希尔排序
又称缩小增量法，是对直接插入排序的一种优化。利用直接插入排序在数据越有序时，排序速度越快的特点，通过将待排序数据分成若干组，在一次循环中同时排序，然后逐渐减少所分的组数，到只剩1组时，再进行一次整体排序。直接插入排序因为其越有序越快的特点经常被用在其他排序算法的优化当中。
既然是直接插入排序的一种优化，就需要了解直接插入排序。这种排序方法类似于我们打牌时，将抽到的牌排序的方法。当我们手上只有一张牌时，默认这张牌是有序的，这样就是从第二张牌开始排序，抽到的第二张牌比第一张小，就放到前面，大就放到后面，之后的牌以此类推。直接插入排序是一种稳定的排序，即存在相等的数据时，不会改变两个数据相对的位置。时间复杂度，最好情况，即数据有序为O(n)，最坏情况，即逆序为O(n^2)。
对于希尔排序每一次分的组数是存在一个较好的解的，它的时间复杂度也跟分组有关系，但求这个解是一个复杂的数学问题，一般来说会在O(n^1.3 ~ n^1.5)，这里只是简单的介绍这种排序思路，不对时间复杂度做深入的讨论，直接插入排序和希尔排序的空间复杂度都是O(1)，希尔排序因为是分组调整，数据基本都是跳跃性的进行交换，所以是不稳定的。具体代码如下。
// 直接插入排序
public static void insertSort(int[] array) {
int i = 1; //第一张牌默认有序，所以从下标1开始。
for(; i < array.length; i++) {
int val = array[i]; //存下第i张牌的值。
int j = i - 1;
while(j >= 0 && array[j] > array[i]) {
array[j + 1] = array[j]; //前面的牌往后挪，给新插入的牌腾位置。
j--;
}
array[j + 1] = val; //循环出来要么j走到了第一张牌前面，要么第j张牌比第i张小。
//将第i张牌插入到j+1的位置。
}
}
//希尔排序优化
public static void insertSort(int[] array, int gap) {
int i = gap;
for(; i < array.length; i = i + gap) {
int val = array[i]; //存下第i张牌的值。
int j = i - gap;
while(j >= 0 && array[j] > array[i]) {
array[j + gap] = array[j];
j = j - gap;
}
array[j + gap] = val;
}
}
public static void shellSort(int[] array){
int gap = array.length - 1;//两个数据的下标的差值，例如直接插入排序可以理解为gap=1，即j=j-1;
while(gap > 1) {
insertSort(array, gap);
gap = gap / 2;//缩小范围
}
insertSort(array, 1);//最后对整体做一次排序。
}快速排序
简称快排，它的思路简单来说就是每一次循环找一个基准，将大于基准的数全部放在基准的右边，小于基准的数据全部放在基准的左边，然后递归排序基准的左边和右边，非递归也可以完成快排，但这里就单独介绍递归的代码。快排一般的时间复杂度为O(n*log(n))，数据有序为最差情况，时间复杂度会达到O(n^2)。空间复杂度一般为O(log(n))，最差情况为O(n)。由于数据会出现跳跃性调整，所以快排也是不稳定的排序。
快排找基准。这里简单介绍三种找基准的方法：
①：选择左右。即以首元素为基准或以尾元素为基准，这种方法在数据量较大且数据已经有序或趋于有序的情况下会非常非常的慢。因为取基准分左右其实是将数据分成两部分同时递归排序，而数据越有序，首元素或尾元素就越难将数据分的均匀，数据量一但过大这种取基准的方法可能还会递归过深导致栈溢出。
②：随机选择。随机选数组范围内的一个下标为基准。随机嘛，纯看运气，随的好就快些，不好就慢些。
③：几数取中法。例如三数取中法。我们取数据的首、尾和中间元素，通过比较确定三个元素的中间大小的值，例如3、9、7，中间大小的是7，基准取7就能保证基准的左边和右边至少有一个元素。
快排的优化，快排的优化非常重要，这里简单介绍三种优化的方式。
①：从上述选基准的方式就可以看出，不同的选择方式对于快排的效率存在很大影响，正确的选基准方式是对快排非常好的优化。
②：在 partition的过程中将与基准相等的值放到基准的旁边，这样就可以减小再递归时的递归区间，这个方法并没有在下面的代码中使用到。
③：在排序进行一定的次数之后，数据慢慢趋于有序，这时就可以改用直接插入排序进行优化了，例如当我们对十万个数据排序时，我们可以设定，在待排序数据个数小于一千时，使用直接插入排序，排完直接return。具体代码如下。
public static void quickSort(int[]array) {
int left = 0;
int right = array.length - 1;
quick(array, left, right); //分开写便于调用和理解。
}
public static void quick(int[]array, int left, int right) {
if(left >= right) {
return; //只有一个元素时，默认有序。
}
/*if(right - left + 1 < x) {
当数组剩余的待排序元素个数小于x时，可以调用直接插入排序进行优化。
x的值根据排序数据的总数自行判断调整。
return;
}*/
int mid = (right - left) / 2 + left; //取中间下标，不建议直接使用(right + left) / 2,数据量大时right + left可能超出int的范围
int midIndex = findMidValIndex(array,left,mid,right);//判断三个下标对应的值数哪个是中间大小，然后返回中间值的下标。
swap(array, midIndex, left); //将中间值和left的值交换。
int pivot = partition(array, left, right); //从left开始，right结束，left为基准来分割。
quick(array,left,pivot - 1);
quick(array,pivot + 1, right);//分别对前一次递归分割出的左右进行排序。
}
public static int findMidValIndex(int[]array, int left, int mid, int right) {
if(array[left] > array[right]) {
if(array[left] < array[mid]) {
return left;
} else {
if(array[mid] > array[right]) {
return mid;
} else {
return right;
}
}
} else {
if(array[right] > array[mid]) {
if(array[mid] > array[left]) {
return mid;
} else {
return left;
}
} else {
return right;
}
}
}
public static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static int partition(int[]array, int start, int end) {
int val = array[start]; //保留基准值。
while(start < end) {
while(start < end && array[end] > val) {
end--;
} //从后往前走，指针相遇或者碰到比基准小的值结束循环。
array[start] = array[end];//start的值已经存入val，所以可以将比基准小的值覆盖start原有的值。
while(start < end && array[start] <= val) {
start++;
}
array[end] = array[start];//两个循环结束就可以把大于基准的放在右边，小于基准的放在左边。
}
array[start] = val;//指针相遇，循环结束，基准值放入该下标，此时该下标的左边小于基准，右边大于基准。
return start; //返回下标用于递归数组的左右排序。
}归并排序
归并排序采用分治的思想，将数组不断进行拆分，直到剩下一个元素，因为单个元素默认有序，所以再采用合并有序数组的方法，逐步将拆分的数据合并，就得到了一个有序的数组，归并排序的时间复杂度为O(n*logn)，空间复杂度为O(n)，是一个稳定的排序。与快排一样，这里使用递归的方法完成代码。
合并有序数组，我们先创建一个目标数组，大小为两个需要合并的数组大小之和，不初始化这个数组，然后循环比较，较小的数放入目标数组，目标数组的下标向后，数据较小的数组下标向后，另一个数组下标不动。代码如下。
public static void mergeSort(int[] array) {
int start = 0;
int end = array.length - 1;
mergeSortInternal(array, start, end);
}
public static void mergeSortInternal(int[] array, int start, int end) {
if(start >= end) {
return; //一个元素默认有序。
}
int mid = (end - start) / 2 + start;
mergeSortInternal(array, start, mid);
mergeSortInternal(array, mid + 1, end); //取得中间下标将数组分开后分别递归。
merge(array, start, mid, end); //左右都递归下来后进行合并。
}
public static void merge(int[] array, int start, int mid, int end) {
int i = start;
int j = mid + 1; //将array看做从start到mid和mid+1到end的两个数组。
int length = end - start + 1;
int[] tmp = new int[length]; //定义出长度为上述两个数组的长度之和的数组
int k = 0;
while(i <= mid && j <= end) {
if(array[i] <= array[j]) { //取等号保证排序的稳定性。
tmp[k] = array[i];
k++;
i++;
} else {
tmp[k] = array[j];
k++;
j++;
}
}//较小的数放入tmp，对应的数组下标移动。
while(i <= mid) {
tmp[k] = array[i];
k++;
i++;
}
while(j <= end) {
tmp[k] = array[j];
k++;
j++;
}//将有剩余数据的数组数据放入tmp。
for (int l = 0; l < length; l++) {
array[start + l] = tmp[l];
}//将合并好的数据放回array。
}堆排序
简称堆排，使用堆排序需要对二叉树有一定的了解，进行堆排序时，使用的是大根堆，即父亲节点的值一定比它的子节点大，所以在一个大根堆中，根节点的值一定是这个堆中最大的。设这个大根堆的最后一个下标为end，我们把根节点的值与end的值进行交换，然后对大根堆做向下调整，调整的结束位置为end-1位置。这样一次调整结束end位置就有序了，根节点的值又是end以外最大的值，然后end--；相当于从后往前进行排序，先让大的值有序，这样循环到end为0时，堆就有序了。堆排序的时间复杂度为O(n*logn)，空间复杂度为O(1)。是一个不稳定的排序。代码如下。
public static void heapSort(int[]array, int len) {
createHeap(array); //建堆。
int end = array.length - 1; //确认调整的结束位置。
while(end > 0) {
swap(array, end, 0); //交换end的值和堆顶的值，交换完成后end位置为最大值。
shiftDown(array, end, 0); //再对堆进行调整，因为调整区间为[0,end)，所以end先不减。
end--;
}
}
public static void createHeap(int[] array) {
//从最后一颗子树开始调整，所以parent的值初始化为最后一个节点的父亲节点
for(int parent = (array.length - 1 - 1) / 2; parent >= 0; parent--) {
shiftDown(array, array.length, parent); //对每一个parent做向下调整，创建大根堆。
}
}
public static void shiftDown(int[]array, int len, int parent) {
int child = parent *2 +1; // 求得左孩子节点的下标。
while (child < len) { //保证每一颗子树都被调整，当child超出数组长度时调整结束。
if (child +1 < len) { //判断是否存在右孩子节点。
if (array[child] < array[child +1]) {
child++;
}
} //此时child下标的值就是parent两个孩子的最大值。
if (array[child] > array[parent]) {
swap(array, child, parent); //交换父亲节点与孩子节点的值，保证父亲节点的值最大。
parent = child;
child = parent *2 +1;
} else {
break;
}
}
}小总结
对于上述四种排序方式，稳定的排序方式是归并排序，空间复杂度由低到高为希尔O(1)，堆排O(1)，快排（视情况）O(logn~n)，归并O(n)，时间复杂度归并和堆排都在O(n*logn)，快排视情况而定，如果不进行优化时间复杂度在O(n*longn~n^2)，一般来说快排都是会进行优化的，希尔排序的时间复杂度在数据有序时为O(n)，其余情况视分组而定，一般在O(n^1.3~n^1.5)之间。
2050
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
