java 数组 希尔排序_Java数据结构和算法(五)--希尔排序和快速排序

在前面复习了三个简单排序Java数据结构和算法(三)--三大排序--冒泡、选择、插入排序，属于算法的基础，但是效率是偏低的，所以现在学习高级排序

插入排序存在的问题：

插入排序在逻辑把数据分为两部分，左边：数据是有序的，右边：数据是无序的

上图中的元素2，是最小的数据，但是在最右边，我们需要和之前的元素进行比较，然后每个元素都要后移，直到找到应该插入的位置，这里

对于元素2来说，所有的元素都要后移一位

这个过程将近存在N次复制，移位的次数平均N/2，所以执行效率是O(N^2)

所以如果能以某种方式不需要一个个移动所有的中间项，就能把较小的数据项移动到左边，那么执行效率会很大的改进

希尔排序：

希尔排序因为计算机科学家Donald L. Shell而闻名，在插入排序的基础上，增加了一个特性，大大提高插入排序的执行效率

通过加大插入排序元素之间的间隔，且在这些有间隔的元素中进行插入排序，从而使数据项大幅度的移动。这样经过一轮排序后，然后减小

数据项的间隔再进行排序，依次进行。进行排序时数据项之间的间隔被称为增量，习惯上用h表示

在完成上面的一轮排序之后，数组中的元素已经"基本有序"，我们知道插入排序对于"基本有序"的数组排序效率是很高的

如果每次插入只需要移动一到两次，算法的效率是O(N)

减小间隔：

对于更大的数组来说，刚开始的间隔应该更大，再逐渐缩小，直到间隔变成1

一般采用2.2来整除得到增量间隔，例如100，间隔分别是45，20，9,4,1，事实证明了这样比用2会整除会显著的改善排序效果

还有一种很常用的间隔序列：knuth 间隔序列 3h+1

图例：

就这样可以完成排序

代码示例：

public class ShellSort {

private long[] elementArray;

private int nItems;

public ShellSort(int max) {

elementArray = new long[max];

nItems = 0;

}

public void insert(long value) {

elementArray[nItems++] = value;

}

public void display() {

for (int i = 0; i < nItems; i++) {

System.out.print(elementArray[i] + " ");

}

System.out.println("");

}

public void sort() {　　//基于knuth容量间隔的希尔排序

int i, j;

long temp;

int h = 1;

while (h <= nItems/3)　　//确定容量间隔

h = h*3+1;

while (h > 0) {　　//保证缩小间隔最终为1

for (i = h; i < nItems; i++) {

temp = elementArray[i];

j = i;

while (j > h-1 && temp < elementArray[j-h]) {　　//这里就是插入排序的逻辑了，每个间隔分组进行排序

elementArray[j] = elementArray[j-h];

j -= h;

}

elementArray[j] = temp;

}

h = (h-1) / 3;

}

}

}

public static void main(String[] args) {

ShellSort shellSort = new ShellSort(10);

shellSort.insert(7);

shellSort.insert(10);

shellSort.insert(1);

shellSort.insert(9);

shellSort.insert(2);

shellSort.insert(5);

shellSort.insert(8);

shellSort.insert(6);

shellSort.insert(4);

shellSort.insert(3);

shellSort.display();

shellSort.sort();

shellSort.display();

}

输出结果：

7 10 1 9 2 5 8 6 4 3

1 2 3 4 5 6 7 8 9 10

分组间隔为2的希尔排序：

public void sort1() {

int i, j;

long temp;

int h;

for (h = nItems/2; h > 0; h /= 2) {

for (i = h; i < nItems; i++) {

temp = elementArray[i];

j = i;

while (j > h-1 && temp < elementArray[j-h]) {

elementArray[j] = elementArray[j-h];

j -= h;

}

elementArray[j] = temp;

}

}

}

相对插入排序，希尔排序稍微复杂一点，如果不能直接理解，可以参考上图，对照代码，一步步理解

希尔排序的效率：

除非在特殊情况，否则无法从理论分析希尔排序的效率，基于各种实验，时间级从O(N^(3/2))-O(N^(7/6))

下图是速度较慢的插入排序和速度较快的快速排序、希尔排序的评估值

快速排序：

毫无疑问，快速排序是最流行的排序算法。因为大多数情况下，快速排序的速度都是最快的，执行时间为O(N*logN)级

快速排序本质上是把一个数组划分为两个子数组，然后递归调用为每个子数组进行快速排序而实现的

左标记i向右移动，直到遇到比pivot大的元素停止，右标记往左移动，直到遇到比pivot小的元素的元素停止，直到i>=j

图例：

代码实现：

public class QuickSort{

public void sort(int[] arr) {

sort(arr, 0, arr.length - 1);

}

private void sort(int[] arr, int left, int right) {

if (right <= left) {

return;

}

//切分

int pivotIndex = partition(arr, left, right);

sort(arr, left, pivotIndex-1);

sort(arr, pivotIndex+1, right);

}

private int partition(int[] arr, int left, int right) {

int i = left;

int j = right+1;

int pivot = arr[left]; //pivot为基准元素，这里选择头文件

while(true){

while(i

while(j > 0 && arr[--j] > pivot){} //右标记往左移动，直到遇到比pivot小的元素，或者到最左边，停止

if(i >= j){ //如果左右标记相遇时候停止，说明没有符合的元素，跳出循环

break;

}else{

swap(arr, i, j);//左右标记在相遇前停止，交换元素，然后继续移动

}

}

swap(arr, left, j);//基准元素和游标相遇时所指元素交换，为最后一次交换

return j;// 一趟排序完成， 返回基准元素位置(注意这里基准元素已经交换位置了)

}

private void swap(int[] arr, int i, int j){

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

}

public static void main(String[] args) {

int []arr = new int[]{7, 10, 1, 9, 2, 5, 8, 6, 4, 3 };

for (int i = 0; i < arr.length; i++) {

System.out.print(arr[i] + " ");

}

System.out.println("");

QuickSort quickSort = new QuickSort();

quickSort.sort(arr);

for (int i = 0; i < arr.length; i++) {

System.out.print(arr[i] + " ");

}

}

输出结果：

7 10 1 9 2 5 8 6 4 3

1 2 3 4 5 6 7 8 9 10

个人感觉快速排序思想很好理解，但是有的代码实现方式，看的真的很头疼，以下代码来自：公众号，相对于上面代码，不利于理解

public class QuickSort{

public static void sort(int[] arr) {

sort(arr, 0, arr.length - 1);

}

private static void sort(int[] arr, int startIndex, int endIndex) {

if (endIndex <= startIndex) {

return;

}

//切分

int pivotIndex = partition(arr, startIndex, endIndex);

sort(arr, startIndex, pivotIndex-1);

sort(arr, pivotIndex+1, endIndex);

}

private static int partition(int[] arr, int startIndex, int endIndex) {

int pivot = startIndex;//取基准值

int index = pivot + 1;//Mark初始化为起始下标

for(int i = index; i <= endIndex; i++){

if(arr[i] < arr[pivot]){

//小于基准值 则mark+1,并交换位置。

swap(arr, i, index);

index ++;

}

}

//基准值与mark对应元素调换位置

swap(arr, pivot, index - 1);

return index - 1;

}

private static void swap(int[] arr, int i, int j) {

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

}

这里代码实现只是左标记从左向右移动，都没有右标记的概念，和他的图解都不一样，理解难度很大

PS：算法理解思想不难，但是手写就有难度了，特别是过了一段时间，很难完全写正确，可以隔段时间写一次，加深记忆，也可以在letcode上刷题

内容参考：