二叉树的遍历有三种方式,如下:
(1)前序遍历(DLR),首先访问根结点,然后遍历左子树,最后遍历右子树。简记根-左-右。
(2)中序遍历(LDR),首先遍历左子树,然后访问根结点,最后遍历右子树。简记左-根-右。
(3)后序遍历(LRD),首先遍历左子树,然后遍历右子树,最后访问根结点。简记左-右-根。
例1:如上图所示的二叉树,若按前序遍历,则其输出序列为 。若按中序遍历,则其输出序列为 。若按后序遍历,则其输出序列为 。
前序:根A,A的左子树B,B的左子树没有,看右子树,为D,所以A-B-D。再来看A的右子树,根C,左子树E,E的左子树F,E的右子树G,G的左子树为H,没有了结束。连起来为C-E-F-G-H,最后结果为ABDCEFGH
中序:先访问根的左子树,B没有左子树,其有右子树D,D无左子树,下面访问树的根A,连起来是BDA。
再访问根的右子树,C的左子树的左子树是F,F的根E,E的右子树有左子树是H,再从H出发找到G,到此C的左子树结束,找到根C,无右子树,结束。连起来是FEHGC, 中序结果连起来是BDAFEHGC
后序:B无左子树,有右子树D,再到根B。再看右子树,最下面的左子树是F,其根的右子树的左子树是H,再到H的根G,再到G的根E,E的根C无右子树了,直接到C,这时再和B找它们其有的根A,所以连起来是DBFHGECA
例2:有下列二叉树,对此二叉树前序遍历的结果为( )。
A)ACBEDGFH B)ABDGCEHF
C)HGFEDCBA D)ABCDEFGH
解析:先根A,左子树先根B,B无左子树,其右子树,先根D,在左子树G,连起来是ABDG。 A的右子树,先根C,C左子树E,E无左子树,有右子树为H,C的右子树只有F,连起来是CEHF。整个连起来是B答案 ABDGCEHF。
例3:已知二叉树后序遍历是DABEC,中序遍历序列是DEBAC,它的前序遍历序列是( ) 。
A)CEDBA B)ACBED C)DECAB D)DEABC
解析:由后序遍历可知,C为根结点,由中序遍历可知,C左边的是左子树含DEBA,C右边无结点,知根结点无右子树。先序遍历先访问根C,答案中只有A以C开头,为正确答案。
后序遍历是DABEC,中序遍历序列是DEBAC
例4: 如下二叉树中序遍历的结果是( )。
A). ACBDFEG B). ACBDFGE C).ABDCGEF D).FCADBEG
解析:首先中序遍历根F会把左右子树分开,F不会在答案的开头和结尾,排除C和D。在看F的右子树,G是E的右子树,中序遍历先访问E,再访问G,E在G前面,排除B。答案为A。
例5:如下二叉树后序遍历的结果是( )。
A) ABCDEF B) DBEAFC C)ABDECF D)DEBFCA
解析:后序的最后一个必须是二叉树的根,快速判断答案为D。
二叉树的链式存储结构是一类重要的数据结构,其形式定义如下:
- //二叉树结点
- typedef struct BiTNode{
- //数据
- char data;
- //左右孩子指针
- struct BiTNode *lchild,*rchild;
- }BiTNode,*BiTree;
通过读入一个字符串,建立二叉树的算法如下:
- //按先序序列创建二叉树
- int CreateBiTree(BiTree &T){
- char data;
- //按先序次序输入二叉树中结点的值(一个字符),‘#’表示空树
- scanf("%c",&data);
- if(data == '#'){
- T = NULL;
- }
- else{
- T = (BiTree)malloc(sizeof(BiTNode));
- //生成根结点
- T->data = data;
- //构造左子树
- CreateBiTree(T->lchild);
- //构造右子树
- CreateBiTree(T->rchild);
- }
- return 0;
- }
二叉树的遍历:
遍历是对树的一种最基本的运算,所谓遍历二叉树,就是按一定的规则和顺序走遍二叉树的所有结点,使每一个结点都被访问一次,而且只被访问一次。由于二叉树是非线性结构,因此,树的遍历实质上是将二叉树的各个结点转换成为一个线性序列来表示。
递归算法:
- //输出
- void Visit(BiTree T){
- if(T->data != '#'){
- printf("%c ",T->data);
- }
- }
- //先序遍历
- void PreOrder(BiTree T){
- if(T != NULL){
- //访问根节点
- Visit(T);
- //访问左子结点
- PreOrder(T->lchild);
- //访问右子结点
- PreOrder(T->rchild);
- }
- }
- //中序遍历
- void InOrder(BiTree T){
- if(T != NULL){
- //访问左子结点
- InOrder(T->lchild);
- //访问根节点
- Visit(T);
- //访问右子结点
- InOrder(T->rchild);
- }
- }
- //后序遍历
- void PostOrder(BiTree T){
- if(T != NULL){
- //访问左子结点
- PostOrder(T->lchild);
- //访问右子结点
- PostOrder(T->rchild);
- //访问根节点
- Visit(T);
- }
- }
非递归算法:
<1>先序遍历:
【思路】:访问T->data后,将T入栈,遍历左子树;遍历完左子树返回时,栈顶元素应为T,出栈,再先序遍历T的右子树。
- /* 先序遍历(非递归)
- 思路:访问T->data后,将T入栈,遍历左子树;遍历完左子树返回时,栈顶元素应为T,出栈,再先序遍历T的右子树。
- */
- void PreOrder2(BiTree T){
- stack<BiTree> stack;
- //p是遍历指针
- BiTree p = T;
- //栈不空或者p不空时循环
- while(p || !stack.empty()){
- if(p != NULL){
- //存入栈中
- stack.push(p);
- //访问根节点
- printf("%c ",p->data);
- //遍历左子树
- p = p->lchild;
- }
- else{
- //退栈
- p = stack.top();
- stack.pop();
- //访问右子树
- p = p->rchild;
- }
- }//while
- }
【思路】:T是要遍历树的根指针,中序遍历要求在遍历完左子树后,访问根,再遍历右子树。
先将T入栈,遍历左子树;遍历完左子树返回时,栈顶元素应为T,出栈,访问T->data,再中序遍历T的右子树。
- void InOrder2(BiTree T){
- stack<BiTree> stack;
- //p是遍历指针
- BiTree p = T;
- //栈不空或者p不空时循环
- while(p || !stack.empty()){
- if(p != NULL){
- //存入栈中
- stack.push(p);
- //遍历左子树
- p = p->lchild;
- }
- else{
- //退栈,访问根节点
- p = stack.top();
- printf("%c ",p->data);
- stack.pop();
- //访问右子树
- p = p->rchild;
- }
- }//while
- }
<3>后序遍历
【思路】:T是要遍历树的根指针,后序遍历要求在遍历完左右子树后,再访问根。需要判断根结点的左右子树是否均遍历过。
- //后序遍历(非递归)
- typedef struct BiTNodePost{
- BiTree biTree;
- char tag;
- }BiTNodePost,*BiTreePost;
- void PostOrder2(BiTree T){
- stack<BiTreePost> stack;
- //p是遍历指针
- BiTree p = T;
- BiTreePost BT;
- //栈不空或者p不空时循环
- while(p != NULL || !stack.empty()){
- //遍历左子树
- while(p != NULL){
- BT = (BiTreePost)malloc(sizeof(BiTNodePost));
- BT->biTree = p;
- //访问过左子树
- BT->tag = 'L';
- stack.push(BT);
- p = p->lchild;
- }
- //左右子树访问完毕访问根节点
- while(!stack.empty() && (stack.top())->tag == 'R'){
- BT = stack.top();
- //退栈
- stack.pop();
- BT->biTree;
- printf("%c ",BT->biTree->data);
- }
- //遍历右子树
- if(!stack.empty()){
- BT = stack.top();
- //访问过右子树
- BT->tag = 'R';
- p = BT->biTree;
- p = p->rchild;
- }
- }//while
- }
<4>层次遍历
【思路】:按从顶向下,从左至右的顺序来逐层访问每个节点,层次遍历的过程中需要用队列。
- //层次遍历
- void LevelOrder(BiTree T){
- BiTree p = T;
- //队列
- queue<BiTree> queue;
- //根节点入队
- queue.push(p);
- //队列不空循环
- while(!queue.empty()){
- //对头元素出队
- p = queue.front();
- //访问p指向的结点
- printf("%c ",p->data);
- //退出队列
- queue.pop();
- //左子树不空,将左子树入队
- if(p->lchild != NULL){
- queue.push(p->lchild);
- }
- //右子树不空,将右子树入队
- if(p->rchild != NULL){
- queue.push(p->rchild);
- }
- }
- }
测试用例:
输入:
ABC##DE#G##F###
输出:
代码:
- #include<iostream>
- #include<stack>
- #include<queue>
- using namespace std;
- //二叉树结点
- typedef struct BiTNode{
- //数据
- char data;
- //左右孩子指针
- struct BiTNode *lchild,*rchild;
- }BiTNode,*BiTree;
- //按先序序列创建二叉树
- int CreateBiTree(BiTree &T){
- char data;
- //按先序次序输入二叉树中结点的值(一个字符),‘#’表示空树
- scanf("%c",&data);
- if(data == '#'){
- T = NULL;
- }
- else{
- T = (BiTree)malloc(sizeof(BiTNode));
- //生成根结点
- T->data = data;
- //构造左子树
- CreateBiTree(T->lchild);
- //构造右子树
- CreateBiTree(T->rchild);
- }
- return 0;
- }
- //输出
- void Visit(BiTree T){
- if(T->data != '#'){
- printf("%c ",T->data);
- }
- }
- //先序遍历
- void PreOrder(BiTree T){
- if(T != NULL){
- //访问根节点
- Visit(T);
- //访问左子结点
- PreOrder(T->lchild);
- //访问右子结点
- PreOrder(T->rchild);
- }
- }
- //中序遍历
- void InOrder(BiTree T){
- if(T != NULL){
- //访问左子结点
- InOrder(T->lchild);
- //访问根节点
- Visit(T);
- //访问右子结点
- InOrder(T->rchild);
- }
- }
- //后序遍历
- void PostOrder(BiTree T){
- if(T != NULL){
- //访问左子结点
- PostOrder(T->lchild);
- //访问右子结点
- PostOrder(T->rchild);
- //访问根节点
- Visit(T);
- }
- }
- /* 先序遍历(非递归)
- 思路:访问T->data后,将T入栈,遍历左子树;遍历完左子树返回时,栈顶元素应为T,出栈,再先序遍历T的右子树。
- */
- void PreOrder2(BiTree T){
- stack<BiTree> stack;
- //p是遍历指针
- BiTree p = T;
- //栈不空或者p不空时循环
- while(p || !stack.empty()){
- if(p != NULL){
- //存入栈中
- stack.push(p);
- //访问根节点
- printf("%c ",p->data);
- //遍历左子树
- p = p->lchild;
- }
- else{
- //退栈
- p = stack.top();
- stack.pop();
- //访问右子树
- p = p->rchild;
- }
- }//while
- }
- /* 中序遍历(非递归)
- 思路:T是要遍历树的根指针,中序遍历要求在遍历完左子树后,访问根,再遍历右子树。
- 先将T入栈,遍历左子树;遍历完左子树返回时,栈顶元素应为T,出栈,访问T->data,再中序遍历T的右子树。
- */
- void InOrder2(BiTree T){
- stack<BiTree> stack;
- //p是遍历指针
- BiTree p = T;
- //栈不空或者p不空时循环
- while(p || !stack.empty()){
- if(p != NULL){
- //存入栈中
- stack.push(p);
- //遍历左子树
- p = p->lchild;
- }
- else{
- //退栈,访问根节点
- p = stack.top();
- printf("%c ",p->data);
- stack.pop();
- //访问右子树
- p = p->rchild;
- }
- }//while
- }
- //后序遍历(非递归)
- typedef struct BiTNodePost{
- BiTree biTree;
- char tag;
- }BiTNodePost,*BiTreePost;
- void PostOrder2(BiTree T){
- stack<BiTreePost> stack;
- //p是遍历指针
- BiTree p = T;
- BiTreePost BT;
- //栈不空或者p不空时循环
- while(p != NULL || !stack.empty()){
- //遍历左子树
- while(p != NULL){
- BT = (BiTreePost)malloc(sizeof(BiTNodePost));
- BT->biTree = p;
- //访问过左子树
- BT->tag = 'L';
- stack.push(BT);
- p = p->lchild;
- }
- //左右子树访问完毕访问根节点
- while(!stack.empty() && (stack.top())->tag == 'R'){
- BT = stack.top();
- //退栈
- stack.pop();
- BT->biTree;
- printf("%c ",BT->biTree->data);
- }
- //遍历右子树
- if(!stack.empty()){
- BT = stack.top();
- //访问过右子树
- BT->tag = 'R';
- p = BT->biTree;
- p = p->rchild;
- }
- }//while
- }
- //层次遍历
- void LevelOrder(BiTree T){
- BiTree p = T;
- //队列
- queue<BiTree> queue;
- //根节点入队
- queue.push(p);
- //队列不空循环
- while(!queue.empty()){
- //对头元素出队
- p = queue.front();
- //访问p指向的结点
- printf("%c ",p->data);
- //退出队列
- queue.pop();
- //左子树不空,将左子树入队
- if(p->lchild != NULL){
- queue.push(p->lchild);
- }
- //右子树不空,将右子树入队
- if(p->rchild != NULL){
- queue.push(p->rchild);
- }
- }
- }
- int main()
- {
- BiTree T;
- CreateBiTree(T);
- printf("先序遍历:\n");
- PreOrder(T);
- printf("\n");
- printf("先序遍历(非递归):\n");
- PreOrder2(T);
- printf("\n");
- printf("中序遍历:\n");
- InOrder(T);
- printf("\n");
- printf("中序遍历(非递归):\n");
- InOrder2(T);
- printf("\n");
- printf("后序遍历:\n");
- PostOrder(T);
- printf("\n");
- printf("后序遍历(非递归):\n");
- PostOrder2(T);
- printf("\n");
- printf("层次遍历:\n");
- LevelOrder(T);
- printf("\n");
- return 0;
- }