大根堆-小根堆-堆排序-C实现

最新推荐文章于 2024-08-11 20:00:00 发布
最新推荐文章于 2024-08-11 20:00:00 发布
阅读量4.9k 收藏 8
点赞数 1
分类专栏： 数据结构和算法 文章标签： 堆排序

大根堆小根堆的实现：以PPT形式呈现大根堆构建的理论过程

1、首先涉及到一个堆的调整，这也是算法的核心部分。假设树中，节点i的子树已经为两个大根堆。这两个子树再加上i节点的话，可能是大根堆也可能不是，因此需要对节点i进行调整。若i小于left(i) or right(i)，需要将i下移。

2、这是一个例子，需要将4下移。满足大根堆的性质。

3、大根堆的调整算法。假设i节点的两个子树已经是大根堆。对应代码中MaxHeapify（）函数。

4、算法正确性分析。

5、构建大根堆的过程中，只需要考虑n/2 + 1 之前的节点，因为之后的节点都是叶节点。

6、构建大根堆的算法。对应代码中MaxHeapCreat（）函数


#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
#include <string.h>
/*
目的：建立大根堆，也可以变成小根堆，
核心：堆的调整
输入：一系列来自文件的整数。文件中整数以空格隔开
输出：大根堆
*/


void Swap(uint32_t* array, uint32_t i, uint32_t j)
{
	assert(array);
	uint32_t tmp;
	tmp = array[j];
	array[j] = array[i];
	array[i] = tmp;
}


/*大根堆调整*/
void MaxHeapify(uint32_t* array, uint32_t heapSize, uint32_t currentNode)
{
	uint32_t leftChild, rightChild,  largest;
	leftChild = 2*currentNode + 1;
	rightChild = 2*currentNode + 2;
	if(leftChild < heapSize && array[leftChild] > array[currentNode])
		largest = leftChild;
	else
		largest = currentNode;
	if(rightChild < heapSize && array[rightChild] > array[largest])
		largest = rightChild;
	if(largest != currentNode)
	{
	    Swap(array, largest, currentNode);
		MaxHeapify(array, heapSize, largest);
	}
}


/*构建大根堆*/
void MaxHeapCreat(uint32_t* array, uint32_t heapSize)
{
	int i;
	for(i = heapSize/2; i >= 0; i--)
	{
		MaxHeapify(array, heapSize, i);
	}
}


/*小根堆调整*/
void MinHeapify(uint32_t* array, uint32_t heapSize, uint32_t currentNode)
{
	uint32_t leftChild, rightChild,  minimum;
	leftChild = 2*currentNode + 1;
	rightChild = 2*currentNode + 2;
	if(leftChild < heapSize && array[leftChild] < array[currentNode])
		minimum = leftChild;
	else
		minimum = currentNode;
	if(rightChild < heapSize && array[rightChild] < array[minimum])
		minimum = rightChild;
	if(minimum != currentNode)
	{
	    Swap(array, minimum, currentNode);
		MinHeapify(array, heapSize, minimum);
	}
}
/*构建小根堆*/
void MinHeapCreat(uint32_t* array, uint32_t heapSize)
{
	int i;
	for(i = heapSize/2; i >= 0; i--)
	{
		MinHeapify(array, heapSize, i);
	}
}
int main()
{
	uint32_t tmp;
	uint32_t *array;
	array = malloc(sizeof(uint32_t));
	int i, heapSize = 0;


	/*从文件中读出待排序数据*/
    char* filePathway = "C:/Users/Administrator/Desktop/data.txt";
    FILE* fp;
	fp = fopen(filePathway, "rb");
	if(!fp)
	{
	    fprintf(stderr, "Can not open file correctly\n");
	}
	while(!feof(fp))
	{
	    fscanf(fp, "%d", &tmp);
	    heapSize++;
	    array = realloc(array, sizeof(uint32_t) * (heapSize ));
	    if(array == NULL)
	    {
	        fprintf(stderr, "realloc error!\n");
	        return 1;
	    }
	    array[heapSize - 1] = tmp;
    }
    printf("The origen dataset:\n");
    for(i = 0; i < heapSize; i++)
    {
        printf("%d\t", array[i]);
    }
    printf("\n");


    /*构建小根堆并输出*/
    MinHeapCreat(array, heapSize);
    printf("Output the MinHeap:\n");
    for(i = 0; i < heapSize; i++)
    {
        printf("%d\t", array[i]);
    }
    printf("\n");


    /*构建大根堆并输出*/
    MaxHeapCreat(array, heapSize);
    printf("Output the MaxHeap:\n");
    for(i = 0; i < heapSize; i++)
    {
        printf("%d\t", array[i]);
    }
    free(array);
	fclose(fp);


	return 0;
}



