基于优先队列的应用--堆排序和霍夫曼树

堆排序

堆排序就是将数组堆化，大根堆小根堆的根元素永远是最大或者最小的，于是我们取根元素然后调整堆，继续一下次的堆化，不断重复直到取完(或者只剩下根元素)。
此处采用大根堆，将根元素也就是数组的[0]元素不断放到数组的末尾。大根堆的实现可见大小根堆的实现。

#pragma once
//=============================基于根堆的应用--堆排序==========================
//其实就是初始化大根堆的过程 初始化后不断从堆中取出top()元素后pop() 直至堆空
//需要注意的是 与前面的maxHeap.h不同 在maxHeap.h中 我们构造了一个大小为:目标数组大小+1的堆数组heap
//且heap[0]不用 所以我们的下标包括树的根都是从1开始计数的 所以它的左右孩子分别为2*root和2*root+1
//此处我们为了堆排序的效率和性能 不重新分配一个堆数组了 直接在原数组中进行排序
//那么我们的下标包括根的下标就必须从0开始 且根的左右孩子分别为2*root+1和2*root+2
//同时对于根节点来说 heap.h中它的根节点就是child/2 但是此处它的根节点为(child-1)/2
template <typename T>
void heapSort(T arr[], size_t arrSize) {
	--arrSize;//指向尾元素
	//首先初始化为堆
	for (int root = arrSize / 2; root >= 0; --root) {
		int child = 2 * root + 1;//根的左孩子
		T rootElement = arr[root];
		while (child <= arrSize) {
			if (child < arrSize && arr[child] < arr[child + 1])//选左右孩子中大的一个
				++child;
			if (rootElement > arr[child])//是否可以在该位置插入？
				break;
			//不可以。随后把左右孩子中大的一个存在arr[child/2]上，child移动到下一层的左孩子。
			arr[(child - 1) / 2] = arr[child];
			child = 2 * child + 1;
		}
		arr[(child - 1) / 2] = rootElement;
	}

	//随后将最大(root)的元素排在数组最后面 并且pop()重新构建堆
	for (int i = arrSize; i >= 0; --i) {
		T lastElement = arr[i];
		arr[i] = arr[0];//取root元素
		int child = 1;//初始化为第二层
		//重新构建堆
		while (child <= i-1) {//arr[i]不能参与比较
			if (child < i-1 && arr[child] < arr[child + 1])//选左右孩子中大的一个
				++child;
			if (lastElement > arr[child])//是否可以在该位置插入？
				break;
			//不可以。随后把左右孩子中大的一个存在arr[child/2]上，child移动到下一层的左孩子。
			arr[(child - 1) / 2] = arr[child];
			child = child * 2 + 1;
		}
		arr[(child - 1) / 2] = lastElement;
	}
}

构建霍夫曼树

一棵二叉树，如果对一组给定的频率，其WEP最小，那么这棵树称为霍夫曼树(Huffman Tree)。WEP是指二叉树的加权外部路劲长度，这里就不多阐述了。
此处建立霍夫曼树用到了以前的二叉树的实现，用来不断对当前权值最小的两颗树进行合并。同时使用了小根堆(见上面大小根堆的链接)来存储这些带权值的二叉树们。每次从小根堆中取出两棵权值最小的二叉树，权值相加并且对它们对应的二叉树进行合并，然后再存入小根堆。直至剩余最后一棵树(即合并次数为原始的权值数-1)。

霍夫曼树的节点结构
对权值进行构造，将其初始化为只有一个节点的树，同时该树附带了对应的权值。

template <typename T>
struct huffmanTreeNode
{
	//该节点的结构可以看成每个单节点树都伴随一个外部扩展域，外部扩展域中存着它的权重
	binaryTreeChain<T>* huffTree;//指向仅由单节点构成的二叉树
	T weight;//外部扩展域，存有权值
	operator T () { return weight; }//小根堆中的initial()函数需要根据<来比较T 然后堆化
	bool operator<(const huffmanTreeNode<T>& rhs)const { return weight < rhs.weight; }
};

霍夫曼树的构建

//从给定的arrSize个权值的数组构造霍夫曼树
template <typename T>
binaryTreeChain<T>* huffmanTree(T weight[], size_t arrSize) {
	//存放一组单节点树的数组
	huffmanTreeNode<T>* huffNodes = new huffmanTreeNode<T>[arrSize];
	for (int i = 0; i < arrSize;++i) {
		huffNodes[i].weight = weight[i];
		huffNodes[i].huffTree = new binaryTreeChain<int>;
		binaryTreeChain<int> emptyTree;
		huffNodes[i].huffTree->makeTree(i+1,emptyTree,emptyTree);
	}

	//将该数组传入最小堆的initial函数 构建最小堆
	minHeap<huffmanTreeNode<T>> heap;
	heap.heapInitial(huffNodes, arrSize);

	//不断从小根堆中获取权值最小的两个树进行合并 直到剩下一棵树
	huffmanTreeNode<T> min1, min2, mergedNode;//权值最小的两颗树，新合并的霍夫曼节点
	binaryTreeChain<int>* mergedTree;//新合并的霍夫曼树结构
	for (int i = 0; i < arrSize - 1;++i) {
		min1 = heap.top();
		heap.pop();
		min2 = heap.top();
		heap.pop();
		//合并成两颗新的树 
		mergedTree = new binaryTreeChain<int>;
		mergedTree->makeTree(0,*min1.huffTree,*min2.huffTree);
		//并且构成新的霍夫曼节点 存入最小堆
		mergedNode.weight = min1.weight + min2.weight;
		mergedNode.huffTree = mergedTree;
		heap.push(mergedNode);
		//删除两个空树
		delete min1.huffTree;
		delete min2.huffTree;
	}

	return heap.top().huffTree;
}


//===========================test for huffman tree===========================
//层序遍历后可以看到带权值的节点全部作为叶子节点。
//权值小的层数大远离根节点，权值大的层数小靠近根节点。
//也没出现编码重复
int main() {
	int a[]{ 6,2,3,4,9 };
	binaryTreeChain<int>* huffTree = huffmanTree(a, 5);
	huffTree->levelOrderOutput();
	return 0;
}