Golang(二十五)[排序算法-希尔排序]

最新推荐文章于 2022-10-04 21:04:42 发布
最新推荐文章于 2022-10-04 21:04:42 发布
阅读量452 收藏
点赞数
分类专栏： Golang 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42366378/article/details/106313825
版权

Golang-排序算法-希尔排序

在这里插入图片描述

1.简介

希尔排序(Shell Sort),又称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

  • 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
  • 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

2.原理

  • 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1.
  • 按增量序列个数 k，对序列进行 k 趟排序.
  • 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度.

3.操作规则

  1. 获取增量（inc）循环
  2. 比较增量差值的下标数据（i = inc; i<len(array);i++ 比较[i-inc]和[inc]）
  3. 规则交换数据

4.Golang代码

1.升序

// 希尔排序-升序
func ShellSortAsc(array []int) {
	// 获取增量（increment） len(array)/2--len(array)/2/2--len(array)/2/2/2...
	for inc := len(array) / 2; inc > 0; inc /= 2 {
		// 假定len(array)= 10,那么inc的取值范围为：5,2,1
		// 获取比较的元素的增量的下标
		for i := inc; i < len(array); i++ {
			// i的取值根据假定的len(array)=10，inc=5的场景下：5,6,7,8,9
			temp := array[i]
			// 比较inc值和i的差值的下标两个元素
			for j := i - inc; j >= 0; j -= inc {
				// j的取值根据假定的len(array)=10，inc=5的场景下：0,1,2,3,4
				// 如果array的增量inc=5对应的下标的值：array[5],array[6],array[7],array[8],array[9]
				// 小于
				// array的增量inc=5的对应的下标的值：array[0],array[1],array[2],array[3],array[4]
				// inc=5,i=5,j=0则让下标为0,1两个数进行有序
				// inc=5,i=6,j=1则让下标为1,2两个数进行有序
				// inc=5,i=7,j=2则让下标为2,3两个数进行有序
				// inc=5,i=8,j=3则让下标为3,4两个数进行有序
				// inc=5,i=9,j=4则让下标为4,5两个数进行有序
				//=======================================
				// inc=2,i=2,j=0则让下标为0,1两个数进行有序
				// inc=2,i=3,j=1则让下标为1,2两个数进行有序
				// inc=2,i=4,j=2则让下标为2,3两个数进行有序
				// inc=2,i=5,j=3则让下标为3,4两个数进行有序
				// inc=2,i=6,j=4则让下标为4,5两个数进行有序
				// inc=2,i=7,j=5则让下标为5,6两个数进行有序
				// inc=2,i=8,j=3则让下标为6,7两个数进行有序
				// inc=2,i=9,j=7则让下标为7,8两个数进行有序
				//=======================================
				// inc=1,i=1,j=0则让下标为0,1两个数进行有序
				// inc=1,i=2,j=1则让下标为1,2两个数进行有序
				// inc=1,i=3,j=2则让下标为2,3两个数进行有序
				// inc=1,i=4,j=3则让下标为3,4两个数进行有序
				// inc=1,i=5,j=4则让下标为4,5两个数进行有序
				// inc=1,i=6,j=5则让下标为5,6两个数进行有序
				// inc=1,i=7,j=3则让下标为6,7两个数进行有序
				// inc=1,i=8,j=7则让下标为7,8两个数进行有序
				// inc=1,i=9,j=8则让下标为8,9两个数进行有序
				if temp < array[j] {
					array[j], array[j+1] = array[j+1], array[j]
				} else {
					break // 如果不满足，则直接退出此层循环
				}
			}
		}
	}
}

2.降序

