经典排序算法

插入排序

//从待排序列中选出一个元素，插入到已经有序的元素之中，直到所有的元素都插入到有序序列中所有的元素就全部有序了
通常的做法就是将第一个元素看做是有序的元素（即待排序列的第一个元素看做是有序序列），然后我们将第二个元素和有序序列（即第一个元
素）作比较，按正确的序列插入到序列中去。然后在将第三个元素和前面有序序列（即整个待排序列的前两个元素）作比较，将第三个插入到前
两个元素中去，使得前三个元素有序。以此类推，直到所有的元素都有序。
a: 4 、 5 、 3 、1 、9 、7 、6  //把序列分成两个序列，a[0]是有序序列a1，a[1]~a[n-1]为无序序列b1，取b1[cur]=5
		  |
		  | // 取出b1[cur]的值5插入a1序列，b1[cur]右移
		 \ /
a: 4 、 5 、 3 、1 、9 、7 、6  //把序列分成两个序列，a[0]~a[1]是有序序列a1，a[2]~a[n-1]为无序序列b1，b1[cur]=3
		  |
		  | // 取出b1[cur]的值3插入a1序列，b1[cur]右移
		 \ /
a: 3 、 4 、 5 、1 、9 、7 、6  //把序列分成两个序列，a[0]~a[2]是有序序列a1，a[3]~a[n-1]为无序序列b1，b1[cur]=1
		  |
		  | // 取出b1[cur]的值1插入a1序列，b1[cur]右移
		 \ /
a: 1 、 3 、 4 、5 、9 、7 、6  //把序列分成两个序列，a[0]~a[3]是有序序列a1，a[4]~a[n-1]为无序序列b1，b1[cur]=9
		  |
		  | // 取出b1[cur]的值9插入a1序列，b1[cur]右移
		 \ /
a: 1 、 3 、 4 、5 、9 、7 、6  //把序列分成两个序列，a[0]~a[4]是有序序列a1，a[5]~a[n-1]为无序序列b1，b1[cur]=7
		  |
		  | // 取出b1[cur]的值7插入a1序列，b1[cur]右移
		 \ /
a: 1 、 3 、 4 、5 、7 、9 、6  //把序列分成两个序列，a[0]~a[5]是有序序列a1，a[6]~a[n-1]为无序序列b1，b1[cur]=6
		  |
		  | // 取出b1[cur]的值6插入a1序列，b1[cur]右移
		 \ /
a: 1 、 3 、 4 、5 、6 、7 、9  //把序列分成两个序列，a[0]~a[6]是有序序列a1
//时间复杂度O(n^2),首先将一个数插入一个有序序列的时间复杂度为O(n),将n-1个无序序列插入有序序列的次数为n-1

归并排序

设待排序的序列为A（n），n表示元素个数。归并排序的核心是归并（把两个有序的序列合并成一个有序的序列）
//分解：对序列进行分解得到n个有序序列（元素个数为一时可看作有序）
//归并：对两个有序的序列进行合并，假设需要合并的两个序列是a1、b1
比较a1、b1当前指向元素，把小的值赋给c1，并且指针往下移动一位
a1: 1 、 5 、 6 、 9       a1当前指针指向第一个元素1，a1[a_cur]=1
b1: 2 、 4 、 7 、 8       b1当前指针指向第一个元素2, b1[b_cur]=2 
c1: 空
                            |
                            | //比较1 < 2 ， a1[a_cur]后移一位
                           \ /
a1: 1 、 5 、 6 、 9       a1当前指针指向第二个元素5，a1[a_cur]=5
b1: 2 、 4 、 7 、 8       b1当前指针指向第一个元素2, b1[b_cur]=2
c1: 1
                            |
                            | //比较2 < 5， b1[b_cur]后移一位
                           \ /
a1: 1 、 5 、 6 、 9       a1当前指针指向第二个元素5，a1[a_cur]=5
b1: 2 、 4 、 7 、 8       b1当前指针指向第二个元素4, b1[b_cur]=4
c1: 1 、 2                         
                            |
                            | //比较4 < 5， b1[b_cur]后移一位
                           \ /
a1: 1 、 5 、 6 、 9       a1当前指针指向第二个元素5，a1[a_cur]=5
b1: 2 、 4 、 7 、 8       b1当前指针指向第三个元素7, b1[b_cur]=7
c1: 1 、 2 、 4                    
                            |
                            | //比较5 < 7， a1[a_cur]后移一位
                           \ /
a1: 1 、 5 、 6 、 9       a1当前指针指向第三个元素6，a1[a_cur]=6
b1: 2 、 4 、 7 、 8       b1当前指针指向第三个元素7, b1[b_cur]=7
c1: 1 、 2 、 4 、 5    
                            |
                            | //比较6 < 7， a1[a_cur]后移一位
                           \ /
