最小堆實現哈夫曼樹構造

0. 序

• 本以為用最小堆實現個哈夫曼樹是個簡單的事情，結果一不小心就花了好幾個小時才寫完。。。實現過程中主要有三個方面的問題沒注意，導致花了很多時間進行調試。
  • 一是多重指針malloc分配時要多加注意；
  • 二是指針一定要記得初始化，默認不一定為NULL；
  • 三是結構體賦值問題。
• 其余的邊界問題小心就好了。。另，由於本人水平有限，如有任何問題，歡迎指出解決，謝謝大家！詳細結果如下：

1. 哈夫曼樹結構定義如下：

// 定義哈夫曼樹結構
struct TreeNode {
	int weight;
	TreeNode* lChild;
	TreeNode* rChild;
};

2. 最小堆結構定義如下：

// 定義最小堆結構
struct MinHeap {
	TreeNode* p;    // 指向存儲元素的數組
	int size;       // 當前元素個數
	int capacity;   // 最大容量
};

3. 基本操作函數如下：

• MinHeap* createMinHeap(int capacity); // 創建最小堆
• bool isFull(MinHeap* minHeap); // 判斷最小堆是否已滿）
• void printMinHeap(MinHeap* minHeap); // 遍歷最小堆元素
• void insertMinHeap(MinHeap* minHeap, TreeNode* node); // 插入元素
• void minHeapAdjust(MinHeap* minHeap, int parent); // 最小堆調整
• void buildMinHeap(MinHeap* minHeap); // 調整法建立最小堆（n）
• bool isEmpty(MinHeap* minHeap); // 判斷最小堆是否為空
• TreeNode* deleteMin(MinHeap* minHeap); // 刪除最小元素並返回
• void preOrderTraverse(TreeNode* head); // 先序遍歷（遞歸）
• TreeNode* buildHuffmanTree(MinHeap* minHeap); // 構造哈夫曼樹

4. 具體代碼實現如下：

#include <iostream>

using namespace std;

#define MinData -100000
#define SIZE 10

// 定義哈夫曼樹結構
struct TreeNode {
	int weight;
	TreeNode* lChild;
	TreeNode* rChild;
};

// 定義最小堆結構
struct MinHeap {
	TreeNode* p;    // 指向存儲元素的數組
	int size;       // 當前元素個數
	int capacity;   // 最大容量
};

// 創建最小堆
MinHeap* createMinHeap(int capacity) {
	MinHeap* minHeap = (MinHeap*)malloc(sizeof(MinHeap));
	minHeap->p = (TreeNode*)malloc((capacity + 1)* sizeof(TreeNode));
	minHeap->size = 0;
	minHeap->capacity = capacity;
	minHeap->p[0].weight = MinData;
	minHeap->p[0].lChild = NULL;
	minHeap->p[0].rChild = NULL;
	return minHeap;
}

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

// 遍歷最小堆元素
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].weight << " ";
	}
	cout << endl;
}

// 插入元素
void insertMinHeap(MinHeap* minHeap, TreeNode* node) {
	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].weight > node->weight; i /= 2) {
		minHeap->p[i].weight = minHeap->p[i / 2].weight;
		minHeap->p[i].lChild = minHeap->p[i / 2].lChild;
		minHeap->p[i].rChild = minHeap->p[i / 2].rChild;
	}
	minHeap->p[i].weight = node->weight;
	minHeap->p[i].lChild = node->lChild;
	minHeap->p[i].rChild = node->rChild;
}

// 最小堆調整
void minHeapAdjust(MinHeap* minHeap, int parent) {
	int temp = minHeap->p[parent].weight;
	int child = 0;
	for (; parent * 2 <= minHeap->size; parent = child) {
		child = parent * 2;
		if (child < minHeap->size && 
			minHeap->p[child + 1].weight < minHeap->p[child].weight) {
			child++;
		}
		if (temp <= minHeap->p[child].weight) {
			break;
		}
		else {
			minHeap->p[parent].weight = minHeap->p[child].weight;
		}
	}
	minHeap->p[parent].weight = temp;
}

// 調整法建立最小堆（n）
void buildMinHeap(MinHeap* minHeap) {
	for (int i = minHeap->size / 2; i > 0; i--) {
		minHeapAdjust(minHeap, i);
	}
}

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

// 刪除最小元素並返回
TreeNode* 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;
	}
	TreeNode* minNode = (TreeNode*)malloc(sizeof(TreeNode));
	minNode->weight = minHeap->p[1].weight;
	minNode->lChild = minHeap->p[1].lChild;
	minNode->rChild = minHeap->p[1].rChild;
	int last = minHeap->p[minHeap->size--].weight;
	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].weight < minHeap->p[child].weight) {
			child++;
		}
		if (last < minHeap->p[child].weight) {
			break;
		}
		else {
			minHeap->p[parent].weight = minHeap->p[child].weight;
			minHeap->p[parent].lChild = minHeap->p[child].lChild;
			minHeap->p[parent].rChild = minHeap->p[child].rChild;
		}
	}
	minHeap->p[parent].weight = last;
	minHeap->p[parent].lChild = minHeap->p[minHeap->size + 1].lChild;
	minHeap->p[parent].rChild = minHeap->p[minHeap->size + 1].rChild;
	return minNode;
}

// 先序遍歷（遞歸）
void preOrderTraverse(TreeNode* head) {
	if (head) {
		cout << head->weight << " ";
		preOrderTraverse(head->lChild);
		preOrderTraverse(head->rChild);
	}
}

// 構造哈夫曼樹
TreeNode* buildHuffmanTree(MinHeap* minHeap) {
	TreeNode* huffmanTreeNode = NULL;
	buildMinHeap(minHeap);
	for (int i = 0; i < minHeap->capacity - 1; i++) {
		huffmanTreeNode = (TreeNode*)malloc(sizeof(TreeNode));
		huffmanTreeNode->lChild = deleteMin(minHeap); 
		huffmanTreeNode->rChild = deleteMin(minHeap); 
		huffmanTreeNode->weight = huffmanTreeNode->lChild->weight 
			+ huffmanTreeNode->rChild->weight;
		insertMinHeap(minHeap, huffmanTreeNode);
	}
	huffmanTreeNode = deleteMin(minHeap);
	return huffmanTreeNode;
}

int main() {

	MinHeap* minHeap = NULL;
	minHeap = createMinHeap(SIZE);
	for (int i = 0; i < SIZE; i++) {
		minHeap->p[i + 1].weight = SIZE - i;
		minHeap->p[i + 1].lChild = NULL;
		minHeap->p[i + 1].rChild = NULL;
		minHeap->size++;
	}

	cout << "原始數據序列：" << endl;
	printMinHeap(minHeap);
	buildMinHeap(minHeap);
	cout << "最小堆數據序列：" << endl;
	printMinHeap(minHeap);

	TreeNode* huffumanTree = NULL;
	huffumanTree = buildHuffmanTree(minHeap);
	cout << "哈夫曼樹先序遍歷序列：" << endl;
	preOrderTraverse(huffumanTree);
	cout << endl;

	system("pause");

	return 0;
}

5. 運行結果截圖如下：

6. 哈夫曼樹構造如下：