Golang快速排序

最新推荐文章于 2023-05-18 18:00:30 发布
最新推荐文章于 2023-05-18 18:00:30 发布
阅读量2.2k 收藏 3
点赞数 1
分类专栏： go 文章标签： golang 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37703224/article/details/121485047
版权

介绍

快速排序是一种分治策略的排序算法，是由英国计算机科学家 Tony Hoare 发明的， 该算法被发布在 1961 年的 Communications of the ACM 国际计算机学会月刊。

注： ACM = Association for Computing Machinery，国际计算机学会，世界性的计算机从业员专业组织，创立于1947年，是世界上第一个科学性及教育性计算机学会。

快速排序是对冒泡排序的一种改进，也属于交换类的排序算法。

实现步骤

快速排序通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

步骤如下：

  • 先从数列中取出一个数作为基准数。一般取第一个数。
  • 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
  • 再对左右区间重复第二步，直到各区间只有一个数。

时间复杂度

在最好情况下，每一轮都能平均切分，这样遍历元素只要 n/2 次就可以把数列分成两部分，每一轮的时间复杂度都是：O(n)

最差的情况下，每次都不能平均地切分，每次切分都因为基准数是最大的或者最小的，不能分成两个数列，这样时间复杂度变为了 T(n) = T(n-1) + O(n)，按照主定理计算可以知道时间复杂度为：O(n^2)。

在综合情况下，快速排序的平均时间复杂度为：O(nlogn)。

普通快速排序


// 普通快速排序
func SortQuick(array []int, begin, end int) {
	if begin < end {
		// 进行切分
		loc := partition(array, begin, end)
		// 对左部分进行快排
		SortQuick(array, begin, loc-1)
		// 对右部分进行快排
		SortQuick(array, loc+1, end)
	}
}

// 切分函数，并返回切分元素的下标
func partition(array []int, begin, end int) int {
	i := begin + 1 // 将array[begin]作为基准数，因此从array[begin+1]开始与基准数比较！
	j := end       // array[end]是数组的最后一位

	// 没重合之前
	for i < j {
		if array[i] > array[begin] {
			array[i], array[j] = array[j], array[i] // 交换
			j--
		} else {
			i++
		}
	}

	/* 跳出while循环后，i = j。
	 * 此时数组被分割成两个部分  -->  array[begin+1] ~ array[i-1] < array[begin]
	 *                        -->  array[i+1] ~ array[end] > array[begin]
	 * 这个时候将数组array分成两个部分，再将array[i]与array[begin]进行比较，决定array[i]的位置。
	 * 最后将array[i]与array[begin]交换，进行两个分割部分的排序！以此类推，直到最后i = j不满足条件就退出！
	 */
	if array[i] >= array[begin] { // 这里必须要取等“>=”，否则数组元素由相同的值组成时，会出现错误！
		i--
	}

	array[begin], array[i] = array[i], array[begin]
	return i
}

测试普通快速排序

