最小堆的基本操作实现

1. 最小堆结构定义如下：

// 定义最小堆结构
struct MinHeap {
	int* p;       // 存储元素的数组
	int size;     // 当前元素个数
	int capacity; // 最大容量
};

2. 最小堆的基本操作函数如下：

• MinHeap* createMinHeap(int capacity); // 创建最小堆
• bool isFull(MinHeap* minHeap); // 判断最小堆是否已满）
• bool isEmpty(MinHeap* minHeap); // 判断最小堆是否为空
• void insertMinHeap(MinHeap* minHeap, int val); // 插入元素
• void printMinHeap(MinHeap* minHeap); // 遍历最小堆元素
• int deleteMin(MinHeap* minHeap); // 删除最小元素并返回

3. 具体代码实现如下：

#include <iostream>
#include <stdlib.h>

using namespace std;

#define MinData -100000

// 定义最小堆结构
struct MinHeap {
	int* p;       // 存储元素的数组
	int size;     // 当前元素个数
	int capacity; // 最大容量
};

// 创建最小堆
MinHeap* createMinHeap(int capacity) {
	MinHeap* minHeap = (MinHeap*)malloc(sizeof(MinHeap));
	minHeap->p = (int*)malloc((capacity + 1) * sizeof(minHeap->p));
	minHeap->size = 0;
	minHeap->capacity = capacity;
	minHeap->p[0] = MinData;    // 哨兵
	return minHeap;
}

// 判断最小堆是否已满
bool isFull(MinHeap* minHeap) {
	if (minHeap->size == minHeap->capacity) {
		return true;
	}
	return false;
}

// 判断最小堆是否为空
bool isEmpty(MinHeap* minHeap) {
	if (minHeap->size == 0) {
		return true;
	}
	return false;
}

// 插入元素
void insertMinHeap(MinHeap* minHeap, int val) {
	if (minHeap == NULL) {
		cout << "The min heap is not created." << endl;
		return;
	}
	if (isFull(minHeap)) {
		cout << "The min heap is full." << endl;
		return;
	}
	int i = ++(minHeap->size);
	for (; minHeap->p[i / 2] > val; i /= 2) {
		minHeap->p[i] = minHeap->p[i / 2];
	}
	minHeap->p[i] = val;
}

// 遍历最小堆元素
void printMinHeap(MinHeap* minHeap) {
	if (minHeap == NULL) {
		cout << "The min heap is not created." << endl;
		return;
	}
	for (int i = 0; i < minHeap->size; i++) {
		cout << minHeap->p[i + 1] << " ";
	}
	cout << endl;
}

// 删除最小元素并返回
int deleteMin(MinHeap* minHeap) {
	if (minHeap == NULL) {
		cout << "The min heap is not created." << endl;
		return 0;
	}
	if (isEmpty(minHeap)) {
		cout << "The min heap is empty." << endl;
		return 0;
	}
	int min = minHeap->p[1];
	int last = minHeap->p[minHeap->size--];
	int parent = 0;
	int child = 0;
	for (parent = 1; parent * 2 <= minHeap->size; parent = child) {
		child = parent * 2;
		if (child != minHeap->size && minHeap->p[child + 1] < minHeap->p[child]) {
			child++;
		}
		if (last < minHeap->p[child]) {
			break;
		}
		else {
			minHeap->p[parent] = minHeap->p[child];
		}
	}
	minHeap->p[parent] = last;
	return min;
}

int main() {

	MinHeap* minHeap = NULL;

	minHeap = createMinHeap(10);
	insertMinHeap(minHeap, 5);
	insertMinHeap(minHeap, 4);
	insertMinHeap(minHeap, 3);
	insertMinHeap(minHeap, 2);
	insertMinHeap(minHeap, 1);
	printMinHeap(minHeap);
	cout << deleteMin(minHeap) << endl;
	printMinHeap(minHeap);
	cout << deleteMin(minHeap) << endl;
	printMinHeap(minHeap);

	system("pause");

	return 0;
}

4. 运行结果截图如下：