zoukankan      html  css  js  c++  java

  • 二叉树遍历

    二叉树遍历 - 数据结构
     
     

    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 ";  
    111.     CreateBiTree( T);  
    112.     //PreOrderTraverse(T);  
    113.     //PreOrderTraverse_for(T);  
    114.     LevelOrderTraverse(T);  
    115. }  
  • 相关阅读:
    promise
    ES6中的类
    css基础知识
    ES6数据解构：set map 的介绍
    ES6对象的拓展
    ES6函数的拓展
    ES6数组的拓展
    ES6字符串和数值的扩展
    webpack的三种运行方式
    Mysql数据增删改操作以及复制表小技巧
  • 原文地址：https://www.cnblogs.com/timssd/p/5449996.html
Copyright © 2011-2022 走看看