堆排序（非递归）

最新推荐文章于 2022-03-27 15:17:59 发布
最新推荐文章于 2022-03-27 15:17:59 发布
阅读量2.3k 收藏
点赞数 2
分类专栏： C 文章标签： null 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kevinshq/article/details/7173925
版权

以下代码经测试，排序5000000（五千万）int型数据没有问题！

第一个参数是数组首地址
第二个参数是数组元素个数 
void HeapSort(int * const arr, const DWORD number)//堆排序
{
    int tmp;
    DWORD tmpIndex;
    DWORD i=1;
    DWORD num;
    DWORD indexUp;
    DWORD indexDown;
    if (number < 2)
    {
        return;
    }
    indexUp = number-1;
    if (0 != (indexUp%2))
    {
        tmpIndex = (indexUp - 1) / 2;
        if (arr[indexUp] > arr[tmpIndex])
        {
            tmp = arr[indexUp];
            arr[indexUp] = arr[tmpIndex];
            arr[tmpIndex] = tmp;
        }
        indexUp--;
    }
    for (; indexUp>0; indexUp-=2)
    {
        tmpIndex = (indexUp / 2) - 1;
        if (arr[indexUp-1] >= arr[indexUp])
        {
            if (arr[indexUp-1] > arr[tmpIndex])
            {
                tmp = arr[indexUp-1];
                arr[indexUp-1] = arr[tmpIndex];
                arr[tmpIndex] = tmp;
                indexDown = indexUp-1;
            }
            else
            {
                continue;
            }
        }
        else
        {
            if (arr[indexUp] > arr[tmpIndex])
            {
                tmp = arr[indexUp];
                arr[indexUp] = arr[tmpIndex];
                arr[tmpIndex] = tmp;
                indexDown = indexUp;
            }
            else
            {
                continue;
            }
        }
        while ((2*indexDown) < number)
        {
            tmpIndex = 2*indexDown +1;
            if (arr[tmpIndex] >= arr[tmpIndex+1] || (tmpIndex+1 == number))
            {
                if (arr[tmpIndex] > arr[indexDown])
                {
                    tmp = arr[indexDown];
                    arr[indexDown] = arr[tmpIndex];
                    arr[tmpIndex] = tmp;
                    indexDown = tmpIndex;
                }
                else
                {
                    break;
                }
            }
            else
            {
                if ((arr[tmpIndex+1] > arr[indexDown]) && (tmpIndex < number))
                {
                    tmp = arr[indexDown];
                    arr[indexDown] = arr[tmpIndex+1];
                    arr[tmpIndex+1] = tmp;
                    indexDown = tmpIndex+1;
                }
                else
                {
                    break;
                }
            }
        }
    }
    tmp = arr[0];
    arr[0] = arr[number-1];
    arr[number-1] = tmp;

    for (num=number-1; num>1; num--)
    {
        for (indexDown=0; (2*indexDown +1) < num; )
        {
            tmpIndex = 2*indexDown +1;
            if (arr[tmpIndex] >= arr[tmpIndex+1])
            {
                if (arr[tmpIndex] > arr[indexDown])
                {
                    tmp = arr[indexDown];
                    arr[indexDown] = arr[tmpIndex];
                    arr[tmpIndex] = tmp;
                    indexDown = tmpIndex;
                }
                else
                {
                    break;
                }
            }
            else
            {
                if ((arr[tmpIndex+1] > arr[indexDown]) && (tmpIndex+1 < num))
                {
                    tmp = arr[indexDown];
                    arr[indexDown] = arr[tmpIndex+1];
                    arr[tmpIndex+1] = tmp;
                    indexDown = tmpIndex+1;
                }
                else
                {
                    break;
                }
            }
        }
        tmp = arr[0];
        arr[0] = arr[num-1];
        arr[num-1] = tmp;
    }
}

测试代码： 
#include <stdio.h>
#include <conio.h>
#include <windows.h>

void HeapSort(int * const arr, const DWORD number);//堆排序
void ExamineArr(const int * const arr, DWORD number);//检查排序结果

