二叉树周游

lastOne.h

  1 #ifndef __lastOne_H__
  2 #define __lastOne_H__
  3 #include <iostream>
  4 #include <stdio.h>   
  5 #include <stdlib.h>  
  6 typedef char TElemType;
  7 using namespace std;
  8 typedef struct BiTNode {
  9     TElemType data;
 10     struct BiTNode *lchild,*rchild;
 11 } BiTNode,*BiTree;
 12 struct Node;
 13 typedef struct Node * PNode;
 14 typedef int DataType;
 15 struct Node{
 16     BiTree bnode;
 17     PNode link;
 18 };
 19 struct LinkStack{
 20     PNode top;
 21 };
 22 typedef struct LinkStack * PLinkStack;
 23 PLinkStack createEmptyStack_link(void);
 24 int isEmptyStack_link(PLinkStack plstack);
 25 void push_link(PLinkStack plstack,BiTree x);
 26 BiTree pop_link(PLinkStack plstack);
 27 void CreateBiTree(BiTree &T);
 28 void recPostOrderTraverse(BiTree T);
 29 void recInOrderTraverse(BiTree T);
 30 void recPreOrderTraverse(BiTree T);
 31 void InOrderTraverse(BiTree T);
 32 void PreOrderTraverse(BiTree T);
 33 void PostOrderTraverse(BiTree T);
 34 void menu();
 35 void childrenLeaves(BiTree T);
 36 int Depth(BiTree T);
 37 int NodeCount(BiTree T);
 38 int sum=0;
 39 void childrenLeaves(BiTree T){
 40     if(T==NULL){
 41     }
 42     else{
 43         if(T->lchild!=NULL&&T->rchild!=NULL){
 44             sum++;
 45             childrenLeaves(T->lchild);
 46             childrenLeaves(T->rchild);
 47         }
 48     }
 49 }
 50 int Depth(BiTree T){
 51     int n,m;
 52     if(T==NULL)
 53         return 0;
 54     else {
 55         m=Depth(T->lchild);
 56         n=Depth(T->rchild);
 57         if(m>n)
 58             return(m+1);
 59         else
 60             return(n+1);
 61     }
 62 }
 63 int NodeCount(BiTree T){
 64     if(T==NULL)
 65         return 0;
 66     else
 67         return NodeCount(T->lchild)+NodeCount(T->rchild)+1;
 68 }
 69 void menu(){
 70     cout<<"1.recPre\n2.recIn\n3.recPost\n4.pre\n5.in\n6.post\n7.depth\n8.leaves\n9.childrenLeaves\n";
 71 }
 72 void recPreOrderTraverse(BiTree T){
 73     if(T){
 74         cout<<T->data;
 75         recPreOrderTraverse(T->lchild);
 76         recPreOrderTraverse(T->rchild);
 77     }
 78 }
 79 void recInOrderTraverse(BiTree T){
 80     if(T){
 81         recInOrderTraverse(T->lchild);
 82         cout<<T->data;
 83         recInOrderTraverse(T->rchild);
 84     }
 85 }
 86 void recPostOrderTraverse(BiTree T){
 87     if(T){
 88         recPostOrderTraverse(T->lchild);
 89         recPostOrderTraverse(T->rchild);
 90         cout<<T->data;
 91     }
 92 }
 93 void CreateBiTree(BiTree &T){  
 94     char ch;  
 95     scanf("%c",&ch);  
 96     if(ch=='#'){  
 97         T=NULL;  
 98         return;  
 99     }  
100     else{  
101         T=(BiTree)malloc(sizeof(BiTNode));  
102         if(!T)exit(1);  
103         T->data=ch;  
104         CreateBiTree(T->lchild);  
105         CreateBiTree(T->rchild);  
106     }  
107 }  
108 void InOrderTraverse(BiTree T){     
109     PLinkStack plstack=createEmptyStack_link();
110     if(!T){  
111         printf("empty tree£¡\n");  
112         return;  
113     }  
114     while(T||!isEmptyStack_link(plstack)){  
115         while(T){  
116             push_link(plstack,T); 
117             T=T->lchild;  
118         }
119         T=pop_link(plstack); 
120         printf("%c",T->data);  
121         T=T->rchild;  
122     }                                                                                                                                     
123 }  
124 void PreOrderTraverse(BiTree T){  
125     PLinkStack plstack=createEmptyStack_link();  
126     if(!T){  
127         printf("empty tree£¡\n");  
128         return;  
129     }  
130     while(T||!isEmptyStack_link(plstack)){  
131         while(T){  
132             push_link(plstack,T);  
133             printf("%c",T->data);  
134             T=T->lchild;  
135         }
136         T=pop_link(plstack);       
137         T=T->rchild;          
138     }                                                                                                                                     
139 }  
140 void PostOrderTraverse(BiTree T){
141     PLinkStack plstack=createEmptyStack_link();  
142     BiTree p=T;
143     BiTree t;
144     while(p!=NULL||!isEmptyStack_link(plstack)){
145         while(p!=NULL){
146             push_link(plstack,p); 
147             p=p->lchild?p->lchild:p->rchild;
148         }
149         p=pop_link(plstack);
150         printf("%c",p->data);
151         if(plstack->top!=NULL)t=plstack->top->bnode;
152         if(!isEmptyStack_link(plstack)&&t->lchild==p){
153             p=t->rchild;
154         }
155         else p=NULL;
156     }
157 }
158 PLinkStack createEmptyStack_link(void){
159     PLinkStack plstack;
160     plstack=(PLinkStack)malloc(sizeof(struct LinkStack));
161     if(plstack!=NULL){
162         plstack->top=NULL;
163         printf("succeed\n");
164     }
165     else
166         printf("out of space\n");
167     return plstack;
168 }
169 int isEmptyStack_link(PLinkStack plstack){
170     return (plstack->top==NULL);
171 }
172 void push_link(PLinkStack plstack,BiTree T){
173     PNode p;
174     p=(PNode)malloc(sizeof(struct Node));
175     if(p==NULL)printf("out of space\n");
176     else{
177         p->bnode=T; 
178         p->link=plstack->top;
179         plstack->top=p;
180     }
181 }
182 BiTree pop_link(PLinkStack plstack){
183     PNode p;
184     if(isEmptyStack_link(plstack)) printf("Empty stack pop\n");
185     else{
186         BiTree num;
187         num=plstack->top->bnode;
188         p=plstack->top;
189         plstack->top=plstack->top->link;
190         free(p);
191         return num;
192     }
193 }
194 #endif    

