二叉树：层次遍历和应用

声明：

数据结构和功能函数如之前博客所述，如有疑问，详见系列博客

版权所有，如果转载，请注明出处http://blog.csdn.net/tubin100

一 层次遍历

层次遍历：需要队列作为数据结构

代码如下：

void LevelOrder(BiTree T) {
if (nullptr == T) {
Error();
return;
}

std::queue<BiTNode*> q;
BiTNode *p = T;

q.push(p);
while (!q.empty()) {
p = q.front();
q.pop();

visit(p);

if (p->lChild) {
q.push(p->lChild);
}
if (p->rChild) {
q.push(p->rChild);
}
}
}

二 层次遍历应用

1 从下到上，从右到左遍历二叉树

思路分析：

层次遍历每一个节点，每次出队列同时，进入另一个栈，遍历结束后，顺序弹出栈中内容即可。

void LevelOrder_Invert(BiTree T) {
if (nullptr == T) {
Error();
return;
}

std::queue<BiTNode*> q;
std::stack<BiTNode*> st;
BiTNode *p = T;

q.push(p);
while (!q.empty()) {
p = q.front();
q.pop();

st.push(p);

if (p->lChild) {
q.push(p->lChild);
}
if (p->rChild) {
q.push(p->rChild);
}
}

while (!st.empty()) {
std::cout << (st.top())->data << " ";
st.pop();
}
}

2 判断是否为完全二叉树

思路分析：

a 层次遍历二叉树，不判断孩子节点是否为空，直接入队。

b 每次出队时，判断是否为空，

c 一旦有一个节点为空，则根据完全二叉树的性质，队列中若还有元素，则全部应该为空；

d 若出现一个节点不为空，则立即判断不是完全二叉树；

bool IsCompleteTree(BiTree T) {
if (nullptr == T) {
Error();
return false;
}

std::queue<BiTNode*> q;
BiTNode *p = T;
q.push(p);

while (!q.empty()) {
p = q.front();
q.pop();

if (p) {
q.push(p->lChild);
q.push(p->rChild);
} else {
while (!q.empty()) {
p = q.front();
q.pop();

if (nullptr != p) {
return false;
}
}
}
}

return true;
}

3 删除以x为根节点的子树

3.1 递归删除二叉树

首先引入，递归删除二叉树的代码。

void DeleteTree(BiTNode* T) {
if (T) {
DeleteTree(T->lChild);
DeleteTree(T->rChild);
delete T;
}
}

3.2 删除以x为根节点的子树

为什么要用层次遍历？

因为删除一个以x为根的节点需要设置x的父节点的孩子域，所以得需要明确父子关系，层次遍历是简单的选择。

思路分析：

层次遍历二叉树，查找以x为儿子的节点，如果找到了，删除该子树，并设置孩子域为空。

代码如下：

bool DeleteXTree(BiTree T, BTElemType x) {
if (nullptr == T) {
Error();
return false;
}

std::queue<BiTNode*> q;
BiTNode *p = T;
q.push(p);

while (!q.empty()) {
p = q.front();
q.pop();

if (p->lChild && p->lChild->data == x) {
DeleteTree(p->lChild);
p->lChild = nullptr;
return true;
}
if (p->rChild && p->rChild->data == x) {
DeleteTree(p->rChild);
p->rChild = nullptr;
return true;
}
}
return false;
}

4 非递归算法求解树的高度

思路分析

a 用一个last指针指向每一层节点的最后一个元素

b 元素正常入队。

c 每次出队时，front指针会自增，每当front指针 ‘赶上’ 了 last指针时，说明此时一层已经完全出队。此时设置last指针指向rear指针，并且level自增

代码如下：

int BiTreeHeight_non_recur(BiTree T) {
if (!T) {
return 0;
}

//模拟队列
int front, rear;
BiTNode* q[50];    //假设元素个数小于50
front = rear = -1;

int level = 0;  //标识层次
int last = 0;   //标识当前层中最右端节点

BiTNode *p = T;
++rear;
q[rear] = p;

while (front < rear) {
++front;
p = q[front];

if (p->lChild) {
++rear;
q[rear] = p->lChild;
}
if (p->rChild) {
++rear;
q[rear] = p->rChild;
}

//关键点
if (front == last) {  //front 赶上了 last
++level;
last = rear;    //重新指向当前层的最右端节点
}
}

return level;
}

5 求二叉树宽度

思路分析：

a 定义结构体如下：

typedef struct WidthNode {
BiTNode *pointer;
int level;
}WidthNode;

b 每个节点都有层号。

设置根节点的层号为1，通过遍历的过程给每个节点设置层号，可以得到一组带有层号的节点队列。

c 层号出现次数最多，则出现的次数即为二叉树的宽度。

d 通过遍历该队列，将层号映射到数组中，通过一次遍历数组即可求得层号出现最多的次数。

代码如下：

int BiTreeWidth(BiTree T) {
if (!T) {
return 0;
}

WidthNode q[50];
int front, rear;
front = rear = -1;

WidthNode p;
p.pointer = T;
p.level = 1;    //根节点的层号为1

++rear;
q[rear] = p;

WidthNode temp;

while (front < rear) {
++front;
p = q[front];

if (p.pointer->lChild) {
temp.pointer = p.pointer->lChild;
temp.level = p.level + 1;

++rear;
q[rear] = temp;
}
if (p.pointer->rChild) {
temp.pointer = p.pointer->rChild;
temp.level = p.level + 1;

++rear;
q[rear] = temp;
}
}

//假设树高不超过10
//在一组数据中选择一个出现次数最大的数----
//数据的特点：递增，且范围在1-height之间，
//思路：把数据映射到数组中
int a[11] = {0};
for (int i = 0; i <= rear; ++i) {
++a[q[i].level];
}

int width = -1;
for (int i = 0; i < 11; i++) {
if (a[i] > width) {
width = a[i];
}
}

return width;
}

6 总结

1 在熟练掌握了层次遍历的基本框架之后，对于一些简单的应用还是比较熟练的用代码实现。

2 只是其中有些并没有考虑到扩展性，例如自定义的队列数组的大小，这个在实践中最好是不要用的额，因为很容易有各种问题（空间不足或者资源浪费）。