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

news2024/9/20 18:48:24

前言

堆排序

代码示例

1. 算法包

2. 堆排序代码

3. 模拟程序

4. 运行程序

5. 从大到小排序

堆排序的思想

堆排序的实现逻辑

1. 构建最大堆

2. 排序

循环次数测试

假如 10 条数据进行排序

假如 20 条数据进行排序

假如 30 条数据进行排序

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

堆排序的适用场景

1. 大数据集排序

2. 外部排序

3. 优先级队列

4. 动态数据排序

前言

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

堆排序

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

代码示例

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

1. 算法包

创建一个 pkg/algorithm.go

mkdir 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 算第一行，上面示例中在第四十四行代码，第四十九行代码，我们将 ">" 改成了 "<" ，这样就变成了从大到小排序了