accept_linkTree_traverse

 1 //ab#c###
 2 //ab##cdf###e##
 3 #include"lastOne.h"
 4 int main() 
 5 {
 6     BiTree a;
 7     int height,num;
 8     int in;
 9     cout<<"please all the elements\n";
10     CreateBiTree(a);
11     num=NodeCount(a);
12     menu();
13     while(1){
14         scanf("%d",&in);
15         switch(in){
16         case 1:
17             cout<<"recPre:";
18             recPreOrderTraverse(a);
19             cout<<"\n";
20             break; 
21         case 2:
22             cout<<"recIn:";
23             recInOrderTraverse(a);
24             cout<<"\n";
25             break; 
26         case 3:
27             cout<<"recPost:";
28             recPostOrderTraverse(a);
29             cout<<"\n";
30             break; 
31         case 4:
32             cout<<"pre:";
33             PreOrderTraverse(a);
34             cout<<"\n";
35             break; 
36         case 5:
37             cout<<"in:";
38             InOrderTraverse(a);
39             cout<<"\n";
40             break;
41         case 6:
42             cout<<"post:";
43             PostOrderTraverse(a);
44             cout<<"\n";
45             break;    
46         case 7:
47             cout<<"depth:";
48             height=Depth(a);
49             cout<<height<<endl;
50             cout<<"\n";
51             break;
52         case 8:
53             cout<<"leaves:";
54             num=NodeCount(a);
55             cout<<num;
56             cout<<"\n";
57             break;
58         case 9:
59             cout<<"childrenLeaves:";
60             childrenLeaves(a);
61             cout<<sum+1;
62             cout<<"\n";
63             break;
64         } 
65     }
66     return 0;
67 }

Guess you like

Origin http://43.154.161.224:23101/article/api/json?id=325374869&siteId=291194637