int main(int argc, char *argv[])
{
    DWORD StartTime, EndTime;
    DWORD i;
    DWORD num = 50000000;
    int *arr = NULL;
    arr = (int *)malloc(num * sizeof (int));
    if (NULL == arr)
    {
        free(arr);
        printf("内存分配失败，程序退出！\n");
        getch();
        return -1;
    }

    StartTime = GetTickCount();
    for (i=0; i<num; i++)
    {
        *(arr+i) = rand();
    }
    EndTime = GetTickCount();
    printf("生成%u个随机数耗时：%ums\n", num, EndTime - StartTime);
    
    StartTime = GetTickCount();
    HeapSort(arr, num);
    EndTime = GetTickCount();
    printf("堆排序耗时：%ums\n", EndTime - StartTime);
    ExamineArr(arr, num);//检查排序结果

    free(arr);
    getch();
    return 0;
}

void HeapSort(int * const arr, const DWORD number)//堆排序
{
    int tmp;
    DWORD tmpIndex;
    DWORD i=1;
    DWORD num;
    DWORD indexUp;
    DWORD indexDown;
    if (number < 2)
    {
        return;
    }
    indexUp = number-1;
    if (0 != (indexUp%2))
    {
        tmpIndex = (indexUp - 1) / 2;
        if (arr[indexUp] > arr[tmpIndex])
        {
            tmp = arr[indexUp];
            arr[indexUp] = arr[tmpIndex];
            arr[tmpIndex] = tmp;
        }
        indexUp--;
    }
    for (; indexUp>0; indexUp-=2)
    {
        tmpIndex = (indexUp / 2) - 1;
        if (arr[indexUp-1] >= arr[indexUp])
        {
            if (arr[indexUp-1] > arr[tmpIndex])
            {
                tmp = arr[indexUp-1];
                arr[indexUp-1] = arr[tmpIndex];
                arr[tmpIndex] = tmp;
                indexDown = indexUp-1;
            }
            else
            {
                continue;
            }
        }
        else
        {
            if (arr[indexUp] > arr[tmpIndex])
            {
                tmp = arr[indexUp];
                arr[indexUp] = arr[tmpIndex];
                arr[tmpIndex] = tmp;
                indexDown = indexUp;
            }
            else
            {
                continue;
            }
        }
        while ((2*indexDown) < number)
        {
            tmpIndex = 2*indexDown +1;
            if (arr[tmpIndex] >= arr[tmpIndex+1] || (tmpIndex+1 == number))
            {
                if (arr[tmpIndex] > arr[indexDown])
                {
                    tmp = arr[indexDown];
                    arr[indexDown] = arr[tmpIndex];
                    arr[tmpIndex] = tmp;
                    indexDown = tmpIndex;
                }
                else
                {
                    break;
                }
            }
            else
            {
                if ((arr[tmpIndex+1] > arr[indexDown]) && (tmpIndex < number))
                {
                    tmp = arr[indexDown];
                    arr[indexDown] = arr[tmpIndex+1];
                    arr[tmpIndex+1] = tmp;
                    indexDown = tmpIndex+1;
                }
                else
                {
                    break;
                }
            }
        }
    }
    tmp = arr[0];
    arr[0] = arr[number-1];
    arr[number-1] = tmp;

    for (num=number-1; num>1; num--)
    {
        for (indexDown=0; (2*indexDown +1) < num; )
        {
            tmpIndex = 2*indexDown +1;
            if (arr[tmpIndex] >= arr[tmpIndex+1])
            {
                if (arr[tmpIndex] > arr[indexDown])
                {
                    tmp = arr[indexDown];
                    arr[indexDown] = arr[tmpIndex];
                    arr[tmpIndex] = tmp;
                    indexDown = tmpIndex;
                }
                else
                {
                    break;
                }
            }
            else
            {
                if ((arr[tmpIndex+1] > arr[indexDown]) && (tmpIndex+1 < num))
                {
                    tmp = arr[indexDown];
                    arr[indexDown] = arr[tmpIndex+1];
                    arr[tmpIndex+1] = tmp;
                    indexDown = tmpIndex+1;
                }
                else
                {
                    break;
                }
            }
        }
        tmp = arr[0];
        arr[0] = arr[num-1];
        arr[num-1] = tmp;
    }
}

void ExamineArr(const int * const arr, DWORD number)
{
    DWORD i=0, j=1;
    if (number <2)
    {
        return;
    }
    for (; j<number; i++,j++)
    {
        if (arr[i] > arr[j])
        {
            printf("第%u个数大于第%u个数！\n", i, j);
            return;
        }
    }
}


