之前写到过冒泡排序。但是,冒泡排序需要一个个比较,交换位置。这样会有很多的读写操作,会影响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;
}
优点: 减少了冒泡排序的每次交换;
缺点:不稳定,之前数字大小一样的值,相对位置可能改变。