二叉树遍历 - 数据结构

1. 二叉树遍历

1.1 遍历算法：

1．先序遍历的递归算法定义：

　　若二叉树非空，则依次执行如下操作：

　　(1) 访问根结点；

　　(2) 遍历左子树；

　　(3) 遍历右子树。

2．中序遍历的递归算法定义：

　　若二叉树非空，则依次执行如下操作：

　　(1)遍历左子树；

　　(2)访问根结点；

　　(3)遍历右子树。

3．后序遍历得递归算法定义：

　　若二叉树非空，则依次执行如下操作：

　　(1)遍历左子树；

　　(2)遍历右子树；

　　(3)访问根结点。

4．层次遍历：层序遍历（level traversal）二叉树的操作定义为：

     若二叉树为空，则退出，否则，

      按照树的结构，从根开始自上而下，自左而右访问每一个结点，从而实现对每一个结点的遍历 

例子：表达式a + b × (c- d)- e/ f

先序遍历：- + a * b - c d / e f

中序遍历：a + b *  c - d- e / f

后续遍历：a b c d - × +  e f /-

1.2遍历算法实现：

基本操作实现 stdafx.h：

1. // stdafx.h : include file for standard system include files,  
2. // or project specific include files that are used frequently, but  
3. // are changed infrequently  
4. //  
5.   
6. #pragma once  
7.   
8. #include <stdio.h>    
9. #include "stdlib.h"  
10. #include <iostream>  
11. using namespace std;  
12.   
13.   
14. //宏定义      
15. #define TRUE   1      
16. #define FALSE   0      
17. #define OK    1      
18. #define ERROR   0    
19. #define INFEASIBLE -1      
20. #define OVERFLOW -2    
21. #define STACKEMPTY -3   
22. #define QUEUEEMPTY  -3      
23.   
24. #define MAX 10 // MAXIMUM STACK CONTENT    
25. #define MAX_QUEUE 10 // MAXIMUM QUEUE CONTENT    
26.   
27. typedef int Status;      
28. typedef char ElemType;    
29.   
30.   
31. //而二叉树  
32. typedef struct BitNode{  
33.     ElemType data;  
34.     Status visited;  
35.     struct BitNode *lchild, *rchild; //左右孩子指针  
36. }BitNode, *BiTree;  
37.   
38. typedef BiTree StackElemType;    
39. typedef BiTree QueueElemType;    
40.   
41. class stack       
42. {       
43. private:       
44.     StackElemType arr[MAX];     
45.     int top;     
46. public:       
47.     stack()     
48.     {       
49.         inItStack();     
50.     }    
51.     /************************************************************************/    
52.     /* 初始化栈                                                                     */    
53.     /************************************************************************/    
54.     void inItStack()     
55.     {     
56.         top=-1;     
57.     }     
58.     /************************************************************************/    
59.     /* 入栈                                                                     */    
60.     /************************************************************************/    
61.     void push(StackElemType a)     
62.     {       
63.         top++;    
64.         if(top < MAX)  {       
65.             arr[top] = a;     
66.         }   else   {       
67.             cout<<"STACK FULL!!"<<top;       
68.         }       
69.     }       
70.     /************************************************************************/    
71.     /* 出栈                                                                     */    
72.     /************************************************************************/    
73.     StackElemType pop()    
74.     {        
75.         if(isEmpty())   {       
76.             cout<<"STACK IS EMPTY ";    
77.             return NULL;       
78.         } else {       
79.             StackElemType data=arr[top];     
80.             arr[top] = NULL;     
81.             top--;    
82.             return data;     
83.         }       
84.     }       
85.   
86.     /************************************************************************/    
87.     /* 出栈                                                                     */    
88.     /************************************************************************/    
89.     StackElemType getTop()    
90.     {        
91.         if(isEmpty())   {       
92.             cout<<"STACK IS EMPTY ";    
93.             return NULL;       
94.         } else {       
95.             return arr[top];     
96.         }      
97.     }       
98.     /************************************************************************/    
99.     /* 是否为空                                                                     */    
100.     /************************************************************************/    
101.     bool isEmpty()    
102.     {    
103.         if(top == -1) return true;    
104.         else return false;    
105.     }    
106. };       
107.   
108.   
109. class queue {  
110. private:  
111.     QueueElemType   elem[MAX_QUEUE] ;     ///假设当数组只剩下一个单元时认为队满              
112.     int front;      //队头指针    
113.     int rear;       //队尾指针      
114. public:       
115.     /************************************************************************/    
116.     /*   
117.       初始化  
118.       直接使用结构体指针变量，必须先分配内存地址，即地址的指针  
119.     */    
120.     /************************************************************************/    
121.     void InitQueue()     
122.     {    
123.         front = rear = -1;    
124.         
125.     }    
126.     /************************************************************************/    
127.     /*     入队                                                                
128.     */    
129.     /************************************************************************/    
130.          
131.     void EnQueue(QueueElemType e)    
132.     {    
133.         if((rear+1)% MAX_QUEUE == front) exit(OVERFLOW);    
134.         rear = (rear + 1)% MAX_QUEUE;    
135.         elem[rear] = e;     
136.     }    
137.     /************************************************************************/    
138.     /*     出队                                                                 
139.     */    
140.     /************************************************************************/    
141.     QueueElemType DeQueue()    
142.     {    
143.         if (QueueEmpty())  exit(QUEUEEMPTY);    
144.         front =  (front+1) % MAX_QUEUE;    
145.         return elem[front];    
146.     }    
147.     /************************************************************************/    
148.     /*    获取队头元素内容                                                              
149.     */    
150.     /************************************************************************/    
151.         
152.     QueueElemType GetFront()     
153.     {    
154.         if ( QueueEmpty() )  exit(QUEUEEMPTY);    
155.         return elem[ (front+1) % MAX_QUEUE ];    
156.     }    
157.     /************************************************************************/    
158.     /*    判断队列Q是否为空                                                               
159.     */    
160.     /************************************************************************/    
161.     int QueueEmpty()    
162.     {    
163.         if( front==rear) return TRUE;    
164.         else return FALSE;    
165.     }    
166.   
167. };  