// 希尔排序-降序
func ShellSortDesc(array []int) {
	// 获取增量（increment） len(array)/2--len(array)/2/2--len(array)/2/2/2...
	for inc := len(array) / 2; inc > 0; inc /= 2 {
		// 假定len(array)= 10,那么inc的取值范围为：5,2,1
		// 获取比较的元素的增量的下标
		for i := inc; i < len(array); i++ {
			// i的取值根据假定的len(array)=10，inc=5的场景下：5,6,7,8,9
			temp := array[i]
			// 比较inc值和i的差值的下标两个元素
			for j := i - inc; j >= 0; j -= inc {
				// j的取值根据假定的len(array)=10，inc=5的场景下：0,1,2,3,4
				// 如果array的增量inc=5对应的下标的值：array[5],array[6],array[7],array[8],array[9]
				// 小于
				// array的增量inc=5的对应的下标的值：array[0],array[1],array[2],array[3],array[4]
				// inc=5,i=5,j=0则让下标为0,1两个数进行有序
				// inc=5,i=6,j=1则让下标为1,2两个数进行有序
				// inc=5,i=7,j=2则让下标为2,3两个数进行有序
				// inc=5,i=8,j=3则让下标为3,4两个数进行有序
				// inc=5,i=9,j=4则让下标为4,5两个数进行有序
				//=======================================
				// inc=2,i=2,j=0则让下标为0,1两个数进行有序
				// inc=2,i=3,j=1则让下标为1,2两个数进行有序
				// inc=2,i=4,j=2则让下标为2,3两个数进行有序
				// inc=2,i=5,j=3则让下标为3,4两个数进行有序
				// inc=2,i=6,j=4则让下标为4,5两个数进行有序
				// inc=2,i=7,j=5则让下标为5,6两个数进行有序
				// inc=2,i=8,j=3则让下标为6,7两个数进行有序
				// inc=2,i=9,j=7则让下标为7,8两个数进行有序
				//=======================================
				// inc=1,i=1,j=0则让下标为0,1两个数进行有序
				// inc=1,i=2,j=1则让下标为1,2两个数进行有序
				// inc=1,i=3,j=2则让下标为2,3两个数进行有序
				// inc=1,i=4,j=3则让下标为3,4两个数进行有序
				// inc=1,i=5,j=4则让下标为4,5两个数进行有序
				// inc=1,i=6,j=5则让下标为5,6两个数进行有序
				// inc=1,i=7,j=3则让下标为6,7两个数进行有序
				// inc=1,i=8,j=7则让下标为7,8两个数进行有序
				// inc=1,i=9,j=8则让下标为8,9两个数进行有序
				if temp > array[j] {
					array[j], array[j+1] = array[j+1], array[j]
				} else {
					break // 如果不满足，则直接退出此层循环
				}
			}
		}
	}
}

3.测试

func main() {
	array := []int{1, 3, 5, 9, 10, 2, 0, 7, 8, 4}
	fmt.Println("原数据：", array)
	ShellSortAsc(array)
	fmt.Println("希尔排序升序：", array)
	ShellSortDesc(array)
	fmt.Println("希尔排序降序：", array)
}

5.完整代码

package main

import "fmt"

// 希尔排序-升序
func ShellSortAsc(array []int) {
	// 获取增量（increment） len(array)/2--len(array)/2/2--len(array)/2/2/2...
	for inc := len(array) / 2; inc > 0; inc /= 2 {
		// 假定len(array)= 10,那么inc的取值范围为：5,2,1
		// 获取比较的元素的增量的下标
		for i := inc; i < len(array); i++ {
			// i的取值根据假定的len(array)=10，inc=5的场景下：5,6,7,8,9
			temp := array[i]
			// 比较inc值和i的差值的下标两个元素
			for j := i - inc; j >= 0; j -= inc {
				// j的取值根据假定的len(array)=10，inc=5的场景下：0,1,2,3,4
				// 如果array的增量inc=5对应的下标的值：array[5],array[6],array[7],array[8],array[9]
				// 小于
				// array的增量inc=5的对应的下标的值：array[0],array[1],array[2],array[3],array[4]
				// inc=5,i=5,j=0则让下标为0,1两个数进行有序
				// inc=5,i=6,j=1则让下标为1,2两个数进行有序
				// inc=5,i=7,j=2则让下标为2,3两个数进行有序
				// inc=5,i=8,j=3则让下标为3,4两个数进行有序
				// inc=5,i=9,j=4则让下标为4,5两个数进行有序
				//=======================================
				// inc=2,i=2,j=0则让下标为0,1两个数进行有序
				// inc=2,i=3,j=1则让下标为1,2两个数进行有序
				// inc=2,i=4,j=2则让下标为2,3两个数进行有序
				// inc=2,i=5,j=3则让下标为3,4两个数进行有序
				// inc=2,i=6,j=4则让下标为4,5两个数进行有序
				// inc=2,i=7,j=5则让下标为5,6两个数进行有序
				// inc=2,i=8,j=3则让下标为6,7两个数进行有序
				// inc=2,i=9,j=7则让下标为7,8两个数进行有序
				//=======================================
				// inc=1,i=1,j=0则让下标为0,1两个数进行有序
				// inc=1,i=2,j=1则让下标为1,2两个数进行有序
				// inc=1,i=3,j=2则让下标为2,3两个数进行有序
				// inc=1,i=4,j=3则让下标为3,4两个数进行有序
				// inc=1,i=5,j=4则让下标为4,5两个数进行有序
				// inc=1,i=6,j=5则让下标为5,6两个数进行有序
				// inc=1,i=7,j=3则让下标为6,7两个数进行有序
				// inc=1,i=8,j=7则让下标为7,8两个数进行有序
				// inc=1,i=9,j=8则让下标为8,9两个数进行有序
				if temp < array[j] {
					array[j], array[j+1] = array[j+1], array[j]
				} else {
					break // 如果不满足，则直接退出此层循环
				}
			}
		}
	}
}

