C语言数据结构-排序-堆化

堆化

二叉堆一般用数组来表示。例如，根节点在数组中的位置是0，第n个位置的子节点分别在2n+1和 2n+2。 因此，第0个位置的子节点在1和2，1的子节点在3和4。以此类推。这种存储方式便于寻找父节点和子节点。在二叉堆上可以进行插入节点、删除节点、取出值最小的节点、减小节点的值等基本操作。

“最小堆”的定义如下：

typedef struct _otherInfo
{
    int i;
    int j;
}OtherInfo;

typedef struct _minHeapNode
{
    int value;
    OtherInfo otherInfo;
}MinHeapNode, *PMinHeapNode;

typedef struct _minPQ {
    PMinHeapNode heap_array; // 指向堆元素数组
    int heap_size; // 当前堆中的元素个数
    int capacity;  //堆数组的大小
}MinHeap, *PMinHeap;

请实现最小堆的“堆化”函数：

void min_heapify(PMinHeap pq, int i);

其中 pq指向堆，i 为堆元素在数组中的下标。该函数假设元素i对应的子树都已经是最小堆（符合最小堆的要求），但元素i为根的子树并不是最小堆，min_heapify将对元素i及其子树的各结点进行调整，使其为一个最小堆。

（注：假设辅助函数 left、right、parent 和 swap_node 已正确实现，min_heapify 函数可直接使用。）

提供代码

#include <stdio.h>
#include <stdlib.h>
#include "minbinheap.h"

void min_heapify(PMinHeap pq, int i){

}

实例解读

参考答案

#include <stdio.h>
#include <stdlib.h>
#include "minbinheap.h"

void min_heapify(PMinHeap pq, int i){
	int j = 2 * i + 1;
	MinHeapNode* p = pq->heap_array;
	while (j <= pq->heap_size - 1){
		//j为最小值的堆
		if (p[j + 1].value < p[j].value)
			j = j + 1;
		if (p[j].value < p[i].value) {
			swap_node(&p[j], &p[i]);
			i = j;
			j = 2 * i + 1;
		}
		else return;
	}
}

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
//子节点
typedef struct _otherInfo
{
	int i;
	int j;
}OtherInfo;

//堆元素
typedef struct _minHeepNode
{
	int value;
	OtherInfo otherInfo;
}MinHeapNode,*PMinHeapNode;


//最小堆
typedef struct _minPQ
{
	PMinHeapNode heap_array;//指向堆元素的数组
	int heap_size;	//堆元素的个数
	int capacity;	//堆元素的容量
}MinHeap,*PMinHeap;



//pq指向堆,capacity为堆元素数组的初始化大小
void init_min_heap(PMinHeap pq, int capacity){
	pq->capacity = capacity;
	pq->heap_size = 0;
	pq->heap_array = (PMinHeapNode)malloc(sizeof(MinHeapNode) * pq->capacity);
	return;
}

//返回堆元素的父节点下标
//n->2n+1  2n+2
int parent(int i) {
	return (i - 1) / 2;
}

//返回左子节点
int left(int i) {
	return 2 * i + 1;
}

int right(int j) {
	return 2 * j + 2;
}

//交换两个堆元素的值
void swap_node(MinHeapNode* x, MinHeapNode* y) {
	int value;
	int i, j;

	value = y->value;
	i = y->otherInfo.i;
	j = y->otherInfo.j;

	y->value = x->value;
	y->otherInfo.i = x->otherInfo.i;
	y->otherInfo.j = x->otherInfo.j;

	x->value = value;
	x->otherInfo.i = i;
	x->otherInfo.j = j;
}

//pq指向堆,capacity为堆元素数组的初始化大小
void init_min_heap(PMinHeap pq, int capacity) {
	pq->capacity = capacity;
	pq->heap_size = 0;
	pq->heap_array = (PMinHeapNode)malloc(sizeof(MinHeapNode) * pq->capacity);
	return;
}

//parent 和 swap_node 已正确实现,pq指向堆，value 为要插入的堆元素
bool heap_insert_value(PMinHeap pq, int value){
	//如果满了，就无法插入
	if (pq->heap_size == pq->capacity)return false;

	int i = pq->heap_size;
	int j;
	int temp;

	//p指向根节点
	MinHeapNode* p = pq->heap_array;

	//插入最后一位
	p[i].value = value;
	pq->heap_size++;

	while (1) {
		j = parent(i);
		//j不是节点的父亲
		if (p[i].value <= p[j].value) {
			temp = p[i].value;
			p[i].value = p[j].value;
			p[j].value = temp;
			i = j;
			if (i == 0)return true;
		}
		else return true;
	}
}

/*
请实现最小堆的“堆化”函数：

void min_heapify(PMinHeap pq, int i);

其中 pq指向堆，i 为堆元素在数组中的下标。该函数假设元素i对应的子树都已经是最小堆（符合最小堆的要求）
但元素i为根的子树并不是最小堆，min_heapify将对元素i及其子树的各结点进行调整，使其为一个最小堆。

（注：假设辅助函数 left、right、parent 和 swap_node 已正确实现，min_heapify 函数可直接使用。）
*/

void min_heapify(PMinHeap pq, int i){
	int j = 2 * i + 1;
	MinHeapNode* p = pq->heap_array;
	while (j <= pq->heap_size - 1){
		//j为最小值的堆
		if (p[j + 1].value < p[j].value)
			j = j + 1;
		if (p[j].value < p[i].value) {
			swap_node(&p[j], &p[i]);
			i = j;
			j = 2 * i + 1;
		}
		else return;
	}
}

int main()
{
	//创建堆
	return 0;
}