读书笔记-排序

【选择排序】

a[i++] —> a[n]，从前往后看、选择最小值、一次交换到位

1，完整循环找到数组中最小的元素；

2，把这个最小的元素与a[0]交换；

3，在a[i]-an的子数组中重复1-2步骤；

1 2 3 4 5 6 7 8 9 10 11 12 13 14

for(int i = 0; i < n; i++) { int min = i; for(int j = i + 1; j < n; j++) { if(a[j] < min) min = j; } swap(i, j, a); }

简写：

1 2 3 4 5

for(int i =0; i < n; i++) { min = //本次循环的i...n中的最小的元素的index； //将min和本次循环的i两个元素交换； }

特点：

选择排序的扫描路线：a[i++] —> a[n]

选择排序是在每个大循环下，通过完整子循环找到最小值后，退出子循环再进行交换，而不是一找到小于关系就交换，每次交换后，左侧的有序数组的位置是最终的；

运行时间和输入无关，扫描数组的次数是固定的，因为大循环和子循环的次数是固定的，前一次扫描并不为下一次扫描提供信息；

交换次数最少，因为是子循环完全结束后才进行一次交换，每次交换的结果都是最后的排序子结果，元素不用做二次挪动；

选择排序是一截一截往后看，将子数组中的最小元素交换到最前头的位置；

选择排序没有最好情况和最坏情况，扫描的次数是固定的，交换的次数已经是所有排序算法中最少的了；

---

【插入排序】

a[j—] —> a[0]，从半路往前看、让元素尝试往前走不动为止

插入排序是一截一截往前看，将倒置的元素交换；对于一个元素，总是尝试往前走，走到不能走为止，因为前面的元素已然有序了，所以走不动的时候左侧元素也是刚刚重新有序；总是相邻元素交换，所以交换次数频繁，一次交换的位置未必是最终位置；

插入排序的扫描路线：a[j—] —> a[0]

1 2 3 4 5 6

for(int i = 1; i < n; i++) { for(int j = i; j > 0 && a[j] < a[j-1]; j--) swap(j, j -1, a); }

每次子循环的结果，左侧的元素肯定是在已知（已经扫描）的数组中有序的，所以每次子循环发生的条件是，如果a[j]小于a[j-1]，则交换，然后继续进行j—之后的扫描；但如果a[j]不小于a[j-1]，因为左侧在已知数组中是有序的，这个时候该子循环就不会发生了；

对已然有序的数组排序，插入排序是线性扫描，0次交换；

插入排序就是解决倒置的两个元素，交换的次数就是倒置的元素个数；

插入排序和选择排序都是平方级的运行时间，但插入排序通常比选择排序快一个常数，因为对于随机的数组来说，插入排序扫描的次数会由于数组中的部分有序而减少，但选择排序不会，必须全扫描；交换，则是插入排序比选择排序次数要多，选择排序交换次数最多不超过n;

---

【归并排序】

先2分排序子数组，再归并成原数组

原地归并算法：

1，先将所有元素赋值到一个新的数组中，此时数组是两截有序的数组；

2， 在原数组上讲新数组中的数本地归并回来：左边用尽取右边；右边用尽取左边；右边当前元素比左边小取右边；右边当前元素大于等于左边取左边；

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

void merge(Comparable[] a, int low, int mid, int hign) { int i = low, j = mid + 1; for(int k = low; k <= hign; k++) aux[k] = a[k]; for(int k = low; k <= hign; k++) if(i > mid) a[k] = aux[j++]; else if(j > hign) a[k] = aux[i++]; else if(aux[j] < aux[i]) a[k] = aux[j++); else a[k] = aux[i++]; }

自顶向下的归并排序：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

sort(a, 0, a.length - 1); void sort(Comparable[] a, int low, int hign) { if(hign < = low) return; int mid = low + (hign - low) / 2; sort(a, low, mid); sort(a, mid + 1, hign); merge(a, low, mid, hign); }

归并算法的思路就是：两个单元素的数组是分别有序的，可以通过merge方法将其归并为一个2元素的有序数组，依此类推，两个a[low]到a[mid]和a[mid+1]到a[hign]的数组分别有序，可以通过merge方法将其归并为一个有序数组a[low]到a[hign]；

归并自上而下，先分拆(sort)直至单元素数组，再归并(merge)回到原数组；

归并算法的几个优化策略：

1，对小规模数组改用插入排序，比如sort方法中发现hign - low <= 10，则用插入排序；

2， 测试数组是否已经有序，就是看a[mid]如果小于等于a[mid+1]，就不用归并了；

归并排序的时间总是NlogN；

跟普通排序不需要额外空间不一样，归并排序是需要额外空间的，跟N成正比；

归并排序是某种程度上的空间换时间算法；

自底向上的归并：

1 2 3 4 5 6 7 8 9 10

void sort(Comparable[] a) { aux = new Comparable[a.length]; for(int sz = 1; sz < a.length; sz = sz + sz) for(int low = 0; low < N - sz; low += sz + sz) merge(a, low, low + sz - 1, Math.min(low + sz + sz - 1, N -1); }

自顶向下是 化整为零，自底向上是循序渐进；

归并排序用了aux辅助数组，是空间复杂度不是最优的；

任何比较排序算法的复杂度都不会低于lg(N!)~NlgN；

---

【快速排序】

每一次切分都使数组左右两边趋于有序

特点：

1， 快速排序是原地排序，只需要一个很小的辅助栈；归并排序无法做到；

2， 复杂度是NlgN；插入、选择等交换排序无法做到；

3， 快速排序的原理：将一个数组分成两个子数组，将两部分独立地排序。

快速排序和归并排序是互补的：

1， 归并排序将数组分成两个子数组分别排序，并将有序的子数组归并以将整个数组排序；快速排序是当两个子数组都有序时整个数组也就自然有序了。

2， 归并排序中，递归调用发生在处理整个数组之前；快速排序中，递归调用发生在处理整个数组之后；

3， 归并排序是数组被等分为两半；快速排序中，切分的位置取决于数组的内容；

算法：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

void sort(Comparable[] a) { random(a) //随机打乱数组，为了比避免每次的切分元素总是子数组中的最小元素 sort(a, 0, a.length - 1); } void sort(Comparable[] a, int low, int hign) { if(hign <= low) return; int j = partition(a, low, hign); sort(a, low, j -1); sort(a, j + 1, hign); }

递归调用切分实现排序的思路：

如果左子数组和右子数组都是有序的，那么由左子数组（有序且所有元素都小于等于切分元素+切分元素+右子数组（有序且所有元素大于等于切分元素）组成的结果数组也一定是有序的；

切分找j的条件

1， 对于某个j，a[j]已经排定；

2， a[low]到a[j - 1]中的所有元素都不大于a[j]；

3， a[j+1]到a[hign]中的所有元素都不小于a[j]；

注意，上面的2， 3说的都是j的左边和右边的元素分别不大于和不小于切分元素，但此时左右两边并不是有序的；

切分算法：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

int partition(Comparable[] a, int low, int hign) { int i = low, j = hign + 1; Comparable v = a[0]; while(true) { while(a[++i] < v) if(i == hign) break; while(a[--j] > v) if(j == low) break; if(i >= j) break; swap(a, i, j); } swap(a, low, j); return j; }

两个小while分别做从左、从右往中间走的动作；

从左边走遇见的比切分元素大的元素，跟从右边走遇见的比切分元素小的元素，交换之;

因为一次大循环中用的都是a[lo]，同一个参考值，那么通过这样的交换，左侧都小，右侧都大;

i, j相遇的最后一次交换，是a[j]被认为小小于切分元素，a[i]被认为大于切分元素，然后他们交换了位置，这一次是相邻交换，—j和—i使得i和j的索引也交换了，所以此时j就是上一次的i的位置，已经被小于切分元素a[lo]的上一次的a[j]给占用了；同时a[i]则是 大于a[lo]的元素；

所以，最后swap(lo, j)，跟开始的切分元素=a[lo]相呼应；

切分的轨迹是这样的 ：

lo….i….j…hi

lo….ij…….hi

lo….ji…….hi

j…..loi…….hi

归并排序是从底往上一层层合并有有序子数组；

快速排序是从上往下，循序渐进，一层层切分下去，每一次切分都使得数组呈两边大小合适状态，切到单元素数组的时候，整个数组基于n多个两边大小合适的小数组，而有序了；

切分元素不一定要选择a[low]，随机选都行；

打乱数组顺序的意义：random(a) //随机打乱数组，为了比避免每次的切分元素总是子数组中的最小元素。

如果每次的切分元素总是最小的元素，那么每一次切分都只是分离成一个元素的数组和一个N-1长度的子数组，这使得数组会被切分N多次；

对于小数组，切换到插入排序能提高效率；

partition方法还可以用来找一个数组中【第k大的元素】：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

int lo = 0, hi = a.length - 1; while(hi > lo) { int j = partition(a, lo, hi); if(j == k) return a[k]; if(j > k) hi = j - 1; if(j < k) lo = j + 1; return a[k];

---

【堆排序】

先使堆有序，再一个个删除最大值，删除即把第一个最大元素往尾部交换以推出堆

上浮和下沉算法：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

void swim(int k) { while(k > 1 && pq[k/2] < pq[k]) { swap(pq, k/2, k); k = k / 2; } void sink(int k) { while(2 * k <= N) { int j = 2 * k; if(j < N && pq[j] < pq[j+1]) //选取两个子节点中较大的一个往上交换 j++; if(pq[k] >= pq[j]) //结束下沉，已经比字节点大了 break; swap(pq, k, j); //下沉 k = j; } public static void sort(Comparable[] a) { int N = a.length; //先使得堆有序 for(int k = N/2; k >= 1; k--) //从右到左扫，因为最终堆有序是右边总比左边小； sink(a, k, N); //只扫描一半，因为一半之后的元素都是叶节点，就是为1的堆 //再进行下沉排序，销毁堆有序 while(N > 1) { //把最大元素删除，然后放入堆缩小后数组中空出的位置 swap(a, 1, N--); //a[1]就是最大元素，把其交换到最后一个，就是从堆有序堆中删除它 sink(a, 1, N); //被交换到a[1]的元素，通过在子堆中下沉，使得子堆再次有序 } //重复这个过程，最大元素总是往后一个一个走，最后整个数组就有序了

堆排序的复杂度：N*lgN，而且是原地排序，无额外空间消耗；

---

【SpaceToTime排序 空间换时间排序法】

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

int i = 0; int max = array[0]; int len = array.length; for(int i = 1; i < len; i++) //找出最大值，做为空间数组的length if(array[i] > max) max = array[i]; int[] temp = new int[max + 1]; for(int i = 0; i < len; i++) temp[array[i]] = array[i]; int j = 0; int max1 = max + 1; for(i = 0; i < max1; i++) { if(temp[i] > 0] array[j++] = temp[i]; } 不计空间成本，把数组值映射到一个临时数组的下标，然后遍历临时数组，把大于0的数顺序放回原数组； 注：temp[i] = i; array[i] > 0;

---

【Java.util.Arrays.sort】

对原始类型用三向切分的快速排序；

对引用类型用归并排序；

---

【Comparable Comparator】

一个类实现了Comparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现，将算法和数据分离，Comparator也可以在下面两种环境下使用：
1、类的设计师没有考虑到比较问题而没有实现Comparable，可以通过Comparator来实现排序而不必改变对象本身
2、可以使用多种排序标准，比如升序、降序等

多键排序，用Comparator；

转载于:https://www.cnblogs.com/mosthink/p/5288803.html