排序算法：堆排序，golang实现

幸享龙枫

已于 2024-08-01 15:30:48 修改

阅读量1.4k

点赞数 32

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

于 2024-07-31 16:52:17 首次发布

本文链接：https://blog.csdn.net/longfeng995/article/details/140823241

版权

golang 同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

算法

8 篇文章 0 订阅

订阅专栏

假设 5000 条数据，对比冒泡、选择、插入、快速、归并

前言

在实际场景中，选择合适的排序算法对于提高程序的效率和性能至关重要，本节课主要讲解"堆排序"的适用场景及代码实现。

堆排序

堆排序（Heap Sort）是一种基于比较的排序算法，它利用堆这种数据结构所设计。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。在堆排序算法中，我们通常采用最大堆（每个父节点的值都大于或等于其子节点的值）来进行排序。

代码示例

下面我们使用Go语言实现一个堆排序

1. 算法包

创建一个 pkg/algorithm.go

touch pkg/algorithm.go

（如果看过上节课的快速排序，则已存在该文件，我们就不需要再创建了）

2. 堆排序代码

打开 pkg/algorithm.go 文件，代码如下

从小到大 排序

package pkg

// BubbleSort 冒泡排序
...

// SelectionSort 选择排序
...

// InsertionSort 插入排序
...

// QuickSort 快速排序
...

// partition 分区操作
...

// HeapSort 堆排序
func HeapSort(arr []int) {
	n := len(arr)

	// 构建最大堆
	for i := n/2 - 1; i >= 0; i-- {
		heapify(arr, n, i)
	}

	// 一个个从堆顶取出元素
	for i := n - 1; i >= 0; i-- {
		// 移动当前根到末尾
		arr[i], arr[0] = arr[0], arr[i]

		// 调用 max heapify on the reduced heap
		heapify(arr, i, 0)
	}
}

// heapify 将以 i 为根的子树调整为最大堆
func heapify(arr []int, n int, i int) {
	largest := i // 初始化最大为根
	l := 2*i + 1 // 左子节点
	r := 2*i + 2 // 右子节点

	// 如果左子节点大于根
	if l < n && arr[l] > arr[largest] {
		largest = l
	}

	// 如果右子节点大于当前的最大值
	if r < n && arr[r] > arr[largest] {
		largest = r
	}

	// 如果最大值不是根
	if largest != i {
		arr[i], arr[largest] = arr[largest], arr[i] // 交换

		// 递归地堆化受影响的子树
		heapify(arr, n, largest)
	}
}

3. 模拟程序

打开 main.go 文件，代码如下：

package main

import (
	"demo/pkg"
	"fmt"
)

func main() {
	// 定义一个切片，这里我们模拟 10 个元素
	arr := []int{84, 353, 596, 848, 425, 849, 166, 521, 228, 573}
	fmt.Println("Original data:", arr) // 先打印原始数据
	pkg.HeapSort(arr)                  // 调用堆排序
	fmt.Println("New data:  ", arr)    // 后打印排序后的数据
}

4. 运行程序

go run main.go

能发现， Original data 后打印的数据，正是我们代码中定义的切片数据，顺序也是一致的。

New Data 后打印的数据，则是经过堆排序后的数据，是从小到大的。

5. 从大到小排序

如果需要从大到小排序也是可以的，在代码里，需要将两个 if 判断比较的符号进行修改。

修改 pkg/algorithm.go 文件：

package pkg

// BubbleSort 冒泡排序
...

// SelectionSort 选择排序
...

// InsertionSort 插入排序
...

// QuickSort 快速排序
...

// partition 分区操作
...

// HeapSort 堆排序
func HeapSort(arr []int) {
	n := len(arr)

	// 构建最大堆
	for i := n/2 - 1; i >= 0; i-- {
		heapify(arr, n, i)
	}

	// 一个个从堆顶取出元素
	for i := n - 1; i >= 0; i-- {
		// 移动当前根到末尾
		arr[i], arr[0] = arr[0], arr[i]

		// 调用 max heapify on the reduced heap
		heapify(arr, i, 0)
	}
}

// heapify 将以 i 为根的子树调整为最大堆
func heapify(arr []int, n int, i int) {
	largest := i // 初始化最大为根
	l := 2*i + 1 // 左子节点
	r := 2*i + 2 // 右子节点

	// 如果左子节点小于根
	if l < n && arr[l] < arr[largest] {
		largest = l
	}

	// 如果右子节点小于当前的最大值
	if r < n && arr[r] < arr[largest] {
		largest = r
	}

	// 如果最大值不是根
	if largest != i {
		arr[i], arr[largest] = arr[largest], arr[i] // 交换

		// 递归地堆化受影响的子树
		heapify(arr, n, largest)
	}
}

只需要一丁点的代码即可

从 package pkg 算第一行，上面示例中在第四十四行代码，第四十九行代码，我们将 ">" 改成了 "<" ，这样就变成了从大到小排序了