这里再加上一个堆的排序算法

首先看一个例子的演示（图片均来自哈工大李建中《算法设计与分析》课件）

通过这个例子不难看出，主要思想是将大根堆的对顶取出，放到数组的最后一个位置，将最后一个位置原来的数放到堆顶，然后对堆顶做调整Max-Heapify（见链接内博客）。

算法伪代码：

重点来啦，直接上代码，代码亲测没有问题的，只是可能得换一下输入数据而已。

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
#include <string.h>
/*
目的：建立大根堆，也可以变成小根堆，
核心：堆的调整
输入：文件，整数以空格隔开
输出：大根堆
*/


void Swap(uint32_t* array, uint32_t i, uint32_t j)
{
	assert(array);
	uint32_t tmp;
	tmp = array[j];
	array[j] = array[i];
	array[i] = tmp;
}


/*大根堆调整*/
void MaxHeapify(uint32_t* array, uint32_t heapSize, uint32_t currentNode)
{
	uint32_t leftChild, rightChild,  largest;
	leftChild = 2*currentNode + 1;
	rightChild = 2*currentNode + 2;
	if(leftChild < heapSize && array[leftChild] > array[currentNode])
		largest = leftChild;
	else
		largest = currentNode;
	if(rightChild < heapSize && array[rightChild] > array[largest])
		largest = rightChild;
	if(largest != currentNode)
	{
	    Swap(array, largest, currentNode);
		MaxHeapify(array, heapSize, largest);
	}
}


/*构建大根堆*/
void MaxHeapCreat(uint32_t* array, uint32_t heapSize)
{
	int i;
	for(i = heapSize/2; i >= 0; i--)
	{
		MaxHeapify(array, heapSize, i);
	}
}


/*小根堆调整*/
void MinHeapify(uint32_t* array, uint32_t heapSize, uint32_t currentNode)
{
	uint32_t leftChild, rightChild,  minimum;
	leftChild = 2*currentNode + 1;
	rightChild = 2*currentNode + 2;
	if(leftChild < heapSize && array[leftChild] < array[currentNode])
		minimum = leftChild;
	else
		minimum = currentNode;
	if(rightChild < heapSize && array[rightChild] < array[minimum])
		minimum = rightChild;
	if(minimum != currentNode)
	{
	    Swap(array, minimum, currentNode);
		MinHeapify(array, heapSize, minimum);
	}
}
/*构建小根堆*/
void MinHeapCreat(uint32_t* array, uint32_t heapSize)
{
	int i;
	for(i = heapSize/2; i >= 0; i--)
	{
		MinHeapify(array, heapSize, i);
	}
}




void HeapSort(uint32_t* array, uint32_t heapSize)
{
    MaxHeapCreat(array, heapSize);
    int i;
    uint32_t arraySize = heapSize;
    for(i = arraySize - 1; i >= 1; i--)
    {
        Swap(array, 0, i);
        heapSize--;
        MaxHeapify(array, heapSize, 0);
    }
}




int main()
{
	uint32_t tmp;
	uint32_t *array;
	array = malloc(sizeof(uint32_t));
	int i, heapSize = 0;


	/*从文件中读出待排序数据*/
    char* filePathway = "C:/Users/Administrator/Desktop/data.txt";
    FILE* fp;
	fp = fopen(filePathway, "rb");
	if(!fp)
	{
	    fprintf(stderr, "Can not open file correctly\n");
	}
	while(!feof(fp))
	{
	    fscanf(fp, "%d", &tmp);
	    heapSize++;
	    array = realloc(array, sizeof(uint32_t) * (heapSize ));
	    if(array == NULL)
	    {
	        fprintf(stderr, "realloc error!\n");
	        return 1;
	    }
	    array[heapSize - 1] = tmp;
    }
    printf("The origen dataset:\n");
    for(i = 0; i < heapSize; i++)
    {
        printf("%d\t", array[i]);
    }
    printf("\n");


    /*构建小根堆并输出*/
    MinHeapCreat(array, heapSize);


    printf("Output the MinHeap:\n");
    for(i = 0; i < heapSize; i++)
    {
        printf("%d\t", array[i]);
    }
    printf("\n");


    /*构建大根堆并输出*/
    MaxHeapCreat(array, heapSize);
    printf("Output the MaxHeap:\n");
    for(i = 0; i < heapSize; i++)
    {
        printf("%d\t", array[i]);
    }
    /*堆排序*/
    HeapSort(array, heapSize);
    printf("Output the SortedHeap:\n");
    for(i = 0; i < heapSize; i++)
    {
        printf("%d\t", array[i]);
    }
    free(array);
	fclose(fp);


	return 0;
}