func TestSortQuick(t *testing.T) {
	list := []int{5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
	SortQuick(list, 0, len(list)-1)
	fmt.Println(list)

	list = []int{-1, 5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
	SortQuick(list, 0, len(list)-1)
	fmt.Println(list)

	list = []int{-1, 11, 22, 33}
	SortQuick(list, 0, len(list)-1)
	fmt.Println(list)
}

测试结果

=== RUN   TestSortQuick
[1 3 4 5 6 6 6 8 9 14 25 49]
[-1 1 3 4 5 6 6 6 8 9 14 25 49]
[-1 11 22 33]
--- PASS: TestSortQuick (0.00s)
PASS

算法改进方案1

// 直接插入排序在小规模数组下效率极好，我们只需将 end-begin <= 4 的递归部分换成直接插入排序，这部分表示小数组排序。
func SortQuick1(array []int, begin, end int) {
	if begin < end {
		// 当数组小于 4 时使用直接插入排序
		if end-begin <= 4 {
			SortInsert(array[begin : end+1])
			return
		}

		// 进行切分
		loc := partition(array, begin, end)
		// 对左部分进行快排
		SortQuick1(array, begin, loc-1)
		// 对右部分进行快排
		SortQuick1(array, loc+1, end)
	}
}

测试

func TestSortQuick1(t *testing.T) {
	list := []int{5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
	SortQuick1(list, 0, len(list)-1)
	fmt.Println(list)

	list = []int{-1, 5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
	SortQuick1(list, 0, len(list)-1)
	fmt.Println(list)

	list = []int{-1, 11, 22, 33}
	SortQuick1(list, 0, len(list)-1)
	fmt.Println(list)
}

测试结果

=== RUN   TestSortQuick1
[1 3 4 5 6 6 6 8 9 14 25 49]
[-1 1 3 4 5 6 6 6 8 9 14 25 49]
[-1 11 22 33]
--- PASS: TestSortQuick1 (0.00s)
PASS

改进方案2


// 三切分的快速排序
func SortQuick2(array []int, begin, end int) {
	if begin < end {
		// 三向切分函数，返回左边和右边下标
		lt, gt := partition3(array, begin, end)
		// 从lt到gt的部分是三切分的中间数列
		// 左边三向快排
		SortQuick2(array, begin, lt-1)
		// 右边三向快排
		SortQuick2(array, gt+1, end)
	}
}

// 切分函数，并返回切分元素的下标
func partition3(array []int, begin, end int) (int, int) {
	lt := begin       // 左下标从第一位开始
	gt := end         // 右下标是数组的最后一位
	i := begin + 1    // 中间下标，从第二位开始
	v := array[begin] // 基准数

	// 以中间坐标为准
	for i <= gt {
		if array[i] > v { // 大于基准数，那么交换，右指针左移
			array[i], array[gt] = array[gt], array[i]
			gt--
		} else if array[i] < v { // 小于基准数，那么交换，左指针右移
			array[i], array[lt] = array[lt], array[i]
			lt++
			i++
		} else {
			i++
		}
	}

	return lt, gt
}

测试

func TestSortQuick2(t *testing.T) {
	list := []int{5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
	SortQuick2(list, 0, len(list)-1)
	fmt.Println(list)

	list = []int{-1, 5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
	SortQuick2(list, 0, len(list)-1)
	fmt.Println(list)

	list = []int{-1, 11, 22, 33}
	SortQuick2(list, 0, len(list)-1)
	fmt.Println(list)
}

测试结果

=== RUN   TestSortQuick2
[1 3 4 5 6 6 6 8 9 14 25 49]
[-1 1 3 4 5 6 6 6 8 9 14 25 49]
[-1 11 22 33]
--- PASS: TestSortQuick2 (0.00s)
PASS

改进方案3

// 伪尾递归快速排序
func SortQuick3(array []int, begin, end int) {
	for begin < end {
		// 进行切分
		loc := partition(array, begin, end)

		// 那边元素少先排哪边
		if loc-begin < end-loc {
			// 先排左边
			SortQuick3(array, begin, loc-1)
			begin = loc + 1
		} else {
			// 先排右边
			SortQuick3(array, loc+1, end)
			end = loc - 1
		}
	}
}

测试

func TestSortQuick3(t *testing.T) {
	list := []int{5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
	SortQuick3(list, 0, len(list)-1)
	fmt.Println(list)

	list = []int{-1, 5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
	SortQuick3(list, 0, len(list)-1)
	fmt.Println(list)

	list = []int{-1, 11, 22, 33}
	SortQuick3(list, 0, len(list)-1)
	fmt.Println(list)
}

测试结果

=== RUN   TestSortQuick3
[1 3 4 5 6 6 6 8 9 14 25 49]
[-1 1 3 4 5 6 6 6 8 9 14 25 49]
[-1 11 22 33]
--- PASS: TestSortQuick3 (0.00s)
PASS

改进方案4


// 非递归快速排序
func SortQuick4(array []int) {

	// 人工栈
	helpStack := new(LinkStack)

	// 第一次初始化栈，推入下标0，len(array)-1，表示第一次对全数组范围切分
	helpStack.Push(len(array) - 1)
	helpStack.Push(0)

	// 栈非空证明存在未排序的部分
	for !helpStack.IsEmpty() {
		// 出栈，对begin-end范围进行切分排序
		begin := helpStack.Pop().(int) // 范围区间左边
		end := helpStack.Pop().(int)   // 范围

		// 进行切分
		loc := partition(array, begin, end)

		// 右边范围入栈
		if loc+1 < end {
			helpStack.Push(end)
			helpStack.Push(loc + 1)
		}

		// 左边返回入栈
		if begin < loc-1 {
			helpStack.Push(loc - 1)
			helpStack.Push(begin)
		}
	}
}

测试

func TestSortQuick4(t *testing.T) {
	list := []int{5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
	SortQuick4(list)
	fmt.Println(list)

	list = []int{-1, 5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
	SortQuick4(list)
	fmt.Println(list)

	list = []int{-1, 11, 22, 33}
	SortQuick4(list)
	fmt.Println(list)
}

测试结果

=== RUN   TestSortQuick4
[1 3 4 5 6 6 6 8 9 14 25 49]
[-1 1 3 4 5 6 6 6 8 9 14 25 49]
[-1 11 22 33]
--- PASS: TestSortQuick4 (0.00s)
PASS

改进方案5


// 非递归快速排序优化
func SortQuickGood(array []int) {

	// 人工栈
	helpStack := new(LinkStack)

	// 第一次初始化栈，推入下标0，len(array)-1，表示第一次对全数组范围切分
	helpStack.Push(len(array) - 1)
	helpStack.Push(0)

	// 栈非空证明存在未排序的部分
	for !helpStack.IsEmpty() {
		// 出栈，对begin-end范围进行切分排序
		begin := helpStack.Pop().(int) // 范围区间左边
		end := helpStack.Pop().(int)   // 范围

		// 进行切分
		loc := partition(array, begin, end)

		// 切分后右边范围大小
		rSize := -1
		// 切分后左边范围大小
		lSize := -1

		// 右边范围入栈
		if loc+1 < end {
			rSize = end - (loc + 1)
		}

		// 左边返回入栈
		if begin < loc-1 {
			lSize = loc - 1 - begin
		}

		// 两个范围，让范围小的先入栈，减少人工栈空间
		if rSize != -1 && lSize != -1 {
			if lSize > rSize {
				helpStack.Push(end)
				helpStack.Push(loc + 1)
				helpStack.Push(loc - 1)
				helpStack.Push(begin)
			} else {
				helpStack.Push(loc - 1)
				helpStack.Push(begin)
				helpStack.Push(end)
				helpStack.Push(loc + 1)
			}
		} else {
			if rSize != -1 {
				helpStack.Push(end)
				helpStack.Push(loc + 1)
			}

			if lSize != -1 {
				helpStack.Push(loc - 1)
				helpStack.Push(begin)
			}
		}
	}
}

测试

func TestSortQuickGood(t *testing.T) {
	list := []int{5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
	SortQuickGood(list)
	fmt.Println(list)

	list = []int{-1, 5, 9, 1, 6, 8, 14, 6, 49, 25, 4, 6, 3}
	SortQuickGood(list)
	fmt.Println(list)

	list = []int{-1, 11, 22, 33}
	SortQuickGood(list)
	fmt.Println(list)
}

测试结果

=== RUN   TestSortQuickGood
[1 3 4 5 6 6 6 8 9 14 25 49]
[-1 1 3 4 5 6 6 6 8 9 14 25 49]
[-1 11 22 33]
--- PASS: TestSortQuickGood (0.00s)
PASS
Python私教
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
quicksort:Golang实施快速排序
05-05
快速排序 该软件包提供了的实验性实现。 有关文档，请参见 。
Golang数据结构与算法----快速排序
apple_51747657的博客
12-20 27
快速排序（QuickSort）是一种常用的、高效的排序算法，属于分治法的一种。它的基本思想是选择一个基准元素，将序列分为两部分，小于基准元素的部分和大于基准元素的部分，然后对这两部分分别递归地进行快速排序。
算法2---归并排序与快速排序（golang）
Sunnyang123的博客
05-18 62
mid:=(left+right)/2 //有可能越界mid:=left+(right-left)/2 //改进1mid := left + (right-left)>>1 //改进2 右移一位比除以2快。
Golang实现快速排序和归并排序以及堆排序算法全注释
努力！奋斗！
06-03 239
快速排序算法 快速排序算法步骤如下： 首先从一个数组里找一个基准 对数组进行遍历 把比基准小的放基准左边，把比基准大的放基准右边 以基准为分割点，分成两个数组重复1-4步骤 直到数组长度为1返回 func quickSort(data []int) { //如果数组长度为1，返回 if len(data) <= 1 { return } //设置基准为数组第一个元素 base := data[0] //两个指针分别指向待交换首尾位置 l, r := 0, len(data)-1
基础算法----快速排序(Quick Sort)
junff
05-03 639
快速排序是一种基于分治思想的比较排序算法 选取一个基准元素(通常是序列的第一个或最后一个元素)作为基准值，小于基准值的元素移到基准值的左边，大于或等于基准值的元素移到基准值的右边 然后分别对左、右子序列递归排序，当左、右子序列排序完成(长度小于等于1)，整个序列的排序完成
Golang（排序篇） —— 快速排序
Huifeng Tang 的博客
03-05 2477
Golang（排序篇） —— 快速排序Golang（排序篇） —— 快速排序快速排序思想复杂度Golang代码参考链接关于作者 Golang（排序篇） —— 快速排序 快速排序思想 1．先从数列中取出一个数作为基准数。（任意位置） 2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。 3．再对左右区间重复第二步，直到各区间只有一个数。 重复第二步，直到所有元素均排序完毕。 复杂度 时间复杂度： O(nlogn) 空间复杂度： 最坏情况 —— O(n) 最优情况 —— O(lo
快速排序 golang
lcf枫的博客
06-17 3596
快速排序 golang 快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），简称快排，一种排序算法，最早由东尼·霍尔提出。在平均状况下，排序 个项目要（大O符号）次比较。在最坏状况下则需要次比较，但这种状况并不常见。 快排应用 快排是一般语言内置排序包中的实现，当然在数组大小不同的情况下会有不同的选择，但是整体以快排为主，为了防止出...
数据结构与算法 — 快速排序（Golang）
Mr_XiMu的博客
03-21 1001
快速排序，基于golang的实现
golang快速排序详解
pardon110的博客
07-15 616
合理假设 对于任意无序数组中的任意一个元素，如何确定它在排序后的索引位置？ 通常思路是先对无序数组排序，后遍历该有序数组，比较与给定的元素值，得到有序索引值。 那么，是否存在一种不对无序数组排序，就可知其指定元素在排序后的索引位置？ 不排序求排序后位置 有序的基础，是按照一定顺序有规律排序。假定是升序，那么排序必为如 a < b <c ， 即，只要找到该值比其前面元素大，比后面的元素小，就可确定它在有序数组中的位置 arr = [25, 84, 21, 46, 13, 27, 68, 35,
golang实现快速排序
whb947514756的博客
04-19 139
2.将数组分为两个字数组：①小于基准值的元素组成的数组，②大于基准值的元素组成的数组。说明：使用递归实现，将一个大的问题划分为多个小的问题， 使用分治法的思想。1.基线条件(即递归停止的条件): len(numlist) < 2。2.递归条件(函数调用自己的条件)：len(numlist) >=2。3.对两个子数组进行快速排序(递归)利用分治法将快速排序分为三步。
GOLANG版的冒泡排序和快速排序分享
12-25
//冒泡排序 func mpSort(array []int) { for i:=0;i;j> array[j+1] { array[j], array[j+1] = array[j+1], ...//快速排序 func quickSort(array []int, left int, right int) { if left < right { key := array
go-基于Golang实现的快速排序算法.zip
最新发布
03-09
go_基于Golang实现的快速排序算法
python 算法 排序实现快速排序
12-25
QUICKSORT(A, p, r)是快速排序的子程序，调用划分程序对数组进行划分，然后递归地调用QUICKSORT(A, p, r)，以完成快速排序的过程。快速排序的最差时间复杂度为O(n2)，平时时间复杂度为O(nlgn)。最差时间复杂度的情况...
使用Go语言开发一款入门级别的桌面程序
Python私教
10-31 5512
第一步：搭建目录 创建module项目：go mod init test_go 第二步：编写主代码 test.go package main import ( "github.com/lxn/walk" . "github.com/lxn/walk/declarative" "strings" ) func main() { var inTE, outTE *walk.TextEdit MainWindow{ Title: "SCREAMO",
Golang可变长数组
Python私教
11-22 3075
可变长数组 代码实现 package zgo_algorithm import ( "fmt" "sync" ) // Array 可变长数组 type Array struct { array []int // 固定大小的数组，用满容量和满大小的切片来代替 len int // 真正长度 cap int // 容量 lock sync.Mutex // 为了并发安全使用的锁 } // MakeArray 新建一个可变长数组 // 时间复杂度
图解Go语言GMP模型
Python私教
11-10 2897
声明 非完全原创，大部分内容来自于学习其他人的理论。如果有侵权，请联系我，可以立即删除掉。 Linux进程的内存使用 CPU对内存的访问 CPU 上有个Memory Management Unit（MMU） 单元 CPU 把虚拟地址给MMU，MMU 去物理内存中查询页表，得到实际的物理地址 CPU 维护一份缓存Translation Lookaside Buffer（TLB），缓存虚拟地址和物理地址的映射关系 进程切换开销 直接开销 切换页表全局目录（PGD） 切换内核态堆栈 切换硬件上下文（进程
Golang数组队列
Python私教
11-22 2846
代码实现 package zgo_algorithm import "sync" // 数组队列，先进先出 // 队列先进先出，和栈操作顺序相反，我们这里只实现入队，和出队操作，其他操作和栈一样。 type ArrayQueue struct { array []interface{} // 底层切片 size int // 队列的元素数量 lock sync.Mutex // 为了并发安全使用的锁 } // 入队 // 直接将元素放在数组最后面即可，和栈一样，时间
Golang循环链表
Python私教
11-22 2757
// 循环链表 type Ring struct { prev *Ring // 前驱节点 next *Ring // 后驱节点 Value interface{} // 数据 } // 初始化空的循环链表，前驱和后驱都指向自己，因为是循环的 func (r *Ring) Init() *Ring { r.next = r r.prev = r return r } // 创建N个节点的循环链表 func New(n int) *Ring { if n &lt.
Golang链表队列
Python私教
11-22 2630
代码实现 链表 // 最简单的链表 type LinkNode struct { Value interface{} Next *LinkNode } 队列 // 链表队列，先进先出 type LinkQueue struct { root *LinkNode // 链表起点 size int // 队列的元素数量 lock sync.Mutex // 为了并发安全使用的锁 } // 入队 // 将元素放在链表的末尾，所以需要遍历链表，时间复杂度为：O(n) func (q
golang快速排序
09-12
golang中的快速排序（Quick Sort）是一种常用的排序算法，它的特点是速度快且效率高。下面我来详细解释一下golang中的快速排序算法。 快速排序的基本思想是通过将待排序的序列分成两部分，一部分小于基准值，一部分...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Python私教

创业不易，请打赏支持我一点吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值