无云
关注
专栏目录
堆排序 C++非递归 通俗易懂
keep coding
11-12 746
常见的堆排序算法，代码虽简短巧妙，但是要么用递归，要么有堆调整函数， 不够简洁明了。 本文为自己实现算法，有一个非递归的大顶堆生成函数
三叉堆排序（递归&非递归）
热门推荐
SWY's Workshop
12-22 1万+
三叉堆排序（递归&非递归） 问题描述 输入：第一行是一个整数n，表示三叉堆节点的数量 第二行是n个整数，依次表示三叉堆节点的关键字。 输出：n行 每行若干个数，第一个数为树根（即数列最小值），之后若干个数依次为删除树根并用末尾节点关键字last代替根节点后每次交换的数，最后用关键字last结尾。 样例输入： 4 10 30 13 16 样例输出： 10 13 16 13 16 16 30 ...
堆排序递归和非递归的实现
08-07
该源码主要在winform中实现的堆的构造，大顶堆和小顶堆的构造，在构造过程中有递归和非递归两种方式实现，当然必不可少的是堆排序了
堆排序(非递归版本)
一个吃水不忘挖井人的博客。希望能帮助到你
02-04 515
import java.util.Arrays; public class Main { /** * @param args */ //堆排序 //原理 先构建一个构建一个都是大根堆的完全二叉树 // 5 // 3 4 // 1 2 //一颗二叉树 父节点永远比两个子节点都大。这个叫做大根堆 //时间复杂度 O(N*logN) //...
非递归方式实现堆排序
dabingsun的博客
12-25 366
思路： ①顺序存储方式初始化堆 ②逐步调整堆 #交换 def swap(arr,i,j): temp = arr[i] arr[i] = arr[j] arr[j] = temp #初始化最大堆，顺序存储 def heapInsert(arr,index): parent = 0 while index != 0: pare...
非递归的堆排序
丰年留客的专栏
03-27 984
0x01 背景 多年之前写了一篇博客，实现非递归方式的堆排序，多年之后才发现写的有问题。连忙撤了下来，重新复习了《算法导论》，用Go实现了正确的非递归排序。算是填上了当年的坑。基本上是复原了书上的实现，加上自己的理解。 0x02 堆与堆排序 堆是一种完全二叉树。它具有如下特点： 每个节点都比其他子节点的值大或者小。 都大的叫大根堆，都小的叫小根堆。反过来表达，除根节点外，其他节点都比父节点小或者大。堆可以和一个数组对应起来。下标为i的元素的两个子节点分别为2i+1和2i+2。 堆排序就是利用堆的构建过
堆排序的非递归算法分析与JAVA实现
03-02
由于堆排序的非递归实现比递归实现更为复杂，需要我们手动控制循环的迭代次数和条件，因此在理解堆排序算法的逻辑时更为困难。不过，非递归实现能够减少函数调用的开销，提高算法的执行效率，对于理解堆排序的本质...
算法 堆排序（递归和非递归方式讲解）
qq_41512783的博客
10-29 1005
算法 堆排序 @author:Jingdai @date:2020.10.29 刷 LeetCode 215 题，用到堆排序，现总结一下堆排序的知识。 基础知识 完全二叉树 在说堆之前，必须先要说一下完全二叉树。注意和满二叉树区别，完全二叉树的节点可以是任意多个。但是完全二叉树除了最后一层，其余层必须是满的，同时最后一层的叶子节点必须都在左边，从左往右排。如下图是完全二叉树和非完全二叉树的示例。 堆 堆是一种特殊的完全二叉树，分为大根堆和小根堆。对于大根堆，除根节点外每个节点的值小于等于
堆排序的非递归方法
qq_40788950的博客
03-19 572
堆是一种完全二叉树，第i个节点的左孩子是2 * i + 1，右孩子是 2 * i + 2，可以通过子节点求父节点：（i - 1)/ 2 。不管是左孩子还是右孩子都可以通过这种方式求的其父节点。对于一个数组，可以先将数组中的元素构建为一个大根堆，这样数组中的第一个数就是最大的值，将这个数与最后一个位置上的数进行交换，最后一个数就是最大值了，之后考虑对去掉这个元素的数组重新调整为一个大根堆，再将这个数...
堆排序的非递归算法
蜗牛不会飞
08-04 650
/* by leowang 堆排序的非递归算法 */ #include using namespace std; /* run this program using the console pauser or add your own getch, system("pause") or input loop */ int parent(int i) {//此处数组从1开始
排序---堆排序的非递归实现
u014204761的博客
06-05 425
堆排序需要解决两个问题：1.如何由一个无序序列建成一个堆 2.如何在输出堆顶元素后调整剩余元素成为一个新的堆。 其实两个问题就是一个问题，就是如何调整剩余元素成为一个新的堆。 筛选：筛选是从第n/2向下取整个元素开始的，如果看成是完全二叉树，那么肯定是第n/2向下取整的非终端结点。 堆排序:一个无序序列建堆的过程就是一个反复筛选的过程。   def heapsort(data): ...
非递归实现堆排序
老哥的专栏
09-27 804
话不多说，直接上例子，首先得明白具体过程：45 28 49 16 37 82 56 75（最小堆）建树 45 28 49 16 37 82 56 75从n/2个节点开始选择,第一趟,16比75小,不换.到n/2-1个节点,49和82、56比,49小,也不换.到n/2-2个结点,28和16、37比,16小,变成 （n/2的意思也就是第一个非叶子节点
非递归方法的堆排序实现
diaolun4894的博客
09-03 102
引言 首先需要明确，如何根据父亲结点的位置得知孩子结点的位置，以及如何根据孩子结点的位置得知父亲结点的位置。 假设数列索引从0开始，如果父亲结点的索引为i，那么左孩子索引为2i+1，右孩子索引为2i+2；如果孩子结点的索引为j，那么父亲结点的索引为(j-1)/2。 堆排序的核心在于函数 void adjustdown(int *arr, int i, int end) ，其中第i+1个元...
堆排序（非递归版）-- c语言实现
Copertino的专栏
08-15 671
堆，是是在逻辑上模仿完全二叉树的一维数组，（假设数组开始下标为0）某父节点 i 其左右孩子可以表示为2*i+1(左)和2*i+2(右). 堆排序的思想是每次从堆顶拿出一个元素（最大或最小取决于是大顶堆还是小顶堆)放入已排序数组，然后将堆最有一个元素插入堆顶， 这样将引起堆的不平衡，然后重新调整堆至平衡，重复做下去。注意，每次堆拿出堆顶元素的大小都会减小1. #include #in
插入排序（java实现）
张巍的博客
03-26 287
import java.util.Arrays; public class Test { public static void main(String[] args) { int[] array = { 80, 70, 50, 30, 99, 1 }; Test.insertSort(array); System.out.println(Arrays.toString(array
C/C++ 堆排序的非递归实现
高冷的上官梓芸的博客
06-24 1291
C/C++ 数据结构堆排序的快速实现本章所需知识点：大根堆和小根堆的定义如何编写非递归的堆排序 本章所需知识点： 1.父结点索引：(i-1)/2（这里计算机中的除以2，省略掉小数） 2.左孩子索引：2*i+1 3.右孩子索引：2*i+2 大根堆和小根堆的定义 大根堆和小根堆 性质：每个结点的值都大于其左孩子和右孩子结点的值，称之为大根堆；每个结点的值都小于其左孩子和右孩子结点的值，称之为小根堆。 如何编写非递归的堆排序 堆排序原理参考文档 非递归堆排序流程图： 求最大根堆即是数组A的MAXSIZE-1数
排序算法(2)－－－堆排序非递归实现
weixin_30784945的博客
05-27 106
堆排序 对于非递归的堆排序主要有两个步骤： （一）构建大/小根堆 （二）对于构建好的堆，每次取第一个元素（也就是最大或者最小的那个元素）和最后一个元素交换，并把它移除堆的结构，这样，就必须重新维护剩下的树，使它重新变成一个大/小根堆，重复这个步骤，直到堆中的元素为0。 代码 public class HeapSort { public...
C语言实现堆排序算法详解
"堆排序是一种基于比较的排序算法，它通过构建最大（或最小）堆来实现排序。本文档提供了一个用C语言实现的堆排序程序，包括`MAX_HEAPIFY`、`build_heap`和`heapsort`三个关键函数。在`main`函数中，对一个包含10个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值