二叉树遍历

1. / Test.cpp : Defines the entry point for the console application.    
2. //    
3. #include "stdafx.h"    
4.   
5.   
6.   
7. /************************************************************************/  
8. /* 算法： 
9. */  
10. /************************************************************************/  
11.   
12. Status CreateBiTree(BiTree &T);  
13. Status PreOrderTraverse(BiTree &T) ;  
14. Status visit(BiTree &T);  
15.   
16. /************************************************************************/  
17. /* 先序生成二叉树: 
18.    由于使用递归，要想退出函数，输入#的个数跟树的深度有关系 
19. */  
20. /************************************************************************/  
21. Status CreateBiTree(BiTree &T) {  
22.   
23.     char data ;  
24.     //scanf("%d", &data);  
25.     cin>> data;  
26.     if ( '#' == data )  T = NULL; //空格没法读入，所以使用#  
27.     else{  
28.         T = (BiTree) malloc(sizeof(BitNode));  
29.         if (!T) exit(OVERFLOW);  
30.         T->data =  data;  
31.         CreateBiTree(T->lchild);  
32.         CreateBiTree(T->rchild);  
33.     }  
34.     return OK;  
35. }  
36.   
37. /************************************************************************/  
38. /* 先序递归遍历二叉树: 
39. */  
40. /************************************************************************/  
41. Status PreOrderTraverse(BiTree &T) {  
42.     if(T) {  
43.         if(visit(T) )  
44.         if(PreOrderTraverse(T->lchild) )  
45.         if(PreOrderTraverse(T->lchild) ) return OK;  
46.         return ERROR;  
47.     }  
48.     return OK;  
49. }  
50. /************************************************************************/  
51. /* 先序序循环遍历二叉树: 
52. */  
53. /************************************************************************/  
54. Status PreOrderTraverse_for(BiTree &T) {  
55.     BiTree root;  
56.     stack s;  
57.     s.inItStack();  
58.     root = T;  
59.     while(root || !s.isEmpty()) {  
60.         if(root) {  
61.             visit(root);  
62.             s.push(root);  
63.             root = root->lchild;  
64.         } else {  
65.             root = s.getTop();  
66.             s.pop();  
67.             root = root->rchild;  
68.         }  
69.     }  
70.     return OK;  
71. }  
72.   
73. /************************************************************************/  
74. /*  层序遍历二叉树: 
75. */  
76. /************************************************************************/  
77.   
78. void LevelOrderTraverse(BiTree T)  
79. {  
80.     BiTree root,TNode;  
81.     queue q;  
82.     root = T;  
83.     if(!root) exit(ERROR);  
84.     q.EnQueue(root);  
85.     while (!q.QueueEmpty())  
86.     {  
87.         TNode = q.DeQueue();  
88.         visit(TNode);  
89.         if (TNode->lchild) q.EnQueue(TNode->lchild);      
90.         if (TNode->rchild) q.EnQueue(TNode->rchild);      
91.   
92.     }  
93. }  
94.   
95.   
96.   
97. Status visit(BiTree &T){  
98.     if(T->visited != TRUE) {  
99.         T->visited = TRUE;  
100.         cout<<T->data;  
101.         return TRUE;  
102.     }  
103.     return FALSE;  
104. }  
105.   
106.   
107. void main(){  
108.     int pos =1 ;  
109.     BiTree T;  
110.     cout<<"- + a * b - c d / e f\n";  
111.     CreateBiTree( T);  
112.     //PreOrderTraverse(T);  
113.     //PreOrderTraverse_for(T);  
114.     LevelOrderTraverse(T);  
115. }