【数据结构】20 树的应用（堆及其操作）

堆的定义

堆是一种优先队列，从堆中取出元素时按照元素的优先级大小，而不是元素进入队列的先后顺序。
堆的最常用结构是二叉树，一般为完全二叉树。通常使用数组来实现堆的存储。
最大堆：任一结点的值大于或等于其子节点的值。这一性质决定了根节点元素的值在整个堆里是最大的。
最小堆：任一结点的值小于或等于其子节点的值。这一性质决定了根节点元素的值在整个堆里是最小的。
需要注意的是，兄弟节点之间没有什么约束关系，比如 可能会出现左子树个节点的值都大于右子树的所有结点

最大堆的操作

一个有N个元素的最大堆H是一颗完全二叉树，每个结点上的元素值不小于其子节点元素的值。

最大堆的创建

typedef int ElementType;
typedef struct Hnode* Heap;
struct Hnode {
	ElementType* Data;
	int size;
	int capacity;
};

//若堆里要有n个元素，则开辟的数组要有n+1大小，因为0下标位置无用，从1处开始存储
Heap CreateHeap(int maxsize) {
	Heap H = new Hnode[maxsize];
	H->capacity = maxsize ;
	H->Data = new ElementType[maxsize + 1];
	H->size = 0;
	H->Data[0] = 1e8;//定义哨兵为大于堆中所有可能元素的数值
	return H;
}

元素的插入

从新增结点的最后一个结点的父节点开始，用要插入的元素向下过滤上层结点。

bool IsFull(Heap H) {
	if (H->size == H->capacity) {
		return true;
	}
	else {
		return false;
	}
}
bool Insert(Heap H, ElementType X) {
	//H->Data[0]为哨兵
	if (IsFull(H)) {
		printf("最大堆已满\n");
		return false;
	}

	int i = ++H->size;
	//H->Data[i/2]为其父结点 
	while (H->Data[i / 2] < X) {
		H->Data[i] = H->Data[i / 2];
		i /= 2;

	}
	H->Data[i] = X;
	return true;


}


void printh(Heap h) {
	queue<int> q;
	int i = 1;
	int j;
	q.push(i);
	while (!q.empty()) {
		j = q.front();
		printf("%d ", h->Data[j]);
		q.pop();
		if (2 * j <= h->size) {
			q.push(2 * j);
		}
		if (2 *j + 1 <= h->size) {
			q.push(2 * j + 1);
		}

		
	}
}

最大堆的删除

从根节点开始，用最大堆的最后一个元素向上过滤下层元素。

ElementType DeleteMax(Heap h) {
	if (h->size == 0) {
		printf("the heap is empty!\n");
		return -1;
	}
	else {
		int maxi = h->Data[0];//被拿走
		int x = h->Data[h->size];//要删除
		h->size--;
		int parent, child;
		for (parent = 1; 2 * parent <= h->size; parent = child) {
			child = 2 * parent;
			if (child != h->size && h->Data[child] < h->Data[child + 1]) {
				child++;
			}
			if (x >= h->Data[child]) {
				break;
			}
			else {
				h->Data[parent] = h->Data[child];
			}
		}
		h->Data[parent] = x;
		return maxi;
	}
}

最大堆的建立

将已经存在的N个元素按最大堆的要求存放在一个一维数组里。
首先，将N个元素按输入顺序插入二叉树
然后，调整各个结点元素，以满足最大堆的有序性

从第N/2结点开始，对包括该结点和该节点前面的节点进行过滤操作：对一个某一节点，当其两个子节点中较大键值的元素大于它时，将它与大键值子节点交换位置，完成一个层次的向下过滤，接着在新的层次上进行再下一层的过滤，直到找到它的正确位置。