a1: 1 、 5 、 6 、 9       a1当前指针指向第四个元素9，a1[a_cur]=9
b1: 2 、 4 、 7 、 8       b1当前指针指向第三个元素7, b1[b_cur]=7
c1: 1 、 2 、 4 、 5 、 6   
                            |
                            | //比较7 < 9， b1[b_cur]后移一位
                           \ /
a1: 1 、 5 、 6 、 9       a1当前指针指向第四个元素9，a1[a_cur]=9
b1: 2 、 4 、 7 、 8       b1当前指针指向第四个元素8, b1[b_cur]=8
c1: 1 、 2 、 4 、 5 、 6 、 7   
                            |
                            | //比较8 < 9， b1[b_cur]后移一位
                           \ /
a1: 1 、 5 、 6 、 9       a1当前指针指向第四个元素9，a1[a_cur]=9
b1: 2 、 4 、 7 、 8       b1当前指针指向第五个元素null, b1[b_cur]=null,
c1: 1 、 2 、 4 、 5 、 6 、 7  、 8
                            |
                            | //b1不存在当前元素了，直接把a1当前元素及后面的元素按顺序添加到c1序列
                           \ /
a1: 1 、 5 、 6 、 9       a1当前指针指向第五个元素null，a1[a_cur]=null
b1: 2 、 4 、 7 、 8       b1当前指针指向第五个元素null, b1[b_cur]=null
c1: 1 、 2 、 4 、 5 、 6 、 7  、 8 、 9

网上找到的归并排序图解

快速排序

1)假设需要排序的序列为a[n]，取一个值作为基准值(可以取a[0]、a[n/2]、a[n]或者任意一个值)a[tmp]
2)根据选取的基准值把序列一分为二，比基准值小的放到左边，比基准值大的放到右边
3)假设左边序列为a1、右边序列为b1；分别对a1、b1进行1)、2)步操作
//(n)表示上一步的基准值
a: 9 、 12 、 7 、 4 、 19 、 6 、3 、 24
				  |
				  |  //对a[n]进行划分
				 \ /
a: 7 、 4 、 6 、 3 、 (9) 、 12 、19 、 24	 
				  |
				  |  //对a1[a]、b1[b]进行划分
				 \ /
a: 4 、 6 、 3 、 (7) 、 (9) 、 (12) 、19 、 24
				  |
				  |  //对a2[a]、b2[b]进行划分
				 \ /
a: 4 、 6 、 3 、 (7) 、 (9) 、 (12) 、19 、 24
				  |
				  |  //对a3[a]、b3[b]进行划分
				 \ /
a: 3 、 (4) 、 6 、 (7) 、 (9) 、 (12) 、(19) 、 24

放个大佬的图

选择排序

假设需要排序的序列为a[n]
初始temp为0，设a[temp]为最小值，按顺序逐一比较，如果a[i]<a[temp]则temp=i,最后拿到整个序列最小值，把最小值交换到前面，如此执行n-1次可完成排序

a: (3) 、 6、 1 、 3 、 9 、5  // temp = 0 ; a[temp]==3 ---(比较完)----> temp = 2; a[temp]==1;交换位置
			|
			|
		   \ /
a: 1 、 (6)、 3 、 3 、 9 、5  // temp = 1 ; a[temp]==6 ---(比较完)----> temp = 2; a[temp]==3;交换位置
			|
			|
		   \ /	   
a: 1 、 3、 (6) 、 3 、 9 、5  // temp = 2 ; a[temp]==6 ---(比较完)----> temp = 3; a[temp]==3;交换位置
			|
			|
		   \ /	   
a: 1 、 3、 3 、 (6) 、 9 、5  // temp = 3 ; a[temp]==6 ---(比较完)----> temp = 5; a[temp]==5;交换位置
			|
			|
		   \ /	   
a: 1 、 3、 3 、 5 、 (9) 、6  // temp = 4 ; a[temp]==9 ---(比较完)----> temp = 5; a[temp]==6;交换位置
			|
			|
		   \ /	   
a: 1 、 3、 3 、 5 、 6 、(9)  // temp = 5

冒泡排序

相邻两个元素比较，大的（小的也行）放在后面，每一轮冒泡确定一个最大值，并且这个值不参与下一轮的冒泡，经过n-1轮冒泡可得排序

---------》  a: 4 、 6 、 3 、 1 、 8 、 5  
---------》  a: 4 、 3 、 1 、 6 、 5 、 (8)
---------》  a: 3 、 1 、 4 、 5 、 (6) 、 (8)
---------》  a: 1 、 3 、 4 、 (5) 、 (6) 、 (8)
---------》  a: 1 、 3 、 (4) 、 (5) 、 (6) 、 (8)
---------》  a: 1 、 (3) 、 (4) 、 (5) 、 (6) 、 (8)