shop_ping
关注
专栏目录
堆排序（小根堆）C语言实现
weixin_45911345的博客
12-04 1160
#include <stdio.h> void swap(int a[], int b, int c) { int tmp = a[b]; a[b] = a[c]; a[c] = tmp; } void heapify(int a[], int i, int n) { if (i >= n) return; int c1 = 2 * i + 1; int c2 = 2 * i + 2; int min = i; if (c1 < n && a[c1
堆排序（大根堆实现）
baidu_39458769的博客
10-29 1065
//建立大根堆，结果是从小到大排序 public static void heapSort(int[] arr) { buildHeap(arr); //size是当前堆最后一个元素的下标 int size = arr.length - 1; while (size &gt; 0) { int tem...
c语言实现 小根堆heap
12-07
c语言实现 小根堆heap，每次pop的时候都是最小值。整个值以数组形式储存！
【数据结构】堆、大根堆、小根堆与堆排序（C语言实现）
随手写写
09-21 3987
堆、大根堆、小根堆与堆排序（C语言实现）
优先级队列(堆)
最新发布
m0_62055442的博客
08-11 900
队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，该中场景下，使用队列显然不合适，比如：在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话。在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue)。
c语言实现小根堆
jeepxbf的博客
03-14 624
/* ** 小根堆的实现 ** 逻辑模型是一个完全二叉树 存储模型是给vector ** 索引下标从0开始 **（1）如果i=0，结点i是根结点，无父结点；否则结点i的父结点为结点(i-1)/2； **（2）如果2i+1>n-1，则结点i无左子女；否则结点i的左子女为结点2i+1； **（3）如果2i+2>n-1，则结点i无右子女；否则结点i的右子女为结点2i+2 ** 插入一个元素：新元素被加入到heap的末尾，然后更新树以恢复堆的次序。从下往上调整 ** 删除一个元素：为了便于重建堆，实际的
小根堆实现
junsure2012
12-12 1769
public class MinHeap {private int[] heap;private int length;public MinHeap(int[] arr){if(arr.length<=0){throw new IllegalArgumentException("array length illegal");}heap = new int[arr.length];System.ar
堆排序，分别利用大根堆、小根堆排序
qq_33615374的博客
10-07 1386
#include &lt;iostream&gt; using namespace std; //下沉调整（本质上都是上浮调整，只不过是将最小元素上浮） void downAdjust(int array[],int parentIndex,int length) { int temp = array[parentIndex]; int childIndex = 2 * parentInde...
【王道数据结构】堆排序算法，大根堆实现代码
Harrison的博客
08-09 769
堆排序算法
c语言建立小根堆的算法,小根堆(Heap)的详细实现
weixin_29648175的博客
05-23 5652
堆的介绍Heap是一种数据结构具有以下的特点：1)完全二叉树2)heap中存储的值是偏序Min-heap: 父节点的值小于或等于子节点的值Max-heap: 父节点的值大于或等于子节点的值堆的存储一般都用数组来表示堆，i结点的父结点下标就为(i–1)/2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。如第0个结点左右子结点下标分别为1和2。由于堆存储在下标从0开始计数的数组中，因...
C语言 数据结构堆排序顺序存储（升序）
08-30
在堆排序中，我们可以使用大根堆或小根堆，分别用于升序和降序排序。在 đây，我们将使用大根堆来进行升序排序。 三、堆排序的步骤 堆排序的步骤可以分为两个部分：构建堆和调整堆。 1. 构建堆：首先，我们需要...
大根堆（小根堆）实现-优先队列
05-24
大根堆，小根堆，优先队列，堆排序，模版。
内部排序之堆排序的实现详解
09-05
下面是一个简单的C语言实现堆排序的示例代码： ```c #include "iostream" using namespace std; #define MAXSIZE 20 typedef struct { int key; // 其他数据信息 } RedType; typedef struct { RedType r...
大根堆和小根堆的C语言实现
热门推荐
stormlovetao的专栏
03-12 1万+
大根堆小根堆的实现：以PPT形式呈现大根堆构建的理论过程 1、首先涉及到一个堆的调整，这也是算法的核心部分。假设树中，节点i的子树已经为两个大根堆。这两个子树再加上i节点的话，可能是大根堆也可能不是，因此需要对节点i进行调整。若i小于left(i) or right(i)，需要将i下移。 2、这是一个例子，需要将4下移。满足大根堆的性质。 3、大根堆的调整算法。假设i节点的两个子
【C语言】-- 数据结构 -- 堆的实现（小堆）
weixin_64609308的博客
06-05 1795
目录1. 堆的概念及结构2. 堆的基本功能实现 2.1 初始化堆 2.2 数据交换 2.3 大小堆的调整 2.3.1 向上调整(小根堆) -- 多数利用于存入数据 2.3.2 向下调整(小根堆) -- 多数利用于删除数据 2.4 存入数据 2.5 打印数据 2.6 所含数据的多少 2.7 删除数据（堆顶元素） 2.8 堆顶元素 2.9 销毁堆 2.10 判断是否为空.........
C++排序（小堆排序）
liuhuiyan_2014的专栏
04-08 612
#include #include using namespace std; template class MinHeap { public: MinHeap(int sz=DefaultSize) { capacity = sz>DefaultSize?sz:DefaultSize; heap = new Type[capacity]; size = 0; } MinHea
c语言堆排序过程的程序,堆排序C语言实现
weixin_30215717的博客
05-20 222
#include /*目的：建立大根堆，也可以变成小根堆，核心：堆的调整输入：文件，整数以空格隔开输出：大根堆*/void Swap(uint32_t* array, uint32_t i, uint32_t j){assert(array);uint32_t tmp;tmp = array[j];array[j] = array[i];array[i] = tmp;}/*大根堆调整*/void ...
选择排序--简单选择排序，堆排序（大根堆，小根堆的建立，堆排序，插入删除元素）包含程序
m0_75220252的博客
07-06 1894
选择排序--简单选择排序，堆排序（大根堆，小根堆的建立，堆排序，插入删除元素）包含程序
堆排序（C++实现，非常简洁明了）
qq_29462849的博客
08-02 1243
#include<iostream> #include<vector> using namespace std; //i代表当前节点，n代表总的数量，这里是在不断的交换 //这里最终建立的是小根堆，最小值往上冒 void change_smallest(vector<int> &nums,int len,int i) { int smallest =...
c语言实现大根堆排序算法
05-31
下面是C语言实现大根堆排序算法的示例代码： ```c #include <stdio.h> // 调整大根堆 void adjustHeap(int arr[], int i, int len) { int temp = arr[i]; for (int k = 2 * i + 1; k < len; k = 2 * k + 1) { if (k + 1 < len && arr[k] < arr[k + 1]) { k++; } if (arr[k] > temp) { arr[i] = arr[k]; i = k; } else { break; } } arr[i] = temp; } // 大根堆排序 void heapSort(int arr[], int len) { // 构建大根堆 for (int i = len / 2 - 1; i >= 0; i--) { adjustHeap(arr, i, len); } // 交换堆顶元素与堆底元素，并重新构建大根堆 for (int i = len - 1; i >= 0; i--) { int temp = arr[i]; arr[i] = arr[0]; arr[0] = temp; adjustHeap(arr, 0, i); } } int main() { int arr[] = {4, 6, 8, 5, 9, 1, 2, 3, 7}; int len = sizeof(arr) / sizeof(arr[0]); heapSort(arr, len); for (int i = 0; i < len; i++) { printf("%d ", arr[i]); } printf("\n"); return 0; } ``` 在这个示例代码中，adjustHeap函数实现了对堆的调整，heapSort函数实现了对整个序列的排序操作。在main函数中，我们定义了一个待排序的数组arr，并通过调用heapSort函数对其进行排序。最终输出排序后的结果。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值