void precDown(Heap h, int p) {
	int parent, child;
	int x = h->Data[p];
	for (parent = p; 2 * parent <= h->size; parent = child) {
		child = 2 * parent;
		if (child != 2 * parent && h->Data[child] < h->Data[child + 1]) {
			child++;
		}
		if (x >= h->Data[child]) {
			break;
		}
		else {
			h->Data[parent] = h->Data[child];
		}
	}
	h->Data[parent] = x;
}

void BulidHeap(Heap h) {
	int i;
	for (i = h->size / 2; i > 0; i--) {
		precDown(h, i);
	}
}

完整代码

#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

typedef int ElementType;
typedef struct Hnode* Heap;
struct Hnode {
	ElementType* Data;
	int size;
	int capacity;
};

//若堆里要有n个元素，则开辟的数组要有n+1大小，因为0下标位置无用，从1处开始存储
Heap CreateHeap(int maxsize) {
	Heap H = new Hnode[maxsize];
	H->capacity = maxsize ;
	H->Data = new ElementType[maxsize + 1];
	H->size = 0;
	H->Data[0] = 1e8;//定义哨兵为大于堆中所有可能元素的数值
	return H;
}
bool IsFull(Heap H) {
	if (H->size == H->capacity) {
		return true;
	}
	else {
		return false;
	}
}
bool Insert(Heap H, ElementType X) {
	//H->Data[0]为哨兵
	if (IsFull(H)) {
		printf("最大堆已满\n");
		return false;
	}

	int i = ++H->size;
	//H->Data[i/2]为其父结点 
	while (H->Data[i / 2] < X) {
		H->Data[i] = H->Data[i / 2];
		i /= 2;

	}
	H->Data[i] = X;
	return true;


}


void printh(Heap h) {
	queue<int> q;
	int i = 1;
	int j;
	q.push(i);
	while (!q.empty()) {
		j = q.front();
		printf("%d ", h->Data[j]);
		q.pop();
		if (2 * j <= h->size) {
			q.push(2 * j);
		}
		if (2 *j + 1 <= h->size) {
			q.push(2 * j + 1);
		}

		
	}
}



ElementType DeleteMax(Heap h) {
	if (h->size == 0) {
		printf("the heap is empty!\n");
		return -1;
	}
	else {
		int maxi = h->Data[0];//被拿走
		int x = h->Data[h->size];//要删除
		h->size--;
		int parent, child;
		for (parent = 1; 2 * parent <= h->size; parent = child) {
			child = 2 * parent;
			if (child != h->size && h->Data[child] < h->Data[child + 1]) {
				child++;
			}
			if (x >= h->Data[child]) {
				break;
			}
			else {
				h->Data[parent] = h->Data[child];
			}
		}
		h->Data[parent] = x;
		return maxi;
	}
}

void precDown(Heap h, int p) {
	int parent, child;
	int x = h->Data[p];
	for (parent = p; 2 * parent <= h->size; parent = child) {
		child = 2 * parent;
		if (child != 2 * parent && h->Data[child] < h->Data[child + 1]) {
			child++;
		}
		if (x >= h->Data[child]) {
			break;
		}
		else {
			h->Data[parent] = h->Data[child];
		}
	}
	h->Data[parent] = x;
}

void BulidHeap(Heap h) {
	int i;
	for (i = h->size / 2; i > 0; i--) {
		precDown(h, i);
	}
}

int main() {
	int maxsize = 10;
	Heap h = CreateHeap(maxsize);
	int n;
	cin >> n;
	int x;
	while (n--) {
		cin >> x;
		if (!Insert(h, x)) {
			printf("The heap is full!\n");
		}
	}
	printh(h);

	int mai = DeleteMax(h);
	printh(h);


	

}

STL使用

//priority_queue<int> maxheap; //默认最大堆
priority_queue<int, vector<int>, greater<int>> minheap;//最小堆
vector<int> array = { 4, 7,10,3,20,16 };
priority_queue<int> maxheap(array.begin(), array.end());
maxheap.push(11);
cout << maxheap.top() << endl;
maxheap.pop();
maxheap.pop();
cout << maxheap.top() << endl;