插入排序
1、基本思想
在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数找到相应位置并插入，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。
2、实例
public void insertionSort() {
int len = array.length;
int counter = 1;
for (int i = 1; i < len; i++) {
int temp = array[i]; // 存储待排序的元素值
int insertPoint = i - 1; // 与待排序元素值作比较的元素的下标
while (insertPoint >= 0 && array[insertPoint] > temp) { // 当前元素比待排序元素大
array[insertPoint + 1] = array[insertPoint]; // 当前元素后移一位
insertPoint--;
}
array[insertPoint + 1] = temp; // 找到了插入位置，插入待排序元素
System.out.print("第" + counter + "轮排序结果：");
display();
counter++;
}
}
3、算法分析
在第一趟排序中，插入排序最多比较一次，第二趟最多比较两次，依次类推，最后一趟最多比较N-1次。因此有：
1+2+3+…+N-1 = N*N(N-1)/2
因为在每趟排序发现插入点之前，平均来说，只有全体数据项的一半进行比较，我们除以2得到：
N*N(N-1)/4
复制的次数大致等于比较的次数，然而，一次复制与一次比较的时间消耗不同，所以相对于随机数据，这个算法比冒泡排序快一倍，比选择排序略快。
与冒泡排序、选择排序一样，插入排序的时间复杂度仍然为O(N2)，这三者被称为简单排序或者基本排序，三者都是稳定的排序算法。
如果待排序数组基本有序时，插入排序的效率会更高。
4、插入排序的改进
在插入某个元素之前需要先确定该元素在有序数组中的位置，上例的做法是对有序数组中的元素逐个扫描，当数据量比较大的时候，这是一个很耗时间的过程，可以采用二分查找法改进，这种排序也被称为二分插入排序。
改进后的代码如下：
public void BinaryInsertionSort() {
int len = array.length;
int counter = 1;
for (int i = 1; i < len; i++) {
int temp = array[i]; // 存储待排序的元素值
if (array[i - 1] > temp) { // 比有序数组的最后一个元素要小
int insertIndex = binarySearch(0, i - 1, temp); // 获取应插入位置的下标
for (int j = i; j > insertIndex; j--) { // 将有序数组中，插入点之后的元素后移一位
array[j] = array[j - 1];
}
array[insertIndex] = temp; // 插入待排序元素到正确的位置
}
System.out.print("第" + counter + "轮排序结果：");
// display();
counter++;
}
}
/**
*
* - 二分查找法
* - @param lowerBound 查找段的最小下标
* - @param upperBound 查找段的最大下标
* - @param target 目标元素
* - @return 目标元素应该插入位置的下标
*/
public int binarySearch(int lowerBound, int upperBound, int target) {
int curIndex;
while (lowerBound < upperBound) {
curIndex = (lowerBound + upperBound) / 2;
if (array[curIndex] > target) {
upperBound = curIndex - 1;
} else {
lowerBound = curIndex + 1;
}
}
return lowerBound;
}
还有一种在二分插入排序的基础上进一步改进的排序，称为2-路插入排序，其目的是减少排序过程中移动记录的次数，但为此需要n个记录的辅助空间。
算法的思想为：另设一个和原始待排序列L相同的数组D，首先将L[1]复制给D[1]，并把D[1]看成是已排好序的序列中处于中间位置的元素（枢纽元素），之后将L中的从第二个元素开始依次插入到数组D中，大于D[1]的插入到D[1]之后的序列(此处我称为右半边序列，用的是数组左半部分空间)，小于D[1]的插入到D[1]之前的序列(左半边序列，用的是数组右半部分空间)。
该算法将数组当做首尾衔接的环形结构来使用。
示意图如下：
排序完成之后，数组中的元素并不是按照下标升序排列的，而是靠first与final指针确定起始元素。
注意：当L[1]为最小值时，2-路插入排序失去它的优越性，等同于二分插入排序。
代码如下：
public void two_wayInsertionSort() {
int len = array.length;
int[] newArray = new int[len];
newArray[0] = array[0]; // 将原数组的第一个元素作为枢纽元素
int first = 0; // 指向最小元素的指针
int last = 0; // 指向最大元素的指针
for (int j = 0; j < newArray.length; j++) { // 打印初始化数组
System.out.print(newArray[j] + "\t");
}
System.out.println();
for (int i = 1; i < len; i++) {
if (array[i] >= newArray[last]) { // 大于等于最大元素，直接插入到last后面，不用移动元素
last++;
newArray[last] = array[i];
} else if (array[i] < newArray[first]) { // 小于最小元素，直接插到first前面，不用移动元素
first = (first - 1 + len) % len;
newArray[first] = array[i];
} else if (array[i] >= newArray[0]) { // 在最大值与最小值之间，且大于等于枢纽元素，插入到last之前，需要移动元素
int curIndex = last;
last++;
do { // 比array[i]大的元素后移一位
newArray[curIndex + 1] = newArray[curIndex];
curIndex--;
} while (newArray[curIndex] > array[i]);
newArray[curIndex + 1] = array[i]; // 插入到正确的位置
} else { // 在最大值与最小值之间，且小于枢纽元素，插入到first之后，需要移动元素
int curIndex = first;
first = (first - 1 + len) % len;
do { // 比array[i]小的元素前移一位
newArray[curIndex - 1] = newArray[curIndex];
curIndex = (curIndex + 1 + len) % len;
} while (newArray[curIndex] <= array[i]);
newArray[(curIndex - 1 + len) % len] = array[i]; // 插入到正确的位置
}
for (int j = 0; j < newArray.length; j++) { // 打印新数组中的元素
System.out.print(newArray[j] + "\t");
}
System.out.println();
}
}
如果对如下数组进行排序
8,1,11,12,4,20,7,2,6,15
打印结果如下：
此时，first指向下标为5的元素（1），last指向下标为4的元素（20）。
希尔排序
1、基本思想
希尔排序是基于插入排序的，又叫缩小增量排序。
在插入排序中，标记符左边的元素是有序的，右边的是没有排过序的，这个算法取出标记符所指向的数据，存入一个临时变量，接着，在左边有序的数组中找到临时变量应该插入的位置，然后将插入位置之后的元素依次后移一位，最后插入临时变量中的数据。
试想，假如有一个很小的数据项在靠近右端的位置上，把这个数据项插入到有序数组中时，将会有大量的中间数据项需要右移一位，这个步骤对每一个数据项都执行了将近N次复制。虽然不是所有数据项都必须移动N个位置，但是，数据项平均移动了N/2个位置，一共N个元素，总共是N2/2次复制，这实际上是一个很耗时的过程，希尔排序就是对这一步骤进行了改进，不必一个个的移动所有中间数据项，就能把较小的数据项移动到左边，大大提高了排序效率。
希尔排序通过加大插入排序时元素之间的间隔，并对这些间隔的元素进行插入排序，从而使数据能大跨度地移动。数据项之间的间隔被称为增量，习惯上还用h表示。
下图表示的是增量为4时对10个数据项进行第一轮希尔排序的过程：
此时，数据已经基本有序，所有元素离它在最终有序序列中的位置相差都不超过2个单元，通过创建这种交错的内部有序的数据项集合，把完成排序所需的工作量降到了最小，这也是希尔排序的精髓所在。
2、增量算法
在用java实现希尔排序之前，还有一个问题需要弄清楚，就是这个增量该怎么选择？
最简单的方法是第一轮排序的间隔为N/2，第二趟排序的间隔为N/4，依次类推。但是，实践证明，这种方法有时会使运行时间降到O(N2)，并不比插入排序的效率更高。
保持间隔序列中的数字互质很重要，也就是说，除了1之外它们没有公约数。简单地取间隔为N/2，N/4，N/8…1时，没有遵循这一约束，所以使希尔排序的效率降低。
有很多种有效地生成间隔序列的方法，本文提供一种，下一节的java代码也是按照这种方法来生成间隔序列的。
这种序列生成方法是由Donald Knuth(可以百度一下，图灵奖获得者，一位计算机领域的大牛)提出来的。
数列以逆向的形式从1开始，通过递归表达式：h=3*h+1，来产生后面的间隔。
比如，我们有1000个数据项需要排序，利用h=3*h+1产生的间隔序列为：
1,4,13,40,12,121,364,1093,3280…
第八个数1093显然超出了要排序的元素总数，所以第一轮排序，应该选取的间隔为364，第二轮为121，第三轮为12……
3、实例
public void shellSort() {
int len = array.length;
int counter = 1;
int h = 1;
while (3 * h + 1 < len) { // 确定第一轮排序时的间隔
h = 3 * h + 1;
}
while (h > 0) {
for (int i = 0; i < h; i++) {
shellInsertSort(i, h); // 对间隔为h的元素进行插入排序
}
h = (h - 1) / 3; // 下一轮排序的间隔
System.out.print("第" + counter + "轮排序结果：");
display();
counter++;
}
}
/**
*
* - 希尔排序内部使用的插入排序:
*
* - 需要进行插入排序的元素为array[beginIndex]、array[beginIndex+increment]、array[beginIndex+2*increment]...
*
* - @param beginIndex 起始下标
*
* - @param increment 增量
*/
private void shellInsertSort(int beginIndex, int increment) {
int targetIndex = beginIndex + increment; // 欲插入元素的下标
while (targetIndex < array.length) {
int temp = array[targetIndex];
int previousIndex = targetIndex - increment; // 前一个元素下标，间隔为increment
while (previousIndex >= 0 && array[previousIndex] > temp) {
array[previousIndex + increment] = array[previousIndex]; // 比欲插入数据项大的元素后移一位
previousIndex = previousIndex - increment;
}
array[previousIndex + increment] = temp; // 插入到合适的位置
targetIndex = targetIndex + increment; // 插入下一个元素
}
}
4、算法分析
希尔排序不像其他时间复杂度为O(N log2N)的排序算法那么快，但是比选择排序和插入排序这种时间复杂度为O(N2)的排序算法还是要快得多，而且非常容易实现。它在最坏情况下的执行效率和在平均情况下的执行效率相比不会降低多少，而快速排序除非采取特殊措施，否则在最坏情况下的执行效率变得非常差。
迄今为止，还无法从理论上精准地分析希尔排序的效率，有各种各样基于试验的评估，估计它的时间级介于O(N3/2)与O(N7/6)之间。我们可以认为希尔排序的平均时间复杂度为O(N*(logN)2)。
4136
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
