java、Go实现希尔排序

1. 希尔排序

上篇文章我们讲述了插入排序，其效率高于冒泡以及选择排序，但是插入排序有一个问题就是如果数组中较小的数字在后方，那么数组需要移动的次数是很多的，于效率而言是不好的，由此我们引出了希尔排序。
我们可以将数组中较小的数先放在数组靠前的位置，之后再进行插入排序，这样的话效率肯定会提升，此排序方法就为希尔排序。

2. 实现思路

将数组分为若干个小组，每个小组内进行插入排序。分小组的规则为：定义一个变量，初始时定义其为数组长度的一半，小组内每个元素相距小组长度个距离，每个小组进行插入排序，当最后只剩下一个小组后，进行插入排序以后就可以得到有序数组。

3. 图解

–> 第一趟

对应箭头的颜色即为同一小组，数组长度为10，所以第一次被分为 10/2 个小组，也就是五个。在每个分组内进行插入排序，第一趟排序后：

–>第二趟

如图，将数组分为 5/2个小组，也就是2个小组，每个小组的每个元素之间相距为2，继续在每个小组内进行冒泡排序

4. 实现思路

1. 首先我们发现，我们每次需要分小组，每次将小组数量分为上一次的一半个，所以我们发现这可以使用一个循环进行：
   for(int gap = arr.length/2; gap > 0; gap /= 2)
2. 之后我们只需要关注每一个小组内的冒泡排序了，这就是轻车熟路了，我们首先需要定义一个循环，来进行每个小组内的插入排序
   for (int i = gap; i < arr.length; i++)
3. 进行了两次循环后，我们现在已经分好了组，并且找到了插入排序的需要插入的数据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;
4. 经过以上步骤，等最后剩下一个小组以后，我们还会进行一次插入排序，相当于对数组进行插入排序，那么数组就是有序的了，之后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)

---

以梦为马，不负韶华