go语言实现堆排序

Dandelion_Promise

已于 2023-03-17 15:27:03 修改

阅读量629

点赞数 2

分类专栏： golang 文章标签： golang 算法排序算法

于 2023-03-17 15:23:48 首次发布

本文链接：https://blog.csdn.net/weixin_42278305/article/details/129619910

版权

golang 专栏收录该内容

19 篇文章

订阅专栏

一、堆排序原理

堆排序指利用堆的性质进行排序的算法。二插堆堆本身是一颗平衡二叉树，节点值需满足以下性质：

大顶堆：所有父节点的值大于大于子节点的值
小顶堆：所有父节点的值小于大于子节点的值

因此，我们可以从堆顶取出元素, 与数组最后一位交换，然后重新维护堆的性质，再取堆顶元素和最后第二位交换…不断交换，直至使数组有序。

二、代码讲解

通常我们用数组来实现堆。下图是数组对应堆的位置关系：
在这里插入图片描述

通过观察我们可以发现，节点为下标为i的元素，有以下性质：

父节点下标为：(i-1) / 2                        ps: 为整除
左孩子节点下标为：2 * i + 1
右孩子节点下标为：2 * i + 2

1.堆化

当我们要给下标为i的节点，调整为满足堆的性质可以这样定义一个方法

/**
* arr 数组
* n 数组长度
* i 下标为i
*/
func heapify(arr []int, n int, i int) {
    // 先定义最大值为下标为i的元素
	largest := i
	lson := 2 * i + 1 // 左孩子下标
	rson := 2 * i + 2 // 右孩子下标
	if lson < n && arr[largest] < arr[lson] {
		largest = lson
	}
	if rson < n && arr[largest] < arr[rson] {
		largest = rson
	}
	// 最大值不是i, 则交换值。交换完之后，子节点同样要满足堆性质，于是递归该下标
	if largest != i {
		arr[largest], arr[i] = arr[i], arr[largest]
		heapify(arr, n, largest)
	}
}

建堆

注意：我们需要从最后一个父节点开始调整堆
长度为n的数组，最后一个元素下标为n-1, 所以它的父级下标为 (n-1-1) / 2 = n/2 - 1

func buildHeap(arr []int) {
    n := len(arr)
	for i:=n/2-1; i>=0; i--{
		heapify(arr, n, i)
	}
}

堆排序

func HeapSort(arr []int) {
 	n := len(arr)
	buildHeap(arr)
	for i := n-1; i>0;i--{
		arr[0], arr[i] = arr[i], arr[0]
		heapify(arr, i, 0)
	}
}

三、完整版代码

package main

import "fmt"

func heapify(arr []int, n int, i int) {
	// 先定义最大值为下标为i的元素
	largest := i
	lson := 2*i + 1 // 左孩子下标
	rson := 2*i + 2 // 右孩子下标
	if lson < n && arr[largest] < arr[lson] {
		largest = lson
	}
	if rson < n && arr[largest] < arr[rson] {
		largest = rson
	}
	// 最大值不是i, 则交换值。交换完之后，子节点同样要满足堆性质，于是递归该下标
	if largest != i {
		arr[largest], arr[i] = arr[i], arr[largest]
		heapify(arr, n, largest)
	}
}

func buildHeap(arr []int) {
	n := len(arr)
	for i := n/2 - 1; i >= 0; i-- {
		heapify(arr, n, i)
	}
}

func HeapSort(arr []int) {
	n := len(arr)
	buildHeap(arr)
	for i := n - 1; i > 0; i-- {
		arr[0], arr[i] = arr[i], arr[0]
		heapify(arr, i, 0)
	}
}

func main() {
	arr := []int{10, 2, 4, 1, 9, 11, 8, 5, 13, 12, 6, 3, 7, 15, 14}
	fmt.Println("排序前:", arr)
	HeapSort(arr)
	fmt.Println("排序后", arr)
}

运行结果：

排序前: [10 2 4 1 9 11 8 5 13 12 6 3 7 15 14]
排序后 [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]