// 希尔排序-降序
func ShellSortDesc(array []int) {
	// 获取增量（increment） len(array)/2--len(array)/2/2--len(array)/2/2/2...
	for inc := len(array) / 2; inc > 0; inc /= 2 {
		// 假定len(array)= 10,那么inc的取值范围为：5,2,1
		// 获取比较的元素的增量的下标
		for i := inc; i < len(array); i++ {
			// i的取值根据假定的len(array)=10，inc=5的场景下：5,6,7,8,9
			temp := array[i]
			// 比较inc值和i的差值的下标两个元素
			for j := i - inc; j >= 0; j -= inc {
				// j的取值根据假定的len(array)=10，inc=5的场景下：0,1,2,3,4
				// 如果array的增量inc=5对应的下标的值：array[5],array[6],array[7],array[8],array[9]
				// 小于
				// array的增量inc=5的对应的下标的值：array[0],array[1],array[2],array[3],array[4]
				// inc=5,i=5,j=0则让下标为0,1两个数进行有序
				// inc=5,i=6,j=1则让下标为1,2两个数进行有序
				// inc=5,i=7,j=2则让下标为2,3两个数进行有序
				// inc=5,i=8,j=3则让下标为3,4两个数进行有序
				// inc=5,i=9,j=4则让下标为4,5两个数进行有序
				//=======================================
				// inc=2,i=2,j=0则让下标为0,1两个数进行有序
				// inc=2,i=3,j=1则让下标为1,2两个数进行有序
				// inc=2,i=4,j=2则让下标为2,3两个数进行有序
				// inc=2,i=5,j=3则让下标为3,4两个数进行有序
				// inc=2,i=6,j=4则让下标为4,5两个数进行有序
				// inc=2,i=7,j=5则让下标为5,6两个数进行有序
				// inc=2,i=8,j=3则让下标为6,7两个数进行有序
				// inc=2,i=9,j=7则让下标为7,8两个数进行有序
				//=======================================
				// inc=1,i=1,j=0则让下标为0,1两个数进行有序
				// inc=1,i=2,j=1则让下标为1,2两个数进行有序
				// inc=1,i=3,j=2则让下标为2,3两个数进行有序
				// inc=1,i=4,j=3则让下标为3,4两个数进行有序
				// inc=1,i=5,j=4则让下标为4,5两个数进行有序
				// inc=1,i=6,j=5则让下标为5,6两个数进行有序
				// inc=1,i=7,j=3则让下标为6,7两个数进行有序
				// inc=1,i=8,j=7则让下标为7,8两个数进行有序
				// inc=1,i=9,j=8则让下标为8,9两个数进行有序
				if temp > array[j] {
					array[j], array[j+1] = array[j+1], array[j]
				} else {
					break // 如果不满足，则直接退出此层循环
				}
			}
		}
	}
}
func main() {
	array := []int{1, 3, 5, 9, 10, 2, 0, 7, 8, 4}
	fmt.Println("原数据：", array)
	ShellSortAsc(array)
	fmt.Println("希尔排序升序：", array)
	ShellSortDesc(array)
	fmt.Println("希尔排序降序：", array)
}

原数据： [1 3 5 9 10 2 0 7 8 4]
希尔排序升序： [0 1 2 3 4 5 7 8 9 10]
希尔排序降序： [10 9 8 7 5 4 3 2 1 0]

