在上一篇中我記錄了二叉樹的先序，中序，後序的遞迴和非遞迴遍歷方法，這一篇會接著上一篇的，記錄二叉樹的層序遍歷方法，層序遍歷用到了佇列的資料結構，下面直接上程式碼：

1、首先是鏈佇列的資料結構定義，LinkQueue.h檔案：

#pragma once
#include "BinaryTree.h"

/** 鏈佇列的節點定義，包含一個數據域和下一個節點的指標 */
typedef struct QueueNode {
	BiTreeNode* data;
	struct QueueNode* next;
}QueueNode;

/**  鏈佇列的定義，包含隊頭和隊尾指標*/
typedef struct {
	QueueNode* front;
	QueueNode* rear;
}LinkQueue;

LinkQueue* InitQueue();/** 鏈佇列的初始化 */
void DestoryQueue(LinkQueue*);/** 銷燬佇列 */
void EnQueue(LinkQueue*, BiTreeNode*);/** 入隊 */
BiTreeNode* DeQueue(LinkQueue*);/** 出隊 */
 

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

/** 鏈佇列的初始化 */
LinkQueue* InitQueue()
{
	LinkQueue* queue = (LinkQueue*)malloc(sizeof(LinkQueue));
	if (!queue)
	{
		printf("init queue error!\n");
		exit(0);
	}
	queue->front = (QueueNode*)malloc(sizeof(QueueNode));
	queue->front->next = NULL;
	queue->rear = queue->front;
	return queue;
}

/** 鏈佇列的銷燬，注意先進去的是佇列頭，後進去的是佇列尾 */
void DestoryQueue(LinkQueue* queue)
{
	while (queue->front)
	{
		queue->rear = queue->front->next;
		free(queue->front);
		queue->front = queue->rear;
	}
}

/** 入隊 */
void EnQueue(LinkQueue* queue, BiTreeNode* node)
{
	QueueNode* queueNode = (QueueNode*)malloc(sizeof(QueueNode));
	queueNode->data = node;
	queueNode->next = NULL;
	queue->rear->next = queueNode;
	queue->rear = queueNode;
}

/** 出隊 */
BiTreeNode* DeQueue(LinkQueue* queue)
{
	if (queue->front == queue->rear)//佇列為空
		return NULL;
	QueueNode* p = queue->front->next;
	BiTreeNode* node = p->data;
	queue->front = p;
	return node;
}
 

3、層序遍歷的主要程式碼

void LayerOrderBiTree(struct BiTreeNode* root)
{
	int curLayerCount = 0; //當前層中的節點數
	int nextLayerCount = 0; //下一層中的節點數
	struct Queue* queue = InitQueue();
	EnQueue(queue, root);
	curLayerCount++;
	struct BiTreeNode* p;
	while (p = DeQueue(queue))
	{
		curLayerCount--;
		printf("%c ", p->val);
		if (p->left)
		{
			EnQueue(queue, p->left);
			nextLayerCount++;
		}
		if (p->right)
		{
			EnQueue(queue, p->right);
			nextLayerCount++;
		}
		if (curLayerCount == 0)//一層已經遍歷完畢
		{
			curLayerCount = nextLayerCount;
			nextLayerCount = 0;
			printf("\n");
		}
	}
}
 

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

void printResult(char *msg, void(*p)(BiTreeNode*), BiTreeNode* node)
{
	printf("\n---------%s---------\n", msg);
	p(node);
	printf("\n---------%s---------\n", msg);
}

int main()
{
	printf("使用先序建立二叉樹，#表示空節點，請輸入二叉樹的資料：\n");
	BiTreeNode* root = CreateBinaryTree();

	printResult("層序遍歷", LayerOrderBiTree, root);

	return 0;
}

程式碼執行結果如下圖：

下面記錄遇到的坑：

在實現佇列的出隊操作時，程式碼如下：

開始我的程式碼寫錯了，第46行寫成了QueueNode* p = queue->front，結果執行報錯，單步跟蹤後發現出隊不正確，後來檢查原來46行程式碼不對，原因是初始化佇列時，給對頭分配了記憶體空間，然後對頭跟隊尾都指向該空間，但是入隊的時候該空間是沒有用到的，就相當於建立單鏈表時帶了一個頭結點，如下圖所示：

所以出隊的時候，隊頭節點應該是queue->front->next，而不是queue->front！！！

------------------------------這裡是分割線-------------------------------

今天在網上看到一種遞迴輸出層序結果的方法，記錄如下，直接上所有程式碼：

#include<iostream>
#include<stdlib.h>
using namespace std;

typedef struct Node {
	char val;
	struct Node* left = NULL;
	struct Node* right = NULL;
}TreeNode, *Tree;

Tree createTree() {
	char c;
	cin >> c;
	if(c == '#') return NULL;
	Tree tree = (Tree)malloc(sizeof(Tree));
	tree->val = c;
	tree->left = createTree();
	tree->right = createTree();
	return tree;
} 

void preOrder(Tree tree) {
	TreeNode* p = tree;
	if(p) {
		cout << p->val << " ";
		preOrder(p->left);
		preOrder(p->right);
	}
}

//列印第level行的節點，有列印輸出則返回true，否則返回false 
bool printLevel(Tree tree, int level) {
	if(!tree || level < 0) {
		return false;
	}
	if(level == 0) {
		cout << tree->val << " ";
		return true;
	}
	return printLevel(tree->left, level - 1) + printLevel(tree->right, level - 1);
}

//層序遍歷，當某一行沒有列印時break掉迴圈 
void levelOrder(Tree tree) {
	for(int i = 0; ; i++) {
		if(!printLevel(tree, i)) {
			break;
		}
	}
}

int main()
{
	Tree tree = createTree();
	cout << "pre order: " << endl;
	preOrder(tree);
	cout << "\nlevel order: " << endl;
	levelOrder2(tree);
	return 0;
}

測試結果如下圖：

遞迴的程式碼比非遞迴簡單，但是複雜度可能就沒有非遞迴那麼低了