码迷，mamicode.com
首页 > 其他好文 > 详细

二叉树遍历 - 数据结构

时间：2016-05-01 06:32:37      阅读：230      评论：0      收藏：0      [点我收藏+]

标签：

二叉树遍历 - 数据结构
 
 

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：
[cpp] view plain copy
 
 print?
  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. };  



二叉树遍历

[cpp] view plain copy
 
 print?
  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. }  

 

二叉树遍历 - 数据结构

标签：

原文地址：http://www.cnblogs.com/destim/p/5449996.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！