蔻蔻哒
关注
专栏目录
希尔排序（golang实现）
书生的博客
09-28 2037
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。 希尔排序是基于插入排序的以下两点性质而提出改进方法的： 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位 希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进...
Golang实现常见排序算法
hello_wcx的博客
09-01 1251
// 1、冒泡排序 func BubbleSort(arr []int) { n := len(arr) flag := true for i := 0; i < n && flag; i++ { flag = false for j := 0; j < n-i-1; j++ { if arr[j] > arr[j+1] { arr[j], arr[j+1] = arr[j+1], arr[j] flag = true } }.
Golang希尔排序
Python私教
11-23 496
原理 1959 年一个叫 Donald L. Shell (March 1, 1924 – November 2, 2015) 的美国人在 Communications of the ACM 国际计算机学会月刊 发布了一个排序算法，从此名为希尔排序的算法诞生了。 希尔排序是直接插入排序的改进版本。因为直接插入排序对那些几乎已经排好序的数列来说，排序效率极高，达到了 O(n) 的线性复杂度，但是每次只能将数据移动一位。希尔排序创造性的可以将数据移动 n 位，然后将 n 一直缩小，缩到与直接插入排序一样为 1。
希尔排序算法
景初浅行
05-12 1309
希尔排序算法 定义：           希尔排序是插入排序的一种，也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。 算法思想：           希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序，随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰好被分为一组，算法终止。    时间复杂度：          O(N)
golang ----------- 希尔排序
田园园野的博客
05-07 364
尔排序属于插入类排序,是将整个有序序列分割成若干小的子序列分别进行 插入排序。如将下面数组进行排序：1、d =len(a)/2=3,036一组，14一组，25一组，如下排序后如下:2、d=d/2=1,只剩全体一组了注意：当数组为偶数时，1~8；开始d=4,15  26  37  48分四组 当数组为奇数时： 1~9；开始d=4,159  26  37  48也分四组，（注意159三个数一组）代码：...
算法代码实现之希尔排序，Golang(Go语言)实现
陈鹏万里
02-28 1241
封装成函数： package sort func ShellSort(a []int) { n := len(a) h := 1 for h n/3 { //寻找合适的间隔h h = 3*h + 1 } for h >= 1 { //将数组变为间隔h个元素有序 for i := h; i n; i++ { //间隔h插入排序 for j := i; j >= h &&
七种排序算法（golang实现）
番茄炒蛋君的博客
08-02 602
冒泡排序 选择排序 冒泡排序 从左到右依次比较两个相邻元素，如果左边元素大于右边元素，就将两者交换；如果左边元素小于等于右边元素，不进行任何操作。 Version1 package main import "fmt" func main() { slice := []int{7, 5, 8, 4, 3, 2, 6, 9, 1} //执行次数 for i := 0; i < len(slice)-1; i++ { //比较次数 for j := 0; j < len(..
golang数据结构与算法——十大排序算法
qq_39280718的博客
08-18 1596
十大排序算法
Go语言学习笔记【13】 排序算法之插入、二分查找插入、希尔排序
LC520730的博客
08-13 319
go语言实现插入、二分查找插入、希尔排序算法
golang十大排序算法
Yp2800的专栏
04-26 341
排序算法 列举了十大排序算法 冒泡排序 插入排序 选择排序 希尔排序 堆排序 归并排序 计数排序 桶排序 基数排序 Golang 代码实现 package main import ( "fmt" "sort" ) func main() { // nums := []int{2, 6, 4, 8, 10, 9, 15} nums := []int{3, 2, 5, 4, 8, 9...
希尔排序｜Golang
最新发布
weixin_42161901的博客
10-04 326
笔记
4. 进阶排序算法——希尔排序（golang）
lihaoen666的博客
04-03 473
希尔排序 前言 插入排序在某些情况下，效率是很高的。 比如我们的记录本身就是基本有序的，只需要少量的插入操作。 再比如，记录少的时候，插入排序效率的优势也是很明显的。 可是现实中，哪有那么理想的情况啊[>_<] 没有环境，那我们就要自己创造啊！！！ 基本有序： 所谓的基本有序就是小的关键字在前面，大的基本在后面，不大不小的基本在中间。 希尔排序的思想核心 关键词： 步长、分...
Go实现希尔排序
微信公众号: 后端码匠
02-12 549
希尔排序 希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。 func Shell2Sort(arr []int) []int { // 进行分组 for gap := len(arr) / 2; gap > 0; gap = gap / 2 { // 插入排序 // i 待排序的元素 for i := gap; i < len(arr); i++ { // j 在比较过程中, 待排序元素的位置 for j := i; j
Go语言实现希尔排序
weixin_51195721的博客
05-17 142
go语言实现希尔排序
希尔排序法
weixin_33738578的博客
05-28 67
        希尔排序法的基本思想是：先选定第一个整数，把待排序文件里全部记录分成个组。例如以下图，第一个整数分为有序组，其余为无序组。         每次处理就是将无序组中的第一个数。与有序组的元素从后往前一次比較，找到合适位置插入。即完毕一次处理；这样一直反复下去，直到无序组中没有元素为止。例如以下图，已清除描写叙述。         排序的目的就是为了使无...
希尔排序法(Shell Sort)
weixin_34163741的博客
05-11 133
希尔排序法(缩小增量法) 属于插入类排序，是将整个无序列分割成若干小的子序列分别进行插入排序的方法。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。 希尔排序是基于插入排序的以下两点性质而提出改进方法的： 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。 ...
希尔排序(Golang)
weixin_33850015的博客
11-12 98
1 2 3 4 5 6 7 8 9 10 11 12 13 funcshellSort(unsorted[]int,nint){ vari,j,gapint vartempint forgap=n/2;gap>0;gap/=2{ for...
Golang 实现的各种排序算法代码详解
"这篇资源是关于使用Go语言（Golang）实现常见排序算法的代码示例，包括冒泡排序、插入排序、希尔排序、选择排序和快速排序。" 在计算机科学中，排序算法是用于对数据序列进行排列的算法。在Golang中，这些排序算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值