堆排序（非递归）

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


堆，向下调整的递归和非递归实现，堆排序，STL中的优先队列，
xmf_learn_c的博客
07-14 986
在交换值得同时，由于值对应的下标有所改变，那么下标对应的k值一定发生了变化，那么ph里面的值就要发生改变，但如果要改变ph中的值，那我们就要开一个数组来记录下标对应的k值，然后根据这个k值，作为ph的索引，改变两个不同k值对应的下标。这里需要用到插入，插入肯定是在末尾插入的，那么有向下调整的操作，那么一定有向上调整的操作，和向下调整同理，如果孩子节点比父亲节点小，那么需要进行向上调整。2.4的节点仍然没有满足大于两个孩子节点的条件，所以继续调整，到了最终状态，满足小根堆的条件。
堆排序 C++非递归 通俗易懂
keep coding
11-12 803
常见的堆排序算法，代码虽简短巧妙，但是要么用递归，要么有堆调整函数， 不够简洁明了。 本文为自己实现算法，有一个非递归的大顶堆生成函数
堆排序递归和非递归的实现
08-07
该源码主要在winform中实现的堆的构造，大顶堆和小顶堆的构造，在构造过程中有递归和非递归两种方式实现，当然必不可少的是堆排序了
堆排序(非递归版本)
一个吃水不忘挖井人的博客。希望能帮助到你
02-04 572
import java.util.Arrays; public class Main { /** * @param args */ //堆排序 //原理 先构建一个构建一个都是大根堆的完全二叉树 // 5 // 3 4 // 1 2 //一颗二叉树 父节点永远比两个子节点都大。这个叫做大根堆 //时间复杂度 O(N*logN) //...
非递归方式实现堆排序
dabingsun的博客
12-25 404
思路： ①顺序存储方式初始化堆 ②逐步调整堆 #交换 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 1051
0x01 背景 多年之前写了一篇博客，实现非递归方式的堆排序，多年之后才发现写的有问题。连忙撤了下来，重新复习了《算法导论》，用Go实现了正确的非递归排序。算是填上了当年的坑。基本上是复原了书上的实现，加上自己的理解。 0x02 堆与堆排序 堆是一种完全二叉树。它具有如下特点： 每个节点都比其他子节点的值大或者小。 都大的叫大根堆，都小的叫小根堆。反过来表达，除根节点外，其他节点都比父节点小或者大。堆可以和一个数组对应起来。下标为i的元素的两个子节点分别为2i+1和2i+2。 堆排序就是利用堆的构建过
堆排序的非递归算法分析与JAVA实现
03-02
由于堆排序的非递归实现比递归实现更为复杂，需要我们手动控制循环的迭代次数和条件，因此在理解堆排序算法的逻辑时更为困难。不过，非递归实现能够减少函数调用的开销，提高算法的执行效率，对于理解堆排序的本质...
Winform实现堆排序：递归与非递归方法对比
在Winform环境下，由于涉及到图形界面的操作，可能会涉及到事件驱动和消息循环，这对于理解递归和非递归的堆排序实现带来一定的复杂性。 堆的构造是堆排序算法的基础。堆可以通过数组来表示，堆中的每个元素都可以...
堆排序的非递归方法
qq_40788950的博客
03-19 654
堆是一种完全二叉树，第i个节点的左孩子是2 * i + 1，右孩子是 2 * i + 2，可以通过子节点求父节点：（i - 1)/ 2 。不管是左孩子还是右孩子都可以通过这种方式求的其父节点。对于一个数组，可以先将数组中的元素构建为一个大根堆，这样数组中的第一个数就是最大的值，将这个数与最后一个位置上的数进行交换，最后一个数就是最大值了，之后考虑对去掉这个元素的数组重新调整为一个大根堆，再将这个数...
堆排序的非递归算法
蜗牛不会飞
08-04 687
/* 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 484
堆排序需要解决两个问题：1.如何由一个无序序列建成一个堆 2.如何在输出堆顶元素后调整剩余元素成为一个新的堆。 其实两个问题就是一个问题，就是如何调整剩余元素成为一个新的堆。 筛选：筛选是从第n/2向下取整个元素开始的，如果看成是完全二叉树，那么肯定是第n/2向下取整的非终端结点。 堆排序:一个无序序列建堆的过程就是一个反复筛选的过程。   def heapsort(data): ...
非递归实现堆排序
老哥的专栏
09-27 852
话不多说，直接上例子，首先得明白具体过程：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 136
引言 首先需要明确，如何根据父亲结点的位置得知孩子结点的位置，以及如何根据孩子结点的位置得知父亲结点的位置。 假设数列索引从0开始，如果父亲结点的索引为i，那么左孩子索引为2i+1，右孩子索引为2i+2；如果孩子结点的索引为j，那么父亲结点的索引为(j-1)/2。 堆排序的核心在于函数 void adjustdown(int *arr, int i, int end) ，其中第i+1个元...
堆排序（非递归版）-- c语言实现
Copertino的专栏
08-15 743
堆，是是在逻辑上模仿完全二叉树的一维数组，（假设数组开始下标为0）某父节点 i 其左右孩子可以表示为2*i+1(左)和2*i+2(右). 堆排序的思想是每次从堆顶拿出一个元素（最大或最小取决于是大顶堆还是小顶堆)放入已排序数组，然后将堆最有一个元素插入堆顶， 这样将引起堆的不平衡，然后重新调整堆至平衡，重复做下去。注意，每次堆拿出堆顶元素的大小都会减小1. #include #in
插入排序（java实现）
张巍的博客
03-26 321
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 1372
C/C++ 数据结构堆排序的快速实现本章所需知识点：大根堆和小根堆的定义如何编写非递归的堆排序 本章所需知识点： 1.父结点索引：(i-1)/2（这里计算机中的除以2，省略掉小数） 2.左孩子索引：2*i+1 3.右孩子索引：2*i+2 大根堆和小根堆的定义 大根堆和小根堆 性质：每个结点的值都大于其左孩子和右孩子结点的值，称之为大根堆；每个结点的值都小于其左孩子和右孩子结点的值，称之为小根堆。 如何编写非递归的堆排序 堆排序原理参考文档 非递归堆排序流程图： 求最大根堆即是数组A的MAXSIZE-1数
排序算法(2)－－－堆排序非递归实现
weixin_30784945的博客
05-27 139
堆排序 对于非递归的堆排序主要有两个步骤： （一）构建大/小根堆 （二）对于构建好的堆，每次取第一个元素（也就是最大或者最小的那个元素）和最后一个元素交换，并把它移除堆的结构，这样，就必须重新维护剩下的树，使它重新变成一个大/小根堆，重复这个步骤，直到堆中的元素为0。 代码 public class HeapSort { public...
python 堆排序非递归
最新发布
03-14
### Python 实现非递归堆排序 堆排序是一种基于比较的高效排序算法，其核心思想是利用二叉堆数据结构完成数组的最大值提取操作。为了实现非递归版的堆排序，可以按照以下逻辑构建代码。 #### 堆排序的核心思想 堆排序分为两个主要阶段：建堆和调整堆。 1. **建堆**：将输入列表构建成一个最大堆（或最小堆）。在此过程中，父节点始终大于等于子节点。 2. **调整堆**：通过不断移除根节点并重新调整剩余部分为新的堆，逐步得到有序序列。 以下是具体的非递归实现方式： ```python def heapify_non_recursive(arr, n, i): """ 非递归地调整堆 """ largest = i # 初始化当前节点为最大的索引 left_child = 2 * i + 1 # 左孩子节点索引 right_child = 2 * i + 2 # 右孩子节点索引 while True: if left_child < n and arr[left_child] > arr[largest]: largest = left_child if right_child < n and arr[right_child] > arr[largest]: largest = right_child if largest != i: # 如果最大值不是当前节点，则交换它们 arr[i], arr[largest] = arr[largest], arr[i] i = largest # 更新左孩子和右孩子的索引 left_child = 2 * i + 1 right_child = 2 * i + 2 else: break def heap_sort_non_recursive(arr): """ 使用非递归方法实现堆排序 """ n = len(arr) # 构建初始最大堆 for i in range(n // 2 - 1, -1, -1): heapify_non_recursive(arr, n, i) # 提取元素并重建堆 for i in range(n - 1, 0, -1): arr[0], arr[i] = arr[i], arr[0] # 将当前最大值移到最后 heapify_non_recursive(arr, i, 0) # 调整剩下的堆 # 测试代码 if __name__ == "__main__": data = [4, 10, 3, 5, 1] print("原始数组:", data) heap_sort_non_recursive(data) print("排序后的数组:", data) ``` #### 关键点解析 上述代码实现了堆排序的关键功能，并采用非递归的方式完成了 `heapify` 过程。具体说明如下： - 函数 `heapify_non_recursive` 是用来维护堆性质的核心函数，在循环中持续检查父子节点的关系并进行必要的交换[^3]。 - 初始堆化过程从最后一个非叶子节点开始向上逐层处理，确保整个树满足最大堆的要求。 - 排序阶段每次都将堆顶元素（最大值）移动到数组末尾，并缩小堆的有效范围，随后再次调用 `heapify_non_recursive` 来恢复堆属性。 此实现的空间复杂度保持在 \(O(1)\)，因为所有的操作都在原数组上执行，无需额外分配内存空间。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值