6.3.1 遍历二叉树

为什么特别讨论二叉树的遍历

• 之前处理的都是线性结构，线性结构的遍历只有一条路径，遍历起来十分简单。

• 二叉树是非线性结构，每个结点可能有两个子树 / 后继，因此需要确定遍历的方法，
  使二叉树上的所有结点都能排在一个线性队列上，保证一次遍历完成每个结点都被访问一次。

二叉树遍历的实质

• 以一定的规则将二叉树中的结点排列成一个线性序列。
• 对一个非线性结构进行线性化操作。

如何遍历二叉树（基于二叉链表）

• 遍历二叉树
  按某种搜索路径访问二叉树中的所有结点，使得每个结点均被访问一次。
  访问的含义很广泛，泛指对结点的各种操作。

• 遍历方法（以二叉链表为例）
  二叉链表结点有三个基本单元：根结点，左子树，右子树。若能依次遍历这三个部分，便是实现了 “遍历” 整个二叉树的目标。
  令
  L 表示 遍历左子树
  D 表示 访问根节点
  R 表示 访问右子树
  那么有 LDR，LRD，DLR，DRL，RLD，RDL 六种方法。
  本次讨论，限定先左后右，遍历有三种方式：DLR，LDR，LRD。分别称之为 先(根)序遍历，中(根)序遍历，后(根)序遍历。
  如采用了先序遍历，那么对二叉链表中的每一个结点，都是先访问根结点，再访问它的左子树，最后访问它的右子树。
  单独的先序 / 中序 / 后序列表无法唯一的确定二叉树，先序和中序结合起来可以唯一的确定一个二叉树。

代码实例

• 二叉链表、先序算法 （递归）

// 此语句实现先序遍历
PreOrderTraverse(T, PrintElement);

// 二叉链表结点类型定义
typedef struct BiTNode
{
	TElemType data;
	struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree

// 此为遍历的 “访问操作”
Status PrintElement(TElemType e)
{
	printf(e);
	return OK;
}

// 先序遍历
Status PreOrderTraverse(BiTNode T, Status (*visit)(TElemType e))
{
	if(T)
	{
		// 二叉链表T 为非空表

		// 先访问根节点
		if(visit(T->data))
		{
			// 访问左子树
			if(PreOrderTraverse(T->lchild, visit))
			{
				// 访问右子树
				if(PreOrderTraverse(T->rchild, visit))
				{
					return OK;
				}
			}
		}
		return ERROR;
	}
	else
	{
		// T为空二叉链表
		return OK;
	}
}

• 先序建立二叉树 / 二叉链表 （递归）

// 二叉链表结点类型定义
typedef struct BiTNode
{
	TElemType data;
	struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree

Status CreateBiTree(BiTree &T)
{
	scanf(&ch);
	if(ch == ' ')
	{
		// 空格字符表示 空(子)树 / 空结点
		T = NULL;
	}
	else
	{
		// 字符非空则先建立一个根结点
		if(!(T = (BiTNode* )malloc(sizeof(BiTNode))))
		{
			exit(OVERFLOW);
		}
		// 生成(根)结点
		T->data = ch;
		// 构造(根)结点的左子树
		CreateBiTree(T->lchild);
		// 构造(根)结点的右子树
		CreateBiTree(T->rchild);
	}
	return OK;
}

• 利用栈先序遍历二叉树

Status POTraverse(BiTree &T, Status (*visit)(TElemtype e))
{
	BiTree p;
	Stack s;
	InitStack(s);
	p = T;
	while(p || StackEmpty(s))
	{
		if(p)
		{
			// 若指针不空，访问根结点
			// 右指针压栈，继续遍历左子树
			if(!visit(p->data))
			{
				return ERROR;
			}
			Push(s, p->rchild);
			p = p->lchild;
		}
		else
		{
			// 开始访问每一级的右子树
			Pop(s, p);
		}
	}
	return OK;
}

• 二叉树表示表达式
  操作数都在叶子结点上，操作符都在分支结点上。
  表达式 = （第一操作数）（操作符）（第二操作数）
  操作符视为根结点
第一操作数视为左孩子
第二操作数视为右孩子
先序遍历：操作符，第一操作数，第二操作数（波兰式）
  后序遍历：第一操作数，第二操作数，操作符（逆波兰式）
  以 a + b * ( c - d ) - e / f 为例：
  
  先序遍历：- + a * b - c d / e f ( 波兰式 )
  中序遍历：a + b * ( c - d ) - e / f
  后序遍历：a b c d - * + e f / - ( 逆波兰式 )

// 建立叶子结点（操作数结点）
void CrtNode(BiTree &T, char ch)
{
	T = (BiTNode* )malloc(sizeof(BiTNode));
	T->data = ch;
	T->lchild = T->rchild = NULL;
	Push(PTR, T); // 入操作数栈
}

// 建子树算法
void CrtSubtree(Bitree &T, char c)
{
	T = (BiTNode* )malloc(sizeof(BiTNode));
	T->data = c;
	Pop(PTR, rc);
	T->rchild = rc;
	Pop(PTR, lc);
	T->lchild = lc;
	// 压入操作数栈，三者合并堪称一个操作数
	Push(PTR, T);
}
void CrtExpTree(BiTree &T, char exp[])
{
	// 存放操作符的栈
	InitStack(S);
	Push(S,'#');
	// 存放操作数的栈
	InitStack(PTR);
	p = exp;
	ch = *p;
	while(!(GetTop(S) == '#' && ch == '#'))
	{
		if(!IN(ch, OP))
		{
			// 不是运算操作符，则建立叶子结点
			CrtNode(t, ch);
		}
		else
		{
			switch (ch)
			{
				case '(':
					Push(S, ch);
					break;
				case ')':
					Pop(S, c);
					while(c != '(')
					{
						CrtSubtree(t, c);
						Pop(S, c);
					}
					break;
				default:
					while(!GetTop(S, c) && (precede(c, ch)))
					{
						// 栈顶的优先级较高的情况
						CrtSubTree(t, c);
						Pop(S, c);
					}
					if(ch != '#')
					{
						Push(S, ch);
					}
					break;
			}
		}
		if(ch != '#')
		{
			p++;
			ch = *p;
		}
	}
	Pop(PTR, T);
}

• 中序遍历二叉树 / 二叉链表 法1（非递归）

Status InOrderTraverse(BiTree T, Status (*visit)(TElemType e))
{
	//中序遍历二叉链表 / 二叉树 T，对每个数据调用函数visit
	//初始化一个栈，由于是中序，先路过的结点不一定先访问，
	//可能是返回的时候访问，因此要先保存下来，存于栈中。
	//栈的大小设置为二叉树的深度即可
	//栈中的元素表明它本身和它右边的结点还没有被访问
	InitStack(S);
	//根指针进栈
	Push(S, T);
	while(!StackEmpty(S))
	{
		while(GetTop(S, p) && p)
		{
			//向左走到尽头，沿途每一个结点都入栈
			Push(S, p->lchild);
		}
		//空指针出栈
		Pop(S, p);
		if(!StackEmpty(S))
		{
			Pop(S, p);
			if(!visit(p->data))
			{
				//访问失败，直接退出
				return ERROR;	
			}
			Push(S, p->rchild); // 关键的一句
		}
	}
	return OK;
}

• 中序遍历二叉树 / 二叉链表 法2（非递归）

Status InOrderTraverse(BiTree T, Status (*visit)(TElemType e))
{
	InitStack(S);
	p = T;
	while(p || !StackEmpty(S))
	{
		if(p)
		{
			Push(S, p);
			p = p->lchild;
		}
		else
		{
			// 根结点退栈，访问根节点，遍历右子树
			Pop(S, p);
			if(!visit(p->data))
			{
				return ERROR;
			}
			p = p->rchild; // 关键，由此实现中序
		}
	}
	return OK;
}

• 交换二叉树中每一级的左右子树 (递归实现)

Status ExchangeBiTree(BiTree &T)
{
	BiTree p;
	if(T)
	{
		p = T->lchild;
		T->lchild = T->rchild;
		T->rchild = p;
		ExchangeBiTree(T->lchild);
		ExchangeBiTree(T->rchild);
	}
	return OK;
}