算法__选择排序

   之前写到过冒泡排序。但是，冒泡排序需要一个个比较，交换位置。这样会有很多的读写操作，会影响cpu效率。所以，出现了选择排序。选择排序，每次循环选择最小的数字与这次循环的第一位置的数字，交换位置，直至最后。举个例子，说明一下：

7

2

5

1

3

4

8

6

第一轮：

           1. 7 和2比较，2小，最小变量minNumber=2；

           2. 2和5比较， 2小，最小变量minNumber=2；

           3. 2和1比较，1小，最小变量minNumber=1；

           4. 1和3比较，1小，最小变量minNumber=1；

           5. 1和4比较，1小，最小变量minNumber=1；

           6. 1和8比较，1小，最小变量minNumber=1；

           7. 1和6比较，1小，最小变量minNumber=1，1和7交换；

1

2

5

7

3

4

8

6

第二轮：

          1.  2和5比较，2小，最小变量minNumber=2；

          2.  2和7比较，2小，最小变量minNumber不变；

          3.  2和3比较，2小，最小变量minNumber不变；

          4.  2和4比较，2小，最小变量minNumber不变；

          5.  2和8比较，2小，最小变量minNumber不变；

          6.  2和6比较，2小，最小变量minNumber不变；

1

2

5

7

3

4

8

6

第三轮:

1

2

3

7

5

4

8

6

第四轮：

1

2

3

4

5

7

8

6

第五轮：

1

2

3

4

5

6

8

7

第六轮

1

2

3

4

5

6

7

8

代码如下：

private int[] choseSort1(int[] array) {
        int temp;
        for (int i = 0; i < array.length; i++) {
            temp = i;
            for (int j = i + 1; j < array.length; j++) {
                temp = array[j] < array[temp] ? j : temp;
            }
            if (temp != i) {
                array[i] ^= array[temp];
                array[temp] ^= array[i];
                array[i] ^= array[temp];
            }
        }
        return array;
    }

优点： 减少了冒泡排序的每次交换；

缺点：不稳定，之前数字大小一样的值，相对位置可能改变。