排序
引言
为什么想起来最近写这一些列的文章，因为最近一个朋友吐槽面试的有6，7年工作经验的员工，连基本的排序都不能实现，所以想了下，如果让自己来做，能不能讲的清楚这一些列的排序。所以就动手写了这一系列的文章，也算是自己了解巩固下。
常用的排序算法
一、冒泡排序
二、选择排序
三、插入排序
四、快速排序
五、堆排序
六、归并排序
七、基数排序
八、希尔排序
九、桶排序
冒泡排序（Bubble Sort）
冒泡排序也称为：沉降排序(SinkingSort)，之所以有这两个名字和他的实现方法有关，因为冒泡排序的实现方式是将数据列表中的最小的数据往前移动，想水里面的气泡一样向上浮。这样也就对应着最大的数据，逐渐往后移动，对应着上浮的就是下沉。
冒泡排序每次只比较相邻的两个数字的大小，再将一个数字和后面数字继续比较大小，一轮比较完成后在比较下一轮数据。知道最终没有数据可以比较位置，排序结束。
Java:
public class BubbleSort {
public static void main(String[] args) {
int[] a = new int[]{9, 2, 7, 8, 5, 6, 3, 4, 1};
for (int i = a.length - 1; i >= 1; i--) {
for (int j = 0; j < i; j++) {
int temp1 = a[j];
int temp2 = a[j + 1];
a[j] = temp1 > temp2 ? temp2 : temp1;
a[j + 1] = temp1 > temp2 ? temp1 : temp2;
printArrays(a);
}
}
}
private static void printArrays(int[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + "、");
}
System.out.println();
}
}
Out:
2、9、7、8、5、6、3、4、1、
2、7、9、8、5、6、3、4、1、
2、7、8、9、5、6、3、4、1、
2、7、8、5、9、6、3、4、1、
2、7、8、5、6、9、3、4、1、
2、7、8、5、6、3、9、4、1、
2、7、8、5、6、3、4、9、1、
2、7、8、5、6、3、4、1、9、
2、7、8、5、6、3、4、1、9、
2、7、8、5、6、3、4、1、9、
2、7、5、8、6、3、4、1、9、
2、7、5、6、8、3、4、1、9、
2、7、5、6、3、8、4、1、9、
2、7、5、6、3、4、8、1、9、
2、7、5、6、3、4、1、8、9、
2、7、5、6、3、4、1、8、9、
2、5、7、6、3、4、1、8、9、
2、5、6、7、3、4、1、8、9、
2、5、6、3、7、4、1、8、9、
2、5、6、3、4、7、1、8、9、
2、5、6、3、4、1、7、8、9、
2、5、6、3、4、1、7、8、9、
2、5、6、3、4、1、7、8、9、
2、5、3、6、4、1、7、8、9、
2、5、3、4、6、1、7、8、9、
2、5、3、4、1、6、7、8、9、
2、5、3、4、1、6、7、8、9、
2、3、5、4、1、6、7、8、9、
2、3、4、5、1、6、7、8、9、
2、3、4、1、5、6、7、8、9、
2、3、4、1、5、6、7、8、9、
2、3、4、1、5、6、7、8、9、
2、3、1、4、5、6、7、8、9、
2、3、1、4、5、6、7、8、9、
2、1、3、4、5、6、7、8、9、
1、2、3、4、5、6、7、8、9、
程序的实现逻辑很简单，变及数组，依次将两个数字做比较，如果小的在大的前面，那么换一个位置，否则位置不换，继续拿大的和后面的比较。重复实现逻辑，为什么外面循环用i--,呢，因为每次我们实现一次排序，总能得到一个最大值，这个值，一定是排在了这个数组的最后一个，所以，最后面的一个我们是不需要比较的，这样无形中也就减少了运算。
从代码实现上来看，冒泡排序的时间复杂度为：O(n2);简单的说执行速度，取决于for循环的次数，链表的大小。
选择排序（Selection sort）
选择排序是一种很直观简单暴力的排序算法，简单的说，就是，先遍历一遍数据，把最小的数据找出来，交换位置，放在第一位，然后在从把后面的链表继续遍历，找出最小数据，然后在，交换位置，继续遍历后续链表。知道全部遍历完成
public static void main(String[] args) {
int[] a = new int[]{9, 2, 7, 8, 5, 6, 3, 4, 1};
for (int i = 0; i < a.length; i++) {
int min = i;
for (int j = i; j < a.length; j++) {
if (a[min] > a[j]) {
min = j;
}
}
int temp = a[i];
a[i] = a[min];
a[min] = temp;
printArrays(a);
}
}
从代码实现上来看，选择排序的时间复杂度为：O(n2);简单的说执行速度，取决于for循环的次数，链表的大小。
上面的排序，我们不难看出，每次排序，其实我们不仅可以找到最小值，还可以找到最大值，这种情况，我们可以将排序算法优化下
public static void main(String[] args) {
int[] a = new int[]{4, 2, 1, 7, 5, 8, 3, 9, 6, 8, 7, 0, 9, 2, 3,10,2,23,1,2,3,2,2,2,2};
for (int i = 0; i < a.length - i; i++) {
int min = i;
int max = i;
for (int j = i; j < a.length - i; j++) {
if (a[min] > a[j]) {
min = j;
}
if (a[max] < a[j]) {
max = j;
}
}
if (min != max) {
int maxTemp = a[a.length - i - 1];
a[a.length - i - 1] = a[max];
a[max] = maxTemp;
int temp = a[i];
if (a[i] > a[min]) {
a[i] = a[min];
a[min] = temp;
}
printArrays(a);
}
}
}
每次排序同时将最小的放在最前面，将最大的放在最右边，循环的时候，也不需要每次都循环到链表的最后段，每次循环都踢掉链表的两端，在进行排序操作.
实际上这两种写法，在效率上相差并不大，下面那种虽然在循环次数上变少了，但是循环类的操作变复杂了。之所以这样写，只是说明下，我么并不是只能每次找最小的数，也可以按照需要，变换写法。
插入排序(Insertion Sort)
插入排序是一种最简单的排序算法，在数据量小的情况下，是一种非常有效的排序方式，
他的核心思想，保证轮询到的数据前面的链表部分是顺序的，将需要比较的数字和前面的排序完成的链表进行比较，插入到一个合适的位置。
public static void main(String[] args) {
int[] a = new int[20];
for (int i = 0; i < 20; i++) {
int random = (int) (Math.random() * 10);
a[i] = random;
}
for (int i = 1; i < a.length; i++) {
int current = a[i];
int seq = i;
while (seq > 0) {
int temp = a[seq - 1];
if (current >= temp) {
break;
} else {
a[seq - 1] = current;
a[seq] = temp;
}
seq--;
}
}
printArrays(a);
}
插入排序比较适合.属于稳定的排序，适合于数据量小，部分数据有序的情况排序。他比较依赖于原链表的混乱程度。
当链表是有序的，也就是最优情况下，每个数只要和前面的一个数想比较，就可以了。这时候的时间复杂度是O(n);
当然逆向来说，如果链表是有序的，但是和我们需要排序的规则是相反的，那么每个数字都要和前面的所有数字比较。这个时候，时间复杂度就变成了O(n2)
欢迎访问个人博客，常见排序算法（一）
424
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
