排序之堆排序

堆排序:

性质:

堆排序是一种基于比较的排序算法,它使用二叉堆数据结构来实现。二叉堆是一种特殊的完全二叉树,它满足以下两个性质:

  1. 结构性:完全二叉树,即除了最后一层外,其他各层的节点数都达到最大,并且最后一层的节点尽可能地集中在左侧。
  2. 堆属性:可以是最大堆或最小堆。在最大堆中,父节点的值总是大于或等于其子节点的值;在最小堆中,父节点的值总是小于或等于其子节点的值。

堆排序步骤:

堆排序的步骤可以分为两个主要部分:

  1. 构建堆(Build Heap)

将一个无序的数组转换成堆结构。这个过程从最后一个非叶子节点开始,向上逐个节点进行下沉(Sift Down)操作,直到达到根节点。下沉操作的目的是确保当前节点满足堆属性。

  1. 堆排序操作(Heap Sort Operation)

一旦构建了堆,就可以进行排序操作。这个过程包括以下步骤:

  • 将堆顶元素(最大或最小元素,取决于是最大堆还是最小堆)与最后一个元素交换。
  • 移除最后一个元素,因为已经排序完成。
  • 对剩下的元素重新进行下沉操作,以维持堆结构。

这个过程重复进行,直到堆中只剩下一个元素,此时整个数组就已经被排序完成。


堆排序的实现细节:

  • 下沉操作(Sift Down):确保某个节点的值大于其子节点的值(对于最大堆)。如果当前节点的值小于其子节点,就与较大的子节点交换,然后继续这个过程,直到当前节点的值大于其子节点,或者成为叶子节点。
cpp 复制代码
// 辅助函数,用于下沉堆中的一个节点
void siftDown(std::vector<int>& arr, int start, int end) {
    int root = start;
    while ((root * 2 + 1) <= end) { // 有左子节点
        int child = root * 2 + 1; // 左子节点索引
        if (child < end && arr[child] < arr[child + 1]) {
            child++; // 右子节点更大
        }
        if (arr[root] < arr[child]) {
            std::swap(arr[root], arr[child]);
            root = child; // 继续下沉
        } else {
            break;
        }
    }
}
  • 构建堆:从最后一个非叶子节点开始,向上逐个节点进行下沉操作。
cpp 复制代码
// 构建堆
void buildHeap(std::vector<int>& arr) {
    for (int i = arr.size() / 2 - 1; i >= 0; --i) {
        siftDown(arr, i, arr.size() - 1);
    }
}
  • 排序:交换堆顶元素与最后一个元素,然后对剩下的元素进行下沉操作,直到堆为空。
cpp 复制代码
// 堆排序
void heapSort(std::vector<int>& arr) {
    buildHeap(arr); // 构建堆
    for (int i = arr.size() - 1; i > 0; --i) {
        std::swap(arr[0], arr[i]); // 交换堆顶元素和最后一个元素
        siftDown(arr, 0, i - 1); // 重新下沉堆顶元素
    }
}

堆排序的优缺点:

1.优点:

  • 原地排序:不需要额外的存储空间。
  • 时间复杂度:O(n log n),对于所有输入都是线性对数级的。

2.缺点:

  • 不稳定:相同的元素在排序后可能会改变原来的顺序。
  • 空间复杂度:虽然原地排序,但递归实现需要一定的栈空间。

堆排序是一种非常实用的排序算法,尤其适用于数据量大且对稳定性要求不高的场景。由于其高效的性能和简单的实现,它在实际应用中非常受欢迎。


实现代码:

堆排序(Heap Sort)是一种高效的排序算法,它利用了二叉堆的数据结构特性。堆排序可以分为两个主要步骤:构建堆(Build Heap)和堆排序操作(Heap Sort Operation)。以下是使用C++实现堆排序的示例代码:

cpp 复制代码
#include <iostream>
#include <vector>
#include <algorithm> // 包含std::sort

// 辅助函数,用于下沉堆中的一个节点
void siftDown(std::vector<int>& arr, int start, int end) {
    int root = start;
    while ((root * 2 + 1) <= end) { // 有左子节点
        int child = root * 2 + 1; // 左子节点索引
        if (child < end && arr[child] < arr[child + 1]) {
            child++; // 右子节点更大
        }
        if (arr[root] < arr[child]) {
            std::swap(arr[root], arr[child]);
            root = child; // 继续下沉
        } else {
            break;
        }
    }
}

// 构建堆
void buildHeap(std::vector<int>& arr) {
    for (int i = arr.size() / 2 - 1; i >= 0; --i) {
        siftDown(arr, i, arr.size() - 1);
    }
}

// 堆排序
void heapSort(std::vector<int>& arr) {
    buildHeap(arr); // 构建堆
    for (int i = arr.size() - 1; i > 0; --i) {
        std::swap(arr[0], arr[i]); // 交换堆顶元素和最后一个元素
        siftDown(arr, 0, i - 1); // 重新下沉堆顶元素
    }
}

int main() {
    std::vector<int> arr = {5, 3, 17, 10, 84, 19, 6, 22, 9};
    std::cout << "Original array:\n";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << "\n";

    heapSort(arr); // 执行堆排序

    std::cout << "Sorted array:\n";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

这段代码首先定义了一个siftDown函数,它用于将堆中的一个节点下沉到合适的位置,以保持堆的性质。接着定义了buildHeap函数,它用于将一个数组转换成一个堆。最后,heapSort函数使用这两个辅助函数来对数组进行排序。

堆排序的时间复杂度是O(n*log n),其中n是数组中元素的数量。堆排序是原地排序算法,不需要额外的存储空间。

相关推荐
van叶~几秒前
算法妙妙屋-------1.递归的深邃回响:二叉树的奇妙剪枝
c++·算法
简简单单做算法1 分钟前
基于Retinex算法的图像去雾matlab仿真
算法·matlab·图像去雾·retinex
云卓SKYDROID16 分钟前
除草机器人算法以及技术详解!
算法·机器人·科普·高科技·云卓科技·算法技术
半盏茶香40 分钟前
【C语言】分支和循环详解(下)猜数字游戏
c语言·开发语言·c++·算法·游戏
徐子童44 分钟前
双指针算法习题解答
算法
想要打 Acm 的小周同学呀1 小时前
LRU缓存算法
java·算法·缓存
劲夫学编程2 小时前
leetcode:杨辉三角
算法·leetcode·职场和发展
毕竟秋山澪2 小时前
孤岛的总面积(Dfs C#
算法·深度优先
浮生如梦_4 小时前
Halcon基于laws纹理特征的SVM分类
图像处理·人工智能·算法·支持向量机·计算机视觉·分类·视觉检测
励志成为嵌入式工程师6 小时前
c语言简单编程练习9
c语言·开发语言·算法·vim