數據結構學習筆記：二叉樹

Data architecture studying== Binary Tree note:

//edit by author at 2008 09 25 22:53

All of them are simple excercise.Book and internet can support enough information for us.Maybe I am just Reinventing the wheel,but Most of them are worked out  independently by myself. I think It is the biggest achivement.

==========================================================

Abstract:

1.Create Binary Tree:Use recursion and Use Queue create it by level

2.Traverse Binary Tree:Use recursion and Unrecursion(Use queue and stack),and create a sorting binary tree.

3.Destroy Binary Tree.

 

The following is some funtion source code:

 

Create Binary Tree:

1. //=================================
2. //Create Binary Tree and destroy it recursively
3. pstBtNode btree_create_level(pstBtreeQue pQue)
4. {
5.     pstBtNode pbt=NULL , tpbt=NULL;
6.     char ch;
8.     pbt = new stBtNode;
10.     if((ch=level_data[cnt++])!='/0')
11.     {
12.         pbt->data = ch;
13.         pbt->mark=0;
14.         pbt->leftchild = NULL;
15.         pbt->rightchild = NULL;
16.         if(queue_push(pQue, pbt)==_FALSE)
17.         {
18.             return NULL; //here may make memory problem!
19.         }
20.     }
21.     else
22.     {
23.         cout<<"Create Tree Failed!"<<endl;
24.         return pbt;
25.     }
27.     while((queue_is_empty(pQue)==_FALSE)&&((level_data[cnt]!='/0')))
28.     //while(queue_is_empty(pBTQue)==_FALSE)
29.     {
30.         tpbt = queue_pop(pQue);
31.         if(tpbt == NULL) 
32.             continue;
33.         
34.         tpbt->leftchild = NULL;
35.         tpbt->rightchild =NULL;
36.         
37.         if((ch=level_data[cnt++])!='/')
38.         {
39.             tpbt->leftchild=new stBtNode;
40.             tpbt->leftchild->mark=0;
41.             tpbt->leftchild->data = ch;
42.             //tpbt->leftchild->leftchild = NULL;
43.             //tpbt->leftchild->rightchild = NULL;
44.             if(queue_push(pQue , tpbt->leftchild )==_FALSE)
45.             {
46.                 return NULL; //here may make memory problem!
47.             }
48.         }
50.         if((ch=level_data[cnt++])!='/')
51.         {
52.             tpbt->rightchild=new stBtNode;
53.             tpbt->rightchild->mark=0;
54.             tpbt->rightchild->data = ch;
55.             //tpbt->rightchild->leftchild = NULL;
56.             //tpbt->rightchild->rightchild = NULL;
57.             if(queue_push(pQue , tpbt->rightchild )==_FALSE)
58.             {
59.                 return NULL; //here may make memory problem!
60.             }
61.         }
62.         
63.     }
65.     //while((queue_is_empty(pBTQue)==_FALSE)&&((level_data[cnt]=='/0')))
66.     if(level_data[cnt]=='/0')
67.     {
68.         cout<<"Btree_Create_Level:Set Leaf Node as NULL Automatically!"<<endl;
69.         while(queue_is_empty(pQue)==_FALSE)
70.         {
71.             tpbt = queue_pop(pQue);
72.             tpbt->leftchild = NULL;
73.             tpbt->rightchild =NULL;
74.         }
75.     }
76.     return pbt;
77. }
81. #ifdef USE_RECURSION_RETURN_ROOT
83. pstBtNode btree_create(void)
84. {
85.     char ch;
86.     pstBtNode pbt;
87. #if 0
88.     cout<<"In put a node data:";
89.     cin>>t;
90. #else
91.     if(node_data[cnt]!='/0')
92.     {
93.         ch=node_data[cnt++];
94.         cout<<"btree_create:Add NULL leaf automaticly!"<<endl;
95.     }
96.     else
97.         ch='/';
98. #endif
100.     if(ch=='/')
101.     {
102.         pbt = NULL;
103.     }
104.     else
105.     {
106.         pbt=new stBtNode;
107.         pbt->data=ch;
108.         pbt->leftchild = btree_create();
109.         pbt->rightchild = btree_create();
110.     }
111.     return pbt;
112. }
114. #endif
116. //-------------------------------------------------
117. #ifdef USE_RECURSION_NO_RETURN
118. void btree_create(pstBtNode *ppbt)
119. {
120.     char ch;
121. #if 0
122.     cout<<"In put a node data:";
123.     cin>>ch;
124. #else
125.     if(node_data[cnt]!='/0')
126.     {
127.         ch=node_data[cnt++];
128.         cout<<"btree_create:Add NULL leaf automaticly!"<<endl;
129.     }
130.     else
131.         ch='/';
132. #endif
133.     
134.     if(ch=='/')
135.     {
136.         (*ppbt) = NULL;
137.         return ;
138.     }
139.     else
140.     {
141.         (*ppbt)=new stBtNode;
142.         (*ppbt)->data=ch;
143.         btree_create(&((*ppbt)->leftchild));
144.         btree_create(&((*ppbt)->rightchild));
145.     }
146. }
147. #endif

Traverse Binary Tree:

1. void pre_order_stack(pstBtNode pbt , pstBtreeStack pstack)
2. {
3.     pstBtNode tpbt= NULL;
4.     stack_push(pstack, pbt);
5.     while(stack_is_empty(pstack)==_FALSE)
6.     {
7.         tpbt = stack_pop(pstack);
8.         if(tpbt==NULL)
9.         {
10.             cout<<"-";//It's a NULL node
11.             continue;
12.         }
13.         else
14.             cout<<tpbt->data;
16.         //if(tpbt->rightchild!=NULL)
17.         {
18.             if(stack_push(pstack, tpbt->rightchild)==_FALSE)
19.             {
20.                 return ;
21.             }
22.         }
23.         //if(tpbt->leftchild!=NULL)
24.         {
25.             if(stack_push(pstack, tpbt->leftchild)==_FALSE)
26.             {
27.                 return ;
28.             }
29.         }
30.     }
31. }
33. void in_order_stack(pstBtNode pbt , pstBtreeStack pstack)
34. {
35.     pstBtNode tpbt = NULL;
36.     stack_push(pstack ,pbt->rightchild);
37.     stack_push(pstack ,pbt);
38.     stack_push(pstack ,pbt->leftchild);
39.     
40.     while(stack_is_empty(pstack)==_FALSE)
41.     {
42.         tpbt = stack_pop(pstack);
43.         
44.         if(tpbt == NULL)
45.         {
46.             cout<<"-";
47.             if(stack_is_empty(pstack)==_TRUE)
48.                 break;//pay attention here
49.             //else
50.             tpbt = stack_pop(pstack);
51.             cout<<tpbt->data;
52.             continue;
53.         }
55.         stack_push(pstack ,tpbt->rightchild);
56.         stack_push(pstack ,tpbt);
57.         stack_push(pstack ,tpbt->leftchild);        
58.     }
59. }
62. void post_order_stack(pstBtNode pbt, pstBtreeStack pstack)
63. {
64.     pstBtNode tpbt = NULL;
66.     stack_push(pstack ,pbt);
67.     
68.     while(stack_is_empty(pstack)==_FALSE)
69.     {
70.         tpbt = stack_pop(pstack);
71.         
72.         if(tpbt == NULL)
73.         {
74.             cout<<"-";;
75.             continue;
76.         }
77.         //else
78.         tpbt->mark++;
79.         if(tpbt->mark == 2)
80.         {
81.             cout<<tpbt->data;
82.             continue;
83.         }
84.         //else
85.         stack_push(pstack , tpbt);
86.         stack_push(pstack , tpbt->rightchild);
87.         stack_push(pstack , tpbt->leftchild);
88.     }
89. }

Binary Sorting Tree:

1. void btree_sort(char *ptab,pstBtNode *ppbt)
2. {
3.     pstBtNode *tpbt = NULL;
4.     int i=0;
6.     while(ptab[i]!='/0')
7.     {
8.         tpbt = ppbt;
10.         while((*tpbt)!=NULL)
11.         {
12.             if(ptab[i] >= (*tpbt)->data)
13.             {
14.                 tpbt = &((*tpbt)->rightchild);
15.             }
16.             else
17.             {
18.                 tpbt = &((*tpbt)->leftchild);
19.             }
20.         }
21.         
22.         (*tpbt) = new stBtNode;
23.         (*tpbt)->data = ptab[i];
24.         (*tpbt)->leftchild = NULL;
25.         (*tpbt)->rightchild = NULL;
26.         i++;    
27.     }
28. }

 

OK.

Enjoy it.

I hope it will help you in your studing.