排序3-堆排序

最新推荐文章于 2022-05-24 15:18:22 发布
最新推荐文章于 2022-05-24 15:18:22 发布
阅读量634 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 堆排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwhlxl/article/details/46679265
版权

基本思想

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以看作是对选择排序的改进。
通常堆是通过一维数组来实现的。在起始数组为0的情形中：

  • 父节点i的左子节点在位置(2*i+1);
  • 父节点i的右子节点在位置(2*i+2);
  • 子节点i的父节点在位置floor((i-1)/2);

在堆的数据结构中，堆中的最大值总是位于根节点。堆中定义以下几种操作：

  • 最大堆调整（Max_Heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点
  • 创建最大堆（Build_Max_Heap）：将堆所有数据重新排序
  • 堆排序（HeapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算

时间复杂度分析

建立N个元素的二叉堆需要花费 O(n) ，在正式排序时，第 i 次取堆顶的数据事，重建堆需要用O(logi)，总共取 n−1 次堆顶，所以重建堆需要花费 O(nlogn) 。因此，堆排序的时间复杂度为 O(nlogn) ，又因为堆排序对原数据的初始状态不敏感，所以最好、最坏和平均时间复杂度均为 O(nlogn) ; 可以原地进行，空间复杂度 O(1) 。

代码实现

最大堆调整有递归和非递归实现方式。

void Heap_adjust(int arr[], int index, int len)
{


    while(true)
    {
        int iMax = index;
        int iLeft = 2 * index + 1;
        int iRight = 2 * index + 2;

        if(iLeft < len && arr[index] < arr[iLeft])
            iMax = iLeft;
        if(iRight < len && arr[iMax] < arr[iRight])
            iMax = iRight;
        if(iMax != index)
        {
            swap(arr[index], arr[iMax]);
            index = iMax;
        }
        else 
            break;
    }



}

void Heap_adjust2(int arr[], int index, int len)
{
    int iMax = index;
    int iLeft = 2 * index + 1;
    int iRight = 2 * index + 2;

    if(iLeft < len && arr[index] < arr[iLeft])
        iMax = iLeft;

    if(iRight < len && arr[iMax] < arr[iRight])
        iMax = iRight;

    if(iMax != index)
    {
        swap(arr[index], arr[iMax]);
        Heap_adjust2(arr, iMax, len);
    }
}

void Build_maxheap(int arr[], int len)
{
    for(int i = len / 2; i >= 0; i --)
    {
        Heap_adjust(arr, i , len);
    }
}

void Heap_Sort(int arr[], int len)
{
    Build_maxheap(arr, len);

    for(int i = len - 1; i > 0; i --)
    {
        swap(arr[0], arr[i]);
        Heap_adjust(arr, 0, i);
    }
}

测试代码

#include <iostream>
#include <cstring>
#include <ctime>
#include <cmath>
using namespace std;


#define ArraySize 100000


void swap(int *x, int *y)
{
    int temp;
    temp = *x;
    *x   = *y;
    *y   = temp;
}

void Bubble_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = i + 1; j < len; j ++)
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
    }
}

void Bubble_sort1(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = len - 1; j >= i; j --)
        {
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
        }
    }
}

void Bubble_sort2(int arr[], int len)
{
    bool flag = true;

    while(flag)
    {
        flag = false;
        for(int i = 0; i < len; i ++)
            for(int j = len - 1; j >= i; j --)
                if(arr[i] > arr[j])
                    swap(arr[i], arr[j]);
    }
}

void Slect_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        int min_index = i ;
        for(int j = i + 1; j < len; j ++)
        {
            if(arr[min_index] > arr[j])
                min_index = j;
        }

        if(i != min_index)
            swap(arr[i],arr[min_index]);
    }
}

void Insert_sort(int arr[], int len)
{

    for(int i= 1; i < len; i ++)
    {   
        int key = arr[i];
        int j = i;
        while(j && arr[j - 1] > key)
        {
            arr[j] = arr[j - 1];
            j --;
        }

        arr[j] = key;
    }
}

void Shell_sort(int arr[], int len)
{
    int increment = len / 2;

    while(increment)
    {
        for(int i = increment; i < len; i ++)
        {
            int key = arr[i];
            /*int j ;
            for(j = i; j >= increment; j -= increment)
            {
                if(arr[j-increment] > key )
                    arr[j] = arr[j-increment];
                else 
                    break;

            }*/

            int j = i;
            while(j >= increment && arr[j-increment] > key)
            {
                arr[j] = arr[j-increment];
                j -= increment;
            }

            arr[j] = key;
        }

        increment /= 2;
    }
}

void Shell_sort1(int arr[], int len)
{
    int increment = 0;
    for(increment = len/2; increment > 0; increment /=2)
    {
        for(int i = increment; i < len; i++)
        {
            int key = arr[i];
            int j = 0;
            for(j = i; j >= increment; j -=increment)
            {
                if(arr[j-increment] > key)
                    arr[j] = arr[j-increment];
                else 
                    break;
            }

            arr[j] = key;
        }
    }
}

void Shell_sort2(int arr[], int len)
{
    int index = log( 2*len + 1) / log(3.0);

    //cout << index << endl;

    int increment = ( pow(3.0, index) - 1 ) / 2;

    //cout << increment << endl;

    while(increment)
    {
        for(int i = increment; i < len; i ++)
        {
            int key = arr[i];
            /*int j ;
            for(j = i; j >= increment; j -= increment)
            {
                if(arr[j-increment] > key )
                    arr[j] = arr[j-increment];
                else 
                    break;

            }*/

            int j = i;
            while(j >= increment && arr[j-increment] > key)
            {
                arr[j] = arr[j-increment];
                j -= increment;
            }

            arr[j] = key;
        }
        index -= 1;
        increment = ( pow(3.0, index) - 1 ) / 2;
    }
}

void Heap_adjust(int arr[], int index, int len)
{


    while(true)
    {
        int iMax = index;
        int iLeft = 2 * index + 1;
        int iRight = 2 * index + 2;

        if(iLeft < len && arr[index] < arr[iLeft])
            iMax = iLeft;
        if(iRight < len && arr[index] < arr[iRight])
            iMax = iRight;
        if(iMax != index)
        {
            swap(arr[index], arr[iMax]);
            index = iMax;
        }
        else 
            break;
    }



}

void Heap_adjust2(int arr[], int index, int len)
{
    int iMax = index;
    int iLeft = 2 * index + 1;
    int iRight = 2 * index + 2;

    if(iLeft < len && arr[index] < arr[iLeft])
        iMax = iLeft;

    if(iRight < len && arr[index] < arr[iRight])
        iMax = iRight;

    if(iMax != index)
    {
        swap(arr[index], arr[iMax]);
        Heap_adjust2(arr, iMax, len);
    }
}

void Build_maxheap(int arr[], int len)
{
    for(int i = len / 2; i >= 0; i --)
    {
        Heap_adjust(arr, i , len);
    }
}

void Heap_Sort(int arr[], int len)
{
    Build_maxheap(arr, len);

    for(int i = len - 1; i > 0; i --)
    {
        swap(arr[0], arr[i]);
        Heap_adjust(arr, 0, i);
    }
}

void Print_array(int arr[], int len)
{
    for(int i = 0; i < len; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;

}

int main(int argc, char const *argv[])
{
    /* code */
    int Array[ArraySize];
    int Array1[ArraySize];
    int Array2[ArraySize];

    time_t begin , end;

    srand(time(NULL));



    for(int i = 0; i < ArraySize; i ++)
    {
        Array[i] = rand()%ArraySize;
        //cout << Array[i] << " ";
    }

    memcpy(Array1, Array, ArraySize * sizeof(Array1[0]));
    memcpy(Array2, Array, ArraySize * sizeof(Array2[0]));

//  Print_array(Array, ArraySize);

/*  begin = clock();
    Bubble_sort2(Array, ArraySize);
    end = clock();
    cout << "Bubble_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Slect_sort(Array1, ArraySize);
    end = clock();
    cout << "Slect_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Insert_sort(Array2, ArraySize);
    end = clock();
    cout << "Insert_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;*/ 

    begin = clock();
    Shell_sort1(Array1, ArraySize);
    end = clock();
    cout << "Shell_sort1 runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Shell_sort2(Array2, ArraySize);
    end = clock();
    cout << "Shell_sort2 runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Heap_Sort(Array, ArraySize);
    end = clock();
    cout << "Heap_Sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    //Print_array(Array2, ArraySize);
    return 0;
}

运行结果如下：

Shell_sort1 runtime:   0.038s
Shell_sort2 runtime:   0.021s
Heap_Sort runtime:   0.026s

参考资料

堆排序 - 维基百科，自由的百科全书
https://zh.wikipedia.org/wiki/%E5%A0%86%E6%8E%92%E5%BA%8F
常见排序算法 - 堆排序 (Heap Sort) | bubkoo
http://bubkoo.com/2014/01/14/sort-algorithm/heap-sort/

zengwh513
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Jvm-3—堆
光天化日红裤衩
06-27 122
所有的对象实例以及数组都是分配在堆上。栈中保存引用，指向对象或数组在堆中的位置。 一般研究的堆空间为年轻代和养老代。
详解Java常用排序算法-堆排序
08-26
堆排序算法详解 堆排序是一种树形选择排序算法，它的基本思想是将待排序的数组构建成一个大根堆（或小根堆），然后将堆顶元素与堆底元素交换位置，再将剩余元素重新构建成堆，重复执行交换和重构堆的操作，直到整个...
C# 堆排序
数据库
01-08 182
using System; using System.Collections; namespace Sort { public class HeapSorter { public static int[] Sort(int[] sortArray) { BuildMaxHeap(sortArray); ...
3 堆排序
梵高先生的专栏
02-24 230
堆排序 Profile 堆排序结合了插入排序(原地排序)和归并排序(时间复杂度)的优点。堆排序基于一种数据结构——堆。这里说的堆不是指JAVA虚拟机中存储对象的内存空间。堆分为最大堆、最小堆，不仅可以用来实现堆排序，更常见的是实现优先级队列，比如JAVA JDK中的PriorityQueue类就是以堆为数据结构基础实现的。这里暂且不写优先级队列的实现，实现成优先级队列，当然最好是写成一个类...
数据结构学习-3-堆
windy杨树的博客
12-26 113
目录 1 堆的基础概念 2 堆的实现 　2.1 实现一个堆类 　2.2 将无序数组调整为最大堆 1 堆的基础概念 最大堆：父节点要比每一个子节点的值都要大 最小堆：父节点要比每一个子节点的值都要小 堆可以看做是一个完全二叉树的数组对象 堆的出队入队时间复杂度如下图所示： 2 堆的实现 2.1 实现一个堆类 利用数组实现一个堆的原理： 自上而下，自左向右对每一个节点标上...
3.11 堆的概念及堆排序思路
bloger博客
03-23 260
Chapter3: 更好的查找与排序算法 11. 堆的概念及堆排序 [1] 图解排序算法(三)之堆排序 讲得很好，这里相当于写个精简大纲版并将java代码转换为C++代码 堆的相关概念 堆排序概述 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。首先简单了解下堆结构。 堆的概念 堆是具有以下...
挑战七大排序算法-04堆排序
01-07
堆排序 1.原理 2.实现 3.性能分析 堆排序 1.原理 基本原理也是选择排序，只是不再使用遍历的方式查找无序区间的最大数，而是通过堆来选择无序区间的最大数 升序：大顶堆；降序：小顶堆 堆排序的基本思路： a.将无需...
排序算法-堆排序
07-18
4. **重复步骤2-3**：直到堆的大小为1，排序完成。 在`堆排序.cpp`文件中，可能会包含以下关键函数： - `heapify()`: 这个函数用于调整堆，确保父节点满足堆的性质。 - `buildHeap()`: 初始化堆，通常从最后一个非...
java代码-堆排序-----
07-16
堆排序是一种基于比较的排序算法，它利用了数据结构中的“堆”这一概念。在Java中，实现堆排序主要涉及到数组和优先队列（堆）的知识。本文将深入讲解堆排序的基本原理、Java代码实现以及如何阅读和理解提供的`main....
堆排序.txt-堆排序
01-26
算法
算法课3-堆和优先队列
srping123的博客
10-14 151
堆的性质 堆是一个完全二叉树（最后一层的节点都在左边） 一般都用数组来表示堆，i结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 1和2 * i + 2 建堆 O(N) 合并两个堆的时间复杂度和建堆相同 把元素插入堆和把某元素删除，时间复杂度O(logn) 每次插入都是将先将新数据放在数组最后，由于从这个新数据的父结点到根结点必然为一个有序的序列，将新数据与其...
各排序算法比较
发现问题，并解决问题，批判性思维
02-25 3012
各个排序算法的时间复杂度简记： 一般的都是最好n最坏n方四个特例快排因为快所以好的时候可以达到nlogn堆跟归并一样好坏都是nlogn但归并需要空间另外还有一个特殊的是选择因为它每次都要挑最大最小所以都是n方以上。 ...
数据结构：排序趟数 / 比较次数与序列的原始状态有关的排序方法有哪些？
热门推荐
寒泉
10-26 10万+
先说结论 比较次数 与序列初态 无关 的算法是：二路归并排序、简单选择排序、基数排序 比较次数 与序列初态 有关 的算法是：快速排序、直接插入排序、冒泡排序、堆排序、希尔排序 排序趟数 与序列初态 无关 的算法是：直接插入排序、折半插入排序、希尔排序、简单选择排序、归并排序、基数排序 排序趟数与序列初态 有关 的算法是：冒泡排序、快速排序 关于排序趟数 插入排序、选择排序 趟数都是固定的 n-1。对于插入排序来说或，即使序列有序，也要依次从第二个元素开始，向前找它的插入位置。 冒泡排序 趟数与数据有关，优
不简单的选择排序—堆排序算法(5)
qq_43656353的博客
05-24 294
堆排序算法 堆排序(Heap Sort)就是利用堆(假设利用大堆顶)进行排序的方法。它的基本思想是，将待排序的序列构造成一个大堆顶。此时，整个序列的最大值就是堆顶的根节点。将它移走(其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值)，然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次大值。如此反复执行，便能得到一个有序序列了。 /* 对顺序表L作堆排序*/ #include <stdio.h> #define MAXSIZE 10 typedef struct {
堆和栈的区别
climbs的专栏
11-16 1652
1.堆和栈的区别 　　一、堆栈空间分配区别： 　　1、栈（操作系统）：由操作系统自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈； 　　2、堆（操作系统）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。 　　二、堆栈缓存方式区别： 　　1、栈使用的是一级缓存，他们通常都是被调用时处于存储空间中，调用完毕立即释放； 　...
排序算法之堆排序
qq_44290077的博客
08-11 2960
简介         堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。         堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即父节点结点的键值或索引总是小于（或者大于）它的子节点。 堆的概念         在介绍堆排序之前，简单介
堆排序（C++）
weixin_44806108的博客
05-24 4501
堆排序（C++）
排序子系请选择1--冒泡排序 2--简单选择 3--堆排序 4--直接插入 5--希尔排序 6--快速排序 0--输入数据c语言
最新发布
06-03
介绍一下排序子系，排序是计算机科学中最基本的算法之一。以下是常见的排序算法： 1. 冒泡排序：通过比较相邻元素的大小，将较大的元素向后移动，从而实现排序。 2. 简单选择排序：每次在未排序的元素中选择一个最小的元素，放到已排序的元素序列的末尾。 3. 堆排序：将元素构建成一个堆（大根堆或小根堆），每次取出堆顶元素（最大或最小元素），再重新调整堆结构。 4. 直接插入排序：将未排序的元素逐个插入到已排序序列中，保证已排序序列始终有序。 5. 希尔排序：改进的直接插入排序，通过将序列分成多个子序列进行排序，逐步减小子序列长度，最终完成整个序列的排序。 6. 快速排序：通过选取一个基准元素，将序列分成两部分，一部分比基准元素小，另一部分比基准元素大，递归地对两个子序列进行快速排序。 如果您需要输入数据c语言，请输入0。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值