摘要：
插入排序的一个不错改进。与梳排序类似，希尔排序也用到gap的概念。基本思路是：将原先的一行元素以gap为分界分成几段排成几行，然后按列来用插入排序。不断缩小gap直至1.代码中用到的一个小优化是维基上看到的，据说此比率效率较高，由Knuth提出。另外，还有一个优化基于下面的观察。按照常规思路来说，对于每一个gap，我们应该分别对每一列来做插入排序。但是很显然，不同列之间是不会相互干扰的，因此，在代码中直接从第一列第二个元素开始递增，不断做插入排序。相邻的元素位于不同的列，因此它们并不会影响到彼此，对于同一列的元素，在这一列两个元素之间做了其他什么运算并没影响。这样写代码更加简洁。public 阅读全文
摘要：
冒泡排序的一个不错的改进。与希尔排序有点类似，梳排序在冒泡排序的基础上，提出了gap的概念，使元素的推进快了很多。相当于将原先的一行元素以gap为分界分成几段排成几行，然后按列来用冒泡排序。然后不断缩小gap直至gap为1或元素已经有序（这是冒泡排序的一个特点，凡是改编自冒泡排序（如鸡尾酒排序）都有这个特点，即在遍历过程中就可以确认已经排好序）。public static void combSort(int[] A){ int gap = A.length; boolean unsorted = true; while(gap > 1 || unsorted){ ... 阅读全文
摘要：
Bogo的变种，继续卖萌。。。Bogo每次都随机打乱数组，而Bozo每次随机选择两个位置，然后交换这两个位置的值。相同的是不断靠概率不断查看有序了没。。。public static void bozoSort(int[] A){ Random rand = new Random(); while(!inOrder(A)){ int i = rand.nextInt(A.length); int j = rand.nextInt(A.length); swap(A, i, j); }}Java 阅读全文
摘要：
我不知道这个能不能算排序。。。维基上有这个排序名称。。。但我感觉它纯碎在卖萌。。。基本思路：随机打乱数组，然后看看数组有序了没，如果没？继续随机打乱继续看。。。直至有序。神一般的低效。排几十个数不知道要跑多久。。。public static void bogoSort(int[] A){ while(!inOrder(A)) shuffle(A);}private static boolean inOrder(int[] A){ for(int i = 0; i A[i+1])return false; } return true;}private st... 阅读全文
摘要：
又叫臭皮匠排序。。。在《算法导论》作为反例出现的漂亮但极其低效的排序算法。基本思路是：只要数组长度大于3，先将头与尾排序，然后递归调用排序前三分之二，再递归调用排序后三分之二，最后再递归调用排序前三分之二。冗余计算不少啊。。其实简单来说就是在三个数排序的基础上拓展出来的，相当低效。private static void stoogeSortDo(int[] A, int low, int high){ if(A[low] > A[high]) swap(A, low, high); if(high-low+1 >= 3){ int split = (hi... 阅读全文
摘要：
比较特别的排序方法。每次先对奇数项的元素与相邻下一位排序，然后对偶数项元素与相邻下一位排序。感觉和冒泡有点类似，只是分开了两次做。public static void oddEvenSort(int[] A){ boolean unsorted = true; while(unsorted){ unsorted = false; for(int i = 1; i A[i+1]){ swap(A, i, i+1); unsorted = true; } } ... 阅读全文
摘要：
又一个高效的排序。这个排序算法的基础是大根堆的操作。主要用到的基本操作是将元素下移至适当位置。大根堆即根结点大于叶子结点，通过将一个普通数组的元素从底层开始不断向下移到适当位置，即构造完毕。在排序的时候，通过每次将第一个元素与“最后”的元素交换，再将根结点移到适当的位置。需要注意的是，这个“最后”是指每趟排序都压缩数组后的长度。另外，由0开始存储元素，左结点是2*i+1，右结点是2*i+2.public static void heapSort(int[] A){ makeHeap(A); for(int i = A.length-1; i > 0; i --){ s... 阅读全文
摘要：
这个排序名字很多，又叫摇晃排序，双向冒泡排序等（见维基），是冒泡排序的一个改进。效率会好一点，但还是差不多。冒泡排序每次向一个方向冒一个泡，而这个每次向后冒泡后再向前冒泡。我对这种写法比较有兴趣，不断压缩“数组长度”直至有序或为1.public static void shakerSort(int[] A){ boolean unsorted = true; int top = A.length-1; int bottom = 0; while(unsorted){ unsorted = false; for(int i = bottom; ... 阅读全文
摘要：
公认的高效排序。这次在原来的基础上加上了随机化的选择划分值，降低最坏时间复杂度。写划分函数可能有点困难，常见的有两种方法。一种是填坑法，另一种就是本文的方法。填坑法的思路是：1.预先保存key值；2.从后往前找，找到一个比key值小的数，然后把这个数填到key值的位置；3.从前往后找，找到一个比key值大的数，然后把这个数填到上面的数的原先位置；4.回到第2步，直至两个下标相遇；5.把key值填到下标相遇位置（原来的数已经填到别的地方了）。我以前也一直在写这种方法，因为思路很简单，但是写起来不够简洁。这次用了另外一种方法，可能有点难理解，但代码相当很简洁。我不知道能不能讲清楚。同样需要用到两个 阅读全文
摘要：
相当高效的稳定排序算法，但空间复杂度较大。典型的分治思想。而将两个有序的数组合并起来也很简单，只需另开一个数组再不断取它们的较小值即可。public static void mergeSort(int[] A){ mergeSortDo(A, 0, A.length-1);}private static void mergeSortDo(int[] A, int low, int high){ if(low < high){ int mid = (low + high) / 2; mergeSortDo(A, low, mid); merg... 阅读全文
摘要：
这次用了比较简洁的方式来写，每次都交换两数而不是单纯移项，可能会慢一点，但代码很漂亮。public static void insertionSort(int[] A){ for(int i = 1; i = 0 && A[j] > A[j+1]; j --){ swap(A, j, j+1); } }}Java 阅读全文
摘要：
基本的排序算法，每次找到一个最值然后交换。值得主要的是，有些人实现的时候每次比较后都交换元素，这其实是不必要的，只需记下下标，在一趟结束后再交换即可。public static void selectionSort(int[] A){ for(int i = 0; i < A.length-1; i ++){ int k = i; for(int j = i+1; j < A.length; j ++){ if(A[j] < A[k])k = j; } if(k != i){ swap(A... 阅读全文
摘要：
冒泡排序可能是很多人第一个学的排序算法，思路简单，实现的方式大同小异。这次收到鸡尾酒排序的启发，尝试用另一种方式来写，感觉更加简单清晰。只要还没排好序，每一趟排序结束后都会产生一个正确的位置，而这时将“数组长度”减1，忽略已经有序的元素。public static void bubbleSort(int[] A){ boolean unsorted = true; int top = A.length-1; while(unsorted){ unsorted = false; for(int i = 0; i A[i+1]){ ... 阅读全文