java的希尔排序

希尔排序实际上是一种插入排序的升华

准备待排数组[6 2 4 1 5 9]

首先需要选取关键字,例如关键是3和1(第一步分成三组,第二步分成一组),那么待排数组分成了以下三个虚拟组:

[6 1]一组

[2 5]二组

[4 9]三组

看仔细啊,不是临近的两个数字分组,而是3(分成了三组)的倍数的数字分成了一组,

就是每隔3个数取一个,每隔三个再取一个,这样取出来的数字放到一组,

把它们当成一组,但不实际分组,只是当成一组来看,所以上边的"组"实际上并不存在,只是为了说明分组关系

对以上三组分别进行插入排序变成下边这样

[1 6] [2 5] [4 9]

具体过程:

[6 1]6和1交换变成[1 6]

[2 5]2与5不动还是[2 5]

[4 9]4与9不动还是[4 9]

第一趟排序状态演示:

待排数组:[6 2 4 1 5 9]

排后数组:[1 2 4 6 5 9]

第二趟关键字取的是1,即每隔一个取一个组成新数组,实际上就是只有一组啦,隔一取一就全部取出来了嘛

此时待排数组为:[1 2 4 6 5 9]

直接对它进行插入排序

还记得插入排序怎么排不?复习一下

[1 2 4]都不用动,过程省略,到5的时候,将5取出,在前边的有序数组里找到适合它的位置插入,就是4后边,6前边

后边的也不用改,所以排序完毕

顺序输出结果:[1 2 4 5 6 9]

第二块希尔排序的关键是如何取关键字,因为其它内容与插入排序一样

那么如何选取关键字呢?就是分成三组,一组,这个分组的依据是什么呢?为什么不是二组,六组或者其它组嘞?

好的增量序列的共同特征:

① 最后一个增量必须为1

② 应该尽量避免序列中的值(尤其是相邻的值)互为倍数的情况

这么关键的问题竟然没有一个公式,只给出了两个判定标准

好吧,一般10个待排数字的话,关键依次选取5 3 1即可,其它的情况只能自己判断了,然后看是否符合上述两条"好"的标准

增量的取值规则为第一次取总长度的一半,第二次取一半的一半,依次累推直到1为止。

import java.util.*;
import java.io.*;




class ShellSort
{
int length;
int leng;
int[] sort;
public ShellSort(int[] s)
{
this.sort = s;
}
public static void InsertSort(int[] s)                                                      //插入排序
{
int in,out;
for(out = 1; out < s.length; out++)
{
in = out;
int temp = s[out];
while(in > 0 && (s[in-1] > s[in]))
{
s[in] = s[in-1];
in = in - 1;
s[in] = temp;
}
s[in] = temp;
}
}
public void Sort()                                                           //希尔排序
{
leng = sort.length;
length = sort.length;
while((length/2) != 1)
{
length = length/2;
for(int i = 0; i < length; i++)
{
int temp = sort[i];
if(sort[i] > sort[i+length])
{
sort[i] = sort[i+length];
sort[i+length] = temp;
}
}
}
InsertSort(sort);                                                 //当间隔为1时，选择用插入排序
for(int k = 0; k < leng; k++)
{
System.out.print(sort[k] + " ");
}
}
}




public class DataStructure
{
public static void main(String args[])
{
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int[] a = new int[n];
for(int i = 0 ; i < n; i++)
{
a[i] = scan.nextInt();
}
ShellSort sh = new ShellSort(a);
sh.Sort();
}
}