1. 希尔排序
上篇文章我们讲述了插入排序,其效率高于冒泡以及选择排序,但是插入排序有一个问题就是如果数组中较小的数字在后方,那么数组需要移动的次数是很多的,于效率而言是不好的,由此我们引出了希尔排序。
我们可以将数组中较小的数先放在数组靠前的位置,之后再进行插入排序,这样的话效率肯定会提升,此排序方法就为希尔排序。
2. 实现思路
将数组分为若干个小组,每个小组内进行插入排序。分小组的规则为:定义一个变量,初始时定义其为数组长度的一半,小组内每个元素相距小组长度个距离,每个小组进行插入排序,当最后只剩下一个小组后,进行插入排序以后就可以得到有序数组。
3. 图解
–> 第一趟
对应箭头的颜色即为同一小组,数组长度为10,所以第一次被分为 10/2 个小组,也就是五个。在每个分组内进行插入排序,第一趟排序后:
–>第二趟
如图,将数组分为 5/2个小组,也就是2个小组,每个小组的每个元素之间相距为2,继续在每个小组内进行冒泡排序
4. 实现思路
- 首先我们发现,我们每次需要分小组,每次将小组数量分为上一次的一半个,所以我们发现这可以使用一个循环进行:
for(int gap = arr.length/2; gap > 0; gap /= 2) - 之后我们只需要关注每一个小组内的冒泡排序了,这就是轻车熟路了,我们首先需要定义一个循环,来进行每个小组内的插入排序
for (int i = gap; i < arr.length; i++) - 进行了两次循环后,我们现在已经分好了组,并且找到了插入排序的需要插入的数据arr[i],那么我们现在就可以找到其之前的小组内成员,若小于前面的成员,则移位
int insertIndex = i;
int insertValue = arr[i];
while(insertIndex - gap >= 0 && insertValue < arr[insertIndex - gap]){
arr[insertIndex] = arr[insertIndex - gap];
insertIndex -= gap;
}
arr[insertIndex] = insertValue; - 经过以上步骤,等最后剩下一个小组以后,我们还会进行一次插入排序,相当于对数组进行插入排序,那么数组就是有序的了,之后gap/2 = 0,不会进入分组的循环,流程结束
5. 代码
java版本
private static void shellSort(int[] arr){
for (int gap = arr.length/2; gap > 0; gap /= 2){
for (int i = gap; i < arr.length; i++){
int insertIndex = i;
int insertValue = arr[i];
while(insertIndex - gap >= 0 && insertValue < arr[insertIndex - gap]){
arr[insertIndex] = arr[insertIndex - gap];
insertIndex -= gap;
}
arr[insertIndex] = insertValue;
}
}
}
初步测试(10个数据):
public static void main(String[] args) {
int[] arr = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
shellSort(arr);
System.out.println(Arrays.toString(arr));
}
输出:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
速度测试(80000数据):
public static void main(String[] args) {
int[] arr = new int[80000];
Random random = new Random();
for (int i = 0; i < arr.length; i++){
arr[i] = random.nextInt(800000);
}
System.out.println(System.currentTimeMillis());
shellSort(arr);
System.out.println(System.currentTimeMillis());
System.out.println(Arrays.toString(arr));
}
输出:
1585650645547
1585650645559
//下面打印的数组就不复制了,太长了,可以自己粘贴代码测试,不过最好还是自己写一遍
结论:
可以看到,希尔排序可太快咯,比起插入排序的效率已经高了三四层楼那么高了
Go语言版本
//希尔排序
func shellSort(arr []int){
//将数组分小组
for gap := len(arr)/2; gap > 0; gap /= 2 {
//每个小组进行插入排序
for i := gap; i < len(arr); i++ {
insertIndex := i;
insertValue := arr[i];
for {
if (insertIndex - gap < 0 || insertValue >= arr[insertIndex - gap]){
break
}
arr[insertIndex] = arr[insertIndex - gap]
insertIndex -= gap
}
arr[insertIndex] = insertValue
}
}
}
速度测试(80000数据):
func main(){
arr := make([]int, 80000)
t := time.Now()
fomat := t.UnixNano()
rand.Seed(fomat)
for i := 0; i < len(arr); i++{
arr[i] = rand.Intn(80000)
}
t1 := time.Now()
shellSort(arr)
t2 := time.Since(t1)
fmt.Println(t2)
// arr := make([]int, 8)
// queen8(arr, 0)
// fmt.Println(count)
}
结果:
8.9435ms
复杂度分析
希尔排序复杂度比较复杂,这个就不讨论了哈哈哈,反正不是O(n^3)
以梦为马,不负韶华