数据结构 排序 java_Java数据结构之排序---希尔排序

希尔排序的基本介绍：

希尔排序同之前的插入排序一样，它也是一种插入排序，只不过它是简单插入排序之后的一个优化的排序算法，希尔排序也被称为缩小增量排序。

希尔排序的基本思想：

希尔排序是把数组中给定的元素按照下标的一定增量进行分组，在分组之后，对每组使用直接插入排序算法；随着增量的减少，每组包含的元素越来越多，当增量减少到1的时候，整个数组正好被分成一组，此时该算法终止。通常我们判断增量是通过：第一次的增量=数组的长度/2(取整)，第二次的增量=第一次的增量/2(取整)...一直到增量为1结束。

希尔排序的示意图：

整个希尔排序我们可以通过两种方式来实现：交换法(用交换排序的思想)，移动法(用插入排序的思想)。在这个例子中，我们给定的数组是int[] arr = {8,9,1,7,2,3,5,4,6,0};

(1).交换法

其中交换法是通过两种方式讲述的：分步骤的实现，整体的实现。具体的解释在代码的注释中，观看注释即可。

(1.1)分步骤的实现

public static void main(String[] args) {

// TODO Auto-generated method stub

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

System.out.println("原始的序列：");

System.out.println(Arrays.toString(arr));

shellSort(arr);

}

//交换法

//希尔排序

public static void shellSort(int[] arr){

//第一趟排序,由于我们数组中打的元素一共有10个，所以我们第一趟选择的增量为10/2=5

int temp = 0;

for(int i=5;i

for(int j=i-5;j>=0;j-=5){ //j代表了与i对应在一个数组中的数。

if(arr[j]>arr[j+5]){ //这里面就是用来比较在同一个数组里面的数字的大小，并且为它们排序

temp = arr[j];

arr[j] = arr[j+5];

arr[j+5] = temp;

}

}

}

System.out.println("第一趟结束后的序列：");

System.out.println(Arrays.toString(arr));

//第二趟序列,这里面的增量是第一趟的增量/2=5/2=2

for(int i=2;i

for(int j=i-2;j>=0;j=j-2){ //同理，跟第一趟相同

if(arr[j]>arr[j+2]){

temp = arr[j];

arr[j] = arr[j+2];

arr[j+2] = temp;

}

}

}

System.out.println("第一趟结束后的序列：");

System.out.println(Arrays.toString(arr));

//第三趟序列,这里面的增量是第二趟的增量/2=2/2=1

for(int i=1;i

for(int j=i-1;j>=0;j=j-1){ //同理，跟第一趟相同

if(arr[j]>arr[j+1]){

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}

}

}

System.out.println("第一趟结束后的序列：");

System.out.println(Arrays.toString(arr));

}

上述代码的最终结果如下：

(1.2)完整的代码

由上述代码，我们可以看到，当我们增量发生改变的时候，我们只是需要改变j的起始值以及定长的值即可，因此我们可以写出完整的代码如下：

public static void main(String[] args) {

// TODO Auto-generated method stub

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

System.out.println("原始的序列：");

System.out.println(Arrays.toString(arr));

shellSort(arr);

}

//交换法

//希尔排序

public static void shellSort(int[] arr){

//完整的希尔排序算法

int temp = 0;

int count = 0;

//gap的值代表了就是每一趟的增量的值

for(int gap = arr.length/2;gap>=1;gap = gap/2){

for(int i=gap;i

for(int j=i-gap;j>=0;j=j-gap){ //这里面同之前的代码，只不过把增量变成了gap

if(arr[j]>arr[j+gap]){

temp = arr[j];

arr[j] = arr[j+gap];

arr[j+gap] = temp;

}

}

}

System.out.println("第"+(++count)+"趟排序后的序列是:");

System.out.println(Arrays.toString(arr));

}

}

(2).移动法

上述代码是希尔排序的选择类的写法，它由一定的缺陷，就是效率的问题，我们每一趟都需要进行比较，这样会使整个代码的时间复杂度增加。因此我们用移动法对其进行优化。代码如下：

public static void main(String[] args) {

// TODO Auto-generated method stub

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

System.out.println("原始的序列：");

System.out.println(Arrays.toString(arr));

shellSort2(arr);

}

//对交换式的希尔排序进行优化，移动法

public static void shellSort2(int[] arr){

int count = 0;

for(int gap = arr.length/2;gap>=1;gap = gap/2){ //这里同上述代码保持不变

//下面的代码根据我们的插入算法一样，只不过之前的插入算法的增量一直是1，这里面的增量是变化的，具体参照之前一章---插入算法

for(int i=gap;i

int minIndex = i-gap; //待插入位置的下标

int temp = arr[i]; //要插入的数

while(minIndex>=0 && temp

arr[minIndex+gap] = arr[minIndex];

minIndex-=gap;

}

arr[minIndex+gap] = temp;

}

System.out.println("第"+( ++count)+"趟排序的结果:");

System.out.println(Arrays.toString(arr));

}

}

上述代码的最终结果如下：