python 实现heap sort堆排序算法

heap sort堆排序算法介绍

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

堆排序算法可以分为两个主要的过程：

建堆（Heapify）：将无序序列构造成一个堆，根据升序或降序需求选择最大堆或最小堆。
排序：将堆顶元素（最大或最小值）与堆的最后一个元素交换，然后将剩余的n-1个序列重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。
堆排序的步骤

1. 构建最大堆（Build Max Heap）

从最后一个非叶子节点开始，向前遍历到根节点，将每个非叶子节点都调整为最大堆。

2. 堆排序过程
   将堆顶元素（最大值）与堆的最后一个元素交换。
   减少堆的大小（即最后一个元素已经放到了正确的位置，不需要再排序）。
   重新将剩余的部分调整为最大堆。
   重复执行上述过程，直到堆的大小为1。
   Python 示例代码

def heapify(arr, n, i):
    largest = i  # 初始化最大为根
    l = 2 * i + 1     # 左 = 2*i + 1
    r = 2 * i + 2     # 右 = 2*i + 2

    # 如果左子节点大于根节点
    if l < n and arr[i] < arr[l]:
        largest = l

    # 如果右子节点是最大值，并且大于根节点
    if r < n and arr[largest] < arr[r]:
        largest = r

    # 如果最大值不是根节点
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]  # 交换

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

def heapSort(arr):
    n = len(arr)

    # 构建最大堆
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)

    # 一个个从堆顶取出元素
    for i in range(n-1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]   # 交换
        heapify(arr, i, 0)

# 测试代码
arr = [12, 11, 13, 5, 6, 7]
heapSort(arr)
n = len(arr)
print("排序后的数组是")
for i in range(n):
    print("%d" % arr[i], end=" ")

堆排序的性能
时间复杂度：平均和最坏情况都是O(n log n)。
空间复杂度：O(1)，为原地排序。
稳定性：不稳定排序，因为相同的元素可能在排序过程中被交换。
适应性：不适合数据量极小的排序场景，因为建堆过程开销相对较大。

heap sort堆排序算法python实现样例

下面是一个Python实现的堆排序算法：

def heapify(arr, n, i):
    largest = i  # 初始化最大元素为根节点
    left = 2 * i + 1  # 左子节点的索引
    right = 2 * i + 2  # 右子节点的索引
    
    # 如果左子节点存在且大于根节点，则更新最大元素的索引
    if left < n and arr[i] < arr[left]:
        largest = left
    
    # 如果右子节点存在且大于最大元素，则更新最大元素的索引
    if right < n and arr[largest] < arr[right]:
        largest = right
    
    # 如果最大元素不是根节点，则交换根节点和最大元素
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        
        # 递归调整子树
        heapify(arr, n, largest)

def heapSort(arr):
    n = len(arr)
    
    # 从最后一个非叶子节点开始构建最大堆
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)
    
    # 逐个从最大堆中取出元素，放到有序区
    for i in range(n - 1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]  # 将根节点（最大元素）与最后一个元素交换
        heapify(arr, i, 0)  # 重新调整最大堆
        
    return arr

# 示例
arr = [12, 11, 13, 5, 6, 7]
sorted_arr = heapSort(arr)
print(sorted_arr)

输出结果为：[5, 6, 7, 11, 12, 13]