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 #if !defined(AFX_STDAFX_H__02F8C78B_9F6E_45FF_BFCE_7F99B5AC9359__INCLUDED_)
 7 #define AFX_STDAFX_H__02F8C78B_9F6E_45FF_BFCE_7F99B5AC9359__INCLUDED_
 8 
 9 #if _MSC_VER > 1000
10 #pragma once
11 #endif // _MSC_VER > 1000
12 
13 #include <stdc++.h>
14 #include <windows.h>
15 
16 using namespace std;
17 
18 typedef char elementType;
19 typedef int elementType1;
20 
21 typedef struct node
22 {
23     elementType data;//刚开始应该写成将data写成string或者直接将整个函数写成模板的，写完了最后测试时
24                     //才发现现在的写法有诸多不便；但修改的话就又要重构一遍，懒得整了。
25     struct node *leftChild, *rightChild;
26 }bitNode, *binTree;
27 
28 typedef struct charNode
29 {
30     //elementType data;
31     bitNode *data;//the type must be bitNode*
32     struct charNode *link;
33 }CLNode, *CPNode;
34 
35 
36 //typedef struct charNode
37 //{
38     //elementType data;
39     //struct charNode *leftChild, *rightChild;
40 //}charBitNode, *charBinTree;
41 
42 // TODO: reference additional headers your program requires here
43 
44 //{{AFX_INSERT_LOCATION}}
45 // Microsoft Visual C++ will insert additional declarations immediately before the previous line.
46 
47 #endif // !defined(AFX_STDAFX_H__02F8C78B_9F6E_45FF_BFCE_7F99B5AC9359__INCLUDED_)

 1 // charLinkedQueue.h: interface for the charLinkedQueue class.
 2 //
 3 //////////////////////////////////////////////////////////////////////
 4 
 5 #if !defined(AFX_CHARLINKEDQUEUE_H__13C2F642_81C0_4489_9CF2_3D58D8B48EA9__INCLUDED_)
 6 #define AFX_CHARLINKEDQUEUE_H__13C2F642_81C0_4489_9CF2_3D58D8B48EA9__INCLUDED_
 7 
 8 #if _MSC_VER > 1000
 9 #pragma once
10 #endif // _MSC_VER > 1000
11 
12 //刚开始尝试写英文注释的，后面知难而退了；不过原来的英文注释我保留了
13 
14 class charLinkedQueue  
15 {
16 public:
17     charLinkedQueue();
18     virtual ~charLinkedQueue();
19     bool emptyCharLinkedQueue();
20     //bool fullSeqCircleQueue();
21     bool enQueue( bitNode *value );//the type must be bitNode*
22     bool deQueue( /*bitNode *value*/ );
23     bool getFront( bitNode *&value );//the type must be bitNode*&
24     int length();
25     friend ostream &operator<<( ostream &os, charLinkedQueue &clq )
26     {
27         /*
28         if( ( scq._front - 1 ) % maxn == scq._rear )
29             return os;
30         int column  = 0;
31         for( int i = scq._front; i % maxn != scq._rear; i = ( i + 1 ) % maxn )
32         {
33             os << setw(3) << setiosflags(ios::left) << scq.data[i] << " ";
34             column ++;
35             if( column % 10 == 0 )
36                 os << endl;
37         }
38         os << endl;
39         */
40         if( clq._front == NULL )
41             return os;
42         CLNode *tmp = clq._front;
43         int column = 0;
44         while( tmp != clq._rear->link )
45         {
46             os << setw(4) << setiosflags(ios::left) << tmp->data << " ";
47             column ++;
48             tmp = tmp->link;
49             if( column % 10 == 0 )
50                 os << endl;
51         }
52         os << endl;
53     }
54     //为了能顺利使用原来的这个代码块来进行二叉树的层次便利，我主要的精力都放在_front、_rear类型、
55     //deQueue()、enQueue()、charNode的类型确定上，经过无数次尝试，总算结果对了----
56     //如果有Git，看了这个代码的每个版本你就会知道我付出了多少心血。。。。
57 private:
58     CLNode *_front;//the type must be CLNode*
59     CLNode *_rear;//the type must be CLNode*
60 };
61 
62 #endif // !defined(AFX_CHARLINKEDQUEUE_H__13C2F642_81C0_4489_9CF2_3D58D8B48EA9__INCLUDED_)

 1 // _Binary_Tree.h: interface for the _Binary_Tree class.
 2 //
 3 //////////////////////////////////////////////////////////////////////
 4 
 5 #if !defined(AFX__BINARY_TREE_H__9381B15F_E185_4489_9415_360A22C0A4E2__INCLUDED_)
 6 #define AFX__BINARY_TREE_H__9381B15F_E185_4489_9415_360A22C0A4E2__INCLUDED_
 7 
 8 #if _MSC_VER > 1000
 9 #pragma once
10 #endif // _MSC_VER > 1000
11 
12 #include "charLinkedQueue.h"
13 
14 //刚开始尝试写英文注释的，后面知难而退了；不过原来的英文注释我保留了
15 
16 class _Binary_Tree  
17 {
18 public:
19     _Binary_Tree();//不带参数的构造函数
20     _Binary_Tree( elementType *Arr );//带参数的构造函数
21     void build( elementType *Arr );//从数组建立二叉树，相当于初始化；不带参数的构造函数无法适用于这里
22     void createNode( binTree BT, elementType *Arr, int number );//根据从数组读到的数据先序递归建树
23     virtual ~_Binary_Tree();//析构函数
24     bool createBinaryTree( binTree &BT, elementType stringLine[100][3], int length, int &row );//根据文本数据
25                                                             //先序构造二叉树
26     bool readFileToArray( elementType stringLine[100][3], int &length );//将文本数据读入二维数组中
27     bool emptyBinaryTree();//二叉树判空，仅适用于带参数构造函数建立的二叉树
28     bool _exit( binTree BT, elementType value );//判断节点数据是否在二叉树中
29     binTree getNodePoint();//返回根节点地址
30     binTree getNodePoint( binTree BT, elementType value );//返回value在二叉树中的地址
31     binTree getParent( binTree BT, elementType value );//返回value的父母
32     void PreOrderTraverse(binTree BT);//前序遍历
33     void InOrderTraverse(binTree BT);//中序遍历
34     void PostOrderTraverse(binTree BT);//后序遍历
35     void levelOrderTraverse(binTree BT);//层次遍历
36     void destroy( binTree BT );//销毁二叉树
37     void level( binTree BT, int number );//求二叉树中各个节点的层次
38     int height( binTree BT );//求二叉树高度
39     int numberOfBTreeNode( binTree BT );//返回二叉树节点总数
40     int numberOfBTreeLeafNode( binTree BT, int &number );//返回二叉树叶节点个数
41     void numberOfNodeDegreeTwo( binTree BT, int &number );//求二叉树中度为2的节点个数
42     //void family( binTree BT, elementType1 number );
43     void getParent( binTree BT, elementType value, bool &flag );//求value的父节点
44     void getSibling( binTree BT, elementType value, bool &flag );//when call the function, the parameter flag
45                                                                 //must be assigned for false
46                                                                 //求value的兄弟节点，法1；有一个bug
47     void getSibling( binTree BT, elementType value );//求value的兄弟节点，法2
48     void getChild( binTree BT, elementType value, bool &flag );//求value孩子节点
49     int levelJudge( binTree BT, elementType value, int &number, int level );//返回value节点的层次
50     void exchangeLeftAndRightSibling( binTree BT );//交换左右子树
51     void copyBTree( binTree BT1, binTree BT );//复制二叉树
52     charLinkedQueue clq;//包含
53     void allLeafToRootPath( binTree BT, elementType *path, int &pathLength );//求所有叶节点到根节点路径
54     void binaryTreeLongestPath( binTree BT, elementType *path, int &pathLength, 
55         elementType *longestPath, int &longestLength );//求叶节点到根节点的最长路径
56     binTree nearestAncestor( binTree BT, bitNode *BNode1, bitNode *BNode2 );//求两个节点的最近祖先
57                                                                             //本来打算用elementType数据
58                                                                             //作为参数的，后面发现行不通
59                                                                             //可能是我太菜了吧
60 private:
61     bitNode *BTree;
62 
63 };
64 
65 #endif // !defined(AFX__BINARY_TREE_H__9381B15F_E185_4489_9415_360A22C0A4E2__INCLUDED_)

 1 // charLinkedQueue.cpp: implementation of the charLinkedQueue class.
 2 //
 3 //////////////////////////////////////////////////////////////////////
 4 
 5 #include "stdafx.h"
 6 #include "charLinkedQueue.h"
 7 
 8 //////////////////////////////////////////////////////////////////////
 9 // Construction/Destruction
10 //////////////////////////////////////////////////////////////////////
11 
12 charLinkedQueue::charLinkedQueue()
13 {
14     _front = _rear = NULL;
15 }
16 
17 charLinkedQueue::~charLinkedQueue()
18 {
19     CLNode *tmp = NULL;
20     while( _front != _rear )
21     {
22         tmp = _front;
23         _front = _front->link;
24         delete tmp;
25     }
26     cout << "The charLinkedQueue destruction has been called!" << endl;
27 }
28 
29 bool charLinkedQueue::emptyCharLinkedQueue()
30 {
31     return _front == NULL;
32 }
33 
34 bool charLinkedQueue::enQueue( bitNode *value )
35 {
36     CLNode *newNode = new CLNode;
37     if( !newNode )
38     {
39         cerr << "Space allocating falied!Error in charLinkedQueue::enQueue()!" << endl;
40         return false;
41     }
42     newNode->data = value;
43     newNode->link = NULL;
44     if( emptyCharLinkedQueue() )
45     {
46         _front = _rear = newNode;
47     }
48     else
49     {
50         _rear->link = newNode;
51         _rear = newNode;
52     }
53     return true;
54 }
55 
56 bool charLinkedQueue::deQueue( /*elementType &value*/ )
57 {
58     if( emptyCharLinkedQueue() )
59     {
60         cerr << "Node deleting falied!Error in charLinkedQueue::deQueue()!" << endl;
61         return false;
62     }
63     CLNode *tmp = _front;
64     //value = _front->data;
65     _front = _front->link;
66     delete tmp;
67     if( _front == NULL )
68         _rear = NULL;
69     return true;
70 }
71 
72 bool charLinkedQueue::getFront( bitNode *&value )
73 {
74     if( emptyCharLinkedQueue() )
75     {
76         cerr << "Queue is empty!\nNode-data acquiring falied!Error in charLinkedQueue::deQueue()!" << endl;
77         return false;
78     }
79     value = _front->data;//原来我是注释掉的，导致输出一直是A；
80     return true;
81 }
82 
83 int charLinkedQueue::length()
84 {
85     if( emptyCharLinkedQueue() )
86     {
87         cerr << "Queue is empty!" << endl;
88         return -1;
89     }
90     CLNode *tmp = _front;
91     int _size = 0;
92     while( tmp != NULL )
93     {
94         tmp = tmp->link;
95         _size ++;
96     }
97     return _size;
98 }

  1 // _Binary_Tree.cpp: implementation of the _Binary_Tree class.
  2 //
  3 //////////////////////////////////////////////////////////////////////
  4 
  5 #include "stdafx.h"
  6 #include "_Binary_Tree.h"
  7 #include "charLinkedQueue.h"
  8 
  9 //////////////////////////////////////////////////////////////////////
 10 // Construction/Destruction
 11 //////////////////////////////////////////////////////////////////////
 12 
 13 
 14 _Binary_Tree::_Binary_Tree()       //新建一个结点
 15 {
 16     //BTree = NULL;
 17     BTree = new bitNode;
 18     BTree->leftChild = BTree->rightChild = NULL;
 19 }
 20 
 21 _Binary_Tree::~_Binary_Tree()
 22 {
 23     destroy(BTree);//析构函数不能带参数，只能这么处理了
 24 }
 25 
 26 _Binary_Tree::_Binary_Tree( elementType *Arr )
 27 {
 28     BTree = NULL;
 29     build(Arr);
 30 }
 31 
 32 void _Binary_Tree::build( elementType *Arr )
 33 {
 34     if(BTree)
 35       destroy(BTree);
 36     if( Arr[0] == ‘^‘ )
 37     {
 38         BTree = NULL;
 39         return;
 40     }
 41     BTree = new bitNode;
 42     BTree->leftChild = NULL;
 43     BTree->rightChild = NULL;
 44     BTree->data = Arr[0];
 45     createNode( BTree, Arr, 0 );
 46 }
 47 
 48 void _Binary_Tree::createNode( binTree BT, elementType *Arr, int number )
 49 {
 50     bitNode *tmp = new bitNode;
 51     if( Arr[ number * 2 + 1 ] != ‘^‘ )
 52     {
 53         BT->leftChild =new bitNode ;
 54         tmp = BT->leftChild;
 55         tmp->data = Arr[ number * 2 + 1 ];
 56         tmp->leftChild = NULL;
 57         tmp->rightChild = NULL;
 58         createNode( tmp, Arr, number * 2 + 1 );
 59     }
 60     if( Arr[ number * 2 + 2 ] != ‘^‘ )
 61     {
 62         BT->rightChild =new bitNode ;
 63         tmp = BT->rightChild;
 64         tmp->data = Arr[ number * 2 + 2 ];
 65         tmp->leftChild = NULL;
 66         tmp->rightChild = NULL;
 67         createNode( tmp, Arr, number * 2 + 2 );
 68     }
 69 }
 70 
 71 bool _Binary_Tree::createBinaryTree( binTree &BT, elementType stringLine[100][3], int length, int &row )
 72 {     
 73     if (row >= length || length == 0 )      //strlen存数据的二维数组，nRow结点所在的位数，nlen结点的个数
 74         return false;
 75     if ( row == 0 )
 76         BT = BTree;
 77     else
 78         BT = new bitNode;//new下面是公用的，用if的目的是改变private里BTree里的值
 79     BT->data = stringLine[row][0];
 80     BT->leftChild = NULL;
 81     BT->rightChild = NULL;
 82     
 83     int nextRow = row;
 84     if ( stringLine[nextRow][1] == ‘1‘ )
 85     {
 86         ++ row;
 87         createBinaryTree( BT->leftChild, stringLine, length, row );
 88     }
 89     if ( stringLine[nextRow][2] == ‘1‘ )
 90     {
 91         ++row;
 92         createBinaryTree( BT->rightChild, stringLine, length, row );
 93     }
 94     return true;
 95 }
 96 
 97 bool _Binary_Tree::readFileToArray( elementType stringLine[100][3], int &length )
 98 {
 99     FILE *fp;
100     char str[100];
101                 
102     cout << "Please input the file name(belike includes the file path):" << endl;
103     char name[50];// = "bt10.btr";
104     cin >> name;
105     fp = fopen( name, "r" );
106     if (!fp)
107     {
108         cout << "Error!" << endl;
109         return false;
110     }
111     if (fgets(str, 1000, fp) != NULL)
112     {
113         if (strcmp(str, "BinaryTree\n") != 0)
114         {
115             cout << "Error!" << endl;
116             fclose(fp);
117             return false;
118         }
119     }
120     length = 0;
121     while (fscanf(fp, "%c %c %c\n", &stringLine[length][0], &stringLine[length][1], &stringLine[length][2]) != EOF)
122     {
123         length ++;
124     }
125     fclose(fp);
126     return true;
127 }
128 
129 
130 bool _Binary_Tree::emptyBinaryTree()
131 {
132     //if(BTree)
133         //return BTree->leftChild == NULL && BTree->rightChild == NULL;
134     //else
135     return BTree == NULL;
136 }
137 
138 bool _Binary_Tree::_exit( binTree BT, elementType value )
139 {
140     if(!BT)
141         return false;
142         //return NULL;
143     if( BT->data == value )
144         return true;
145         //return BT;
146     //bitNode *index = _exit( BT->leftChild, value );
147     bool flag = _exit( BT->leftChild, value );
148     //if(!index)
149     if(!flag)
150     //_exit( BT->leftChild, value );
151         _exit( BT->rightChild, value );
152 }
153 
154 binTree _Binary_Tree::getNodePoint()
155 {
156     //if( emptyBinaryTree() )
157     //{
158         //throw "Empty binary tree!Error in binTree _Binary_Tree::getNodePoint()!\n";
159         //return NULL;
160     //}
161     return (*this).BTree;
162 }
163 
164 binTree _Binary_Tree::getNodePoint( binTree BT, elementType value )
165 {
166     /*
167     if(!BT)
168     {
169         return NULL;
170     }
171     else
172     {
173         if( BT->data == value )
174             return BT;
175         else
176         {
177             bitNode *tmp;
178             if( tmp = getNodePoint( BT->leftChild, value ) )
179                 return tmp;
180             if( tmp = getNodePoint( BT->rightChild, value ) )
181                 return tmp;
182             return NULL;
183         }
184     }
185     */
186     if(!BT)
187     {
188         return NULL;
189     }
190     else
191     {
192         if( BT->data == value )
193         {
194             return  BT;
195         }
196         //getNodePoint( BT->leftChild, value );
197         //getNodePoint( BT->rightChild, value );
198         
199         bitNode *tmp = getNodePoint( BT->leftChild, value );
200         if(!tmp)
201         {
202             getNodePoint( BT->rightChild, value );
203         }
204         //follow statement can‘t be added to the code
205         //return tmp;
206     }
207 }
208 
209 void _Binary_Tree::PreOrderTraverse(binTree BT)   
210 {
211     //if( emptyBinaryTree() )
212 //    {
213         //throw "Empty binary tree!Error in void _Binary_Tree::PreOrderTraverse(binTree BT) !\n";
214         //return;
215     //}
216     if (BT)  
217     {
218              cout << BT->data << " ";
219             PreOrderTraverse(BT->leftChild);
220             PreOrderTraverse(BT->rightChild);
221     }
222 }
223 
224 void _Binary_Tree::InOrderTraverse(binTree BT)   
225 {
226     if (BT)   
227     {
228             InOrderTraverse(BT->leftChild);
229              cout << BT->data << " ";
230             InOrderTraverse(BT->rightChild);
231     }
232     //return 0;
233 }
234 
235 void _Binary_Tree::PostOrderTraverse( binTree BT )
236 {
237     if (BT)  
238     {
239             PostOrderTraverse(BT->leftChild);
240             PostOrderTraverse(BT->rightChild);
241             cout << BT->data << " ";
242     }
243 }
244 
245 void _Binary_Tree::destroy( binTree BT )
246 {
247     if(BT)
248     {
249         destroy( BT->leftChild );
250         destroy( BT->rightChild );
251         delete BT;
252         BT = NULL;
253     }
254 }
255 
256 void _Binary_Tree::level( binTree BT, int number )
257 {
258 
259     if(BT)
260     {
261         level( BT->leftChild, number + 1 );
262         ///number +=3;
263         //cout << number << endl;
264         cout << BT->data << " level: " << number << endl;
265         
266         level( BT->rightChild, number + 1 );
267         //number -=2;
268     }
269     //number --;
270 }
271 
272 int _Binary_Tree::height( binTree BT )
273 {
274     if(!BT)
275     {
276         return 0;
277     }
278     else
279     {
280         int i = height( BT->leftChild );
281         int j = height( BT->rightChild );
282         return i < j ? j + 1 : i + 1;
283 
284     }
285 }
286 
287 int _Binary_Tree::numberOfBTreeNode( binTree BT )
288 {
289     if(!BT)
290         return 0;
291     else
292     {
293         return numberOfBTreeNode( BT->leftChild ) + numberOfBTreeNode( BT->rightChild ) + 1;
294     }
295 }
296 
297 int _Binary_Tree::numberOfBTreeLeafNode( binTree BT, int &number )
298 {
299     if(!BT)
300     {
301         return 0;
302     }
303     else
304     {
305         if( !BT->leftChild && !BT->rightChild )
306             //number += 1;
307             number ++;
308             //return 1;
309         else
310         {
311             numberOfBTreeLeafNode( BT->leftChild, number );
312             numberOfBTreeLeafNode( BT->rightChild, number );
313         }
314         return number;    
315     }
316 }
317 
318 void _Binary_Tree::numberOfNodeDegreeTwo( binTree BT, int &number )
319 {
320     if(!BT)
321     {
322         return;
323     }
324     else
325     {
326         if( BT->leftChild && BT->rightChild )
327             //number += 1;
328             number += 1;
329             //return 1;
330         //else
331         //{
332             numberOfNodeDegreeTwo( BT->leftChild, number );
333             numberOfNodeDegreeTwo( BT->rightChild, number );
334             //return numberOfNodeDegreeTwo( BT->leftChild, number ) + numberOfNodeDegreeTwo( BT->rightChild, number );
335         //}
336         //return number;    
337     }
338 }
339 
340 /*
341 void _Binary_Tree::family( binTree BT, elementType1 number )
342 {
343     if(!BT)
344     {
345         return;
346     }
347     if( BT->leftChild->data == number || BT->rightChild->data == number )
348     {
349         cout << "parent ---- " << BT->data << endl;
350         if( BT->leftChild->data == number && BT->rightChild )
351         {
352             cout << "rights sibling ---- " << BT->rightChild->data << endl;
353         }
354         if( BT->leftChild && BT->rightChild->data == number )
355         {
356             cout << "left sibling ---- " << BT->leftChild->data << endl;
357         }
358     }
359     if( BT->data == number && ( BT->leftChild || BT->rightChild ) )
360     {
361         cout << ( BT->leftChild ? "left child ---- " : true ) << endl;
362         cout << ( BT->rightChild ? "right child ---- " : true ) << endl;
363     }
364     family( BT->leftChild, number );
365     family( BT->rightChild, number );
366     //if( BT->data == number && BT-)
367     //if( BT->leftChild->data == number &&)
368 }
369 */
370 
371 //bool _Binary_Tree::getParent( binTree BT, elementType number, bool flag )
372 void _Binary_Tree::getParent( binTree BT, elementType value, bool &flag )
373 {
374     if(!BT)
375     {
376         //return false;
377         return;
378     }
379     if( ( BT->leftChild && BT->leftChild->data == value ) || ( BT->rightChild ) && ( BT->rightChild->data == value ) )
380     {
381         flag = true;
382         cout << value << " Parent ---- " << BT->data << endl;
383         return;
384         //return true;
385     }
386     /*
387     if( BT && BT->rightChild->data == number )
388     {
389         cout << "parent ---- " << BT->data << endl;
390         return true;
391     }
392     */
393     getParent( BT->leftChild, value, flag );
394     getParent( BT->rightChild, value, flag );
395 }    
396 
397 binTree _Binary_Tree::getParent( binTree BT, elementType value )
398 {
399     
400     if( !_exit( BT, value ) )
401     {
402         cerr << value << " is not in the binary tree!" << endl;
403         cerr << "Error in binTree _Binary_Tree::getParent( binTree BT, elementType value )!" << endl;
404         return NULL;
405     }
406     
407     if(!BT)
408     {
409         return NULL;
410     }
411     if( BT->data == value )
412     {
413         return BT;
414     }
415     if( ( BT->leftChild && BT->leftChild->data == value ) || ( BT->rightChild && BT->rightChild->data == value ) )//|| BT->rightChild->data == value )
416     {
417         return BT;
418     }
419     bitNode *tmp = getParent( BT->leftChild, value );
420     if(!tmp)
421     {
422         getParent( BT->rightChild, value );
423     }
424 }
425 
426 void _Binary_Tree::getSibling( binTree BT, elementType value, bool &flag )
427 {
428     if(!BT)
429     {
430         cout << value << " No LeftSibling!" << endl << value << " No RightSibling!" << endl;
431         return;
432     }
433     if( !flag &&  !BT->leftChild )//|| !BT->rightChild )//write as "if(!BT)" would result error
434     {
435         
436         if( BT->rightChild )
437         {
438             getSibling( BT->rightChild, value, flag );
439             //return;
440         }
441         else
442         {
443             //cout << value << " No LeftSibling!" << endl;
444             return;
445         }
446         return;//why would deleting the statement cause error!
447     }
448 
449     if( !flag && !BT->rightChild )
450     {
451 
452         if( BT->leftChild )
453         {
454             getSibling( BT->leftChild, value, flag );
455             
456         }
457         else
458         {
459             //cout << value << "No LeftSibling!" << endl;
460             //cout << value << " No RightSibling!" << endl;
461             return;
462             
463         }    
464         return;//why would deleting the statement cause error!
465     }
466     if( BT->rightChild->data == value )
467     {
468         if( BT->leftChild )
469         {
470             flag = true;
471             cout << value << " LeftSibling ---- " << BT->leftChild->data << endl;
472             return;
473         }
474         else if( !BT->leftChild )
475         {
476             cout << value << " No LeftSibling!" << endl;
477             return;
478         }
479         
480     }
481     if( BT->leftChild->data == value )
482     {
483         if( BT->rightChild )
484         {
485             flag = true;
486             cout << value << " RightSibling ---- " << BT->rightChild->data << endl;
487             return;
488         }
489         else if( !BT->rightChild )
490         {
491             cout << value << " No RightSibling!" << endl;
492             return;
493         }
494     }
495     getSibling( BT->leftChild, value, flag );
496     if( !flag && BT->rightChild )
497         getSibling( BT->rightChild, value, flag );
498 }
499 
500 void _Binary_Tree::getSibling( binTree BT, elementType value )
501 {
502     bitNode *parent = getParent( BT, value );
503     
504     if( BT->data == value )
505     {
506         cout << value << " is the root node,neither left sibling also useless right sibling!" << endl;
507         return;
508     }
509     if( !_exit( BT, value ) )
510     {
511         cout << value << " is not in the binary-tree!" << endl;
512         cerr << "Error in void _Binary_Tree::getSibling( binTree BT, elementType value )!" << endl;
513         return;
514     }
515     if( parent->leftChild && parent->leftChild->data == value )
516     {
517         if( parent->rightChild )
518         {
519             cout << value << " RightSibling ---- " << parent->rightChild->data << endl;
520             return;
521         }
522         else
523         {
524             cout << value << " No RightSibling!" << endl;
525             return;
526         }
527     }
528     if( parent->rightChild && parent->rightChild->data == value )
529     {
530         if( parent->leftChild )
531         {
532             cout << value << " LeftSibling ---- " << parent->leftChild->data << endl;
533             return;
534         }
535         else
536         {
537             cout << value << " No LeftSibling!" << endl;
538             return;
539         }
540     }
541 }
542 
543 void _Binary_Tree::getChild( binTree BT, elementType value, bool &flag )//It costed me several minutes to   
544 {                                                                        //write and almost one hour to 
545     /*                                                                    //perfect the function
546     if( BT->leftChild )
547     {
548         getChild( BT->leftChild, value, flag );
549     }
550     if( BT->rightChild )
551     {
552         getChild( BT->rightChild, value, flag );
553     }
554     */
555     
556     /*
557     if( !BT->leftChild )//|| !BT->rightChild )
558     {
559         if(flag)
560         {    
561             cout << "No LeftChild! " << endl;
562             flag = true;
563             return;
564         }
565         else
566         {
567             cout << "No LeftChild! " << endl;
568             flag = false;
569         }
570         //return;
571     }
572     if( !BT->rightChild )
573     {
574         if(flag)
575         {
576             cout << "No RightChild! " << endl;
577             flag = true;
578             return;
579         }
580         else
581         {
582             cout << "No RightChild! " << endl;
583             flag = false;
584         }
585     }
586     */
587     //if(!BT)
588 //    {
589     //    return;
590 //    }
591     if( !_exit( BT, value ) )
592     {
593         cerr << value << " is not in the binary tree!\nError in void _Binary_Tree::getChild( binTree BT, elementType value, bool &flag )" << endl;
594         return;
595     }
596     if( BT->data == value )//at first I neglected this detail that resulted wrong judgement at root-node 
597     {
598         if( BT->leftChild )
599         {
600             flag = true;
601             cout << value << " LeftChild ---- " << BT->leftChild->data << endl;
602             
603         }
604         else
605         {
606             cout << "No LeftChild!" << endl;
607 
608         }
609         if( BT->rightChild )
610         {
611             flag = true;
612             cout << value << " RightChild ---- " << BT->rightChild->data << endl;
613             return;
614         }
615         else
616         {
617             cout << "No RightChild! " << endl;
618             return;
619         }
620     }
621     if( !BT->leftChild )
622     {
623         if( BT->rightChild )
624         {
625             getChild( BT->rightChild, value, flag );
626         }
627         return;
628         /*
629         if(flag)
630         {
631             return;
632         }
633         else
634         {
635             flag = false;
636             return;
637         }*/
638     }
639     if( !BT->rightChild )
640     {
641         if( BT->leftChild )
642         {
643             getChild( BT->leftChild, value, flag );
644         }
645         return;
646         //if(flag)
647         //{
648         //    flag = false;    
649         //}
650         /*
651         if(flag)
652         {
653             return;
654         }
655         else
656         {
657             flag = false;
658             return;
659         }*/
660     }
661     /*
662     if( BT->rightChild->data == value )
663     {
664         if( BT->rightChild->leftChild )
665         {
666             flag = true;
667             cout << value << " LeftChild ---- " << BT->rightChild->leftChild->data << endl;
668             //return;
669         }
670         else
671         {
672             cout << "No LeftChild!" << endl;
673         }
674         if( BT->rightChild->rightChild )
675         {
676             flag = true;
677             cout << value << " RightChild ---- " << BT->rightChild->rightChild->data << endl;
678             return;
679         }
680         else
681         {
682             cout << "No RightChild! " << endl;
683             return;
684         }
685         //else
686         //{
687             //flag = false;
688         //    return;
689         //}
690     }
691     if( BT->leftChild->data == value )
692     {
693         if( BT->leftChild->leftChild )
694         {
695             flag = true;
696             cout << value << " LeftChild ---- " << BT->leftChild->leftChild->data << endl;
697             //return;
698         }
699         else
700         {
701             cout << "No LeftChild!" << endl;
702         }
703         if( BT->leftChild->rightChild )
704         {
705             flag = true;
706             cout << value << " RightChild ---- " << BT->leftChild->rightChild->data << endl;
707             return;
708         }
709         else
710         {
711             cout << "No RightChild! " << endl;
712             return;
713         }
714         //else
715         //{
716             //flag = false;
717         //    return;
718         //}
719     }
720     */
721     getChild( BT->leftChild, value, flag );
722     getChild( BT->rightChild, value, flag );
723 }
724 
725 int _Binary_Tree::levelJudge( binTree BT, elementType value, int &number, int level )
726 {
727     bitNode *position = getNodePoint( getNodePoint(), value );
728     if(!position)
729     {
730         cout << "The value you typed is not in the binary tree!" << endl;
731         //return -1;
732         number = -1;
733         return number;
734     }
735     /*
736     int level;
737     if ( BT == NULL )
738         return 0;
739     else if ( BT->data == value )
740         return number;
741     else
742     {    
743         number ++;
744         level = levelJudge( BT->leftChild, value, number );    
745         if ( level != 0 ) 
746             return number;
747         else    
748         {
749             //number ++;
750             return levelJudge( BT->rightChild, value, number );
751         }
752     }
753     */
754     if(BT)
755     {
756         if( BT->data == value )
757         {
758             //number ++;
759             number = level;
760         }
761         //number ++;
762         levelJudge( BT->leftChild, value, number, level + 1 );
763         //number ++;
764         levelJudge( BT->rightChild, value, number, level + 1);
765     }
766 }
767 
768 void _Binary_Tree::exchangeLeftAndRightSibling( binTree BT )
769 {
770     if( BT && BT->leftChild && BT->rightChild )
771     {
772         bitNode *tmp = BT->leftChild;
773         BT->leftChild = BT->rightChild;
774         BT->rightChild = tmp;
775         exchangeLeftAndRightSibling( BT->leftChild );
776         exchangeLeftAndRightSibling( BT->rightChild );
777     }
778 }
779 
780 void _Binary_Tree::copyBTree( binTree BT1, binTree BT )
781 {
782     bitNode *tmp = NULL;//new bitNode;
783     BT1->data = BT->data;
784     if( BT->leftChild )
785     {
786         BT1->leftChild = new bitNode;
787         tmp = BT1->leftChild;
788         tmp->leftChild = NULL;
789         tmp->rightChild = NULL;
790         copyBTree( tmp, BT->leftChild );
791     }
792     if( BT->rightChild )
793     {
794         BT1->rightChild = new bitNode;
795         tmp = BT1->rightChild;
796         tmp->leftChild = NULL;
797         tmp->rightChild = NULL;
798         copyBTree( tmp, BT->rightChild );
799     }
800 }
801 
802 void _Binary_Tree::levelOrderTraverse( binTree BT )
803 {
804     clq.enQueue(BT);
805     while( !clq.emptyCharLinkedQueue() )
806     {
807         //CLNode *tmp = NULL;
808         clq.getFront(BT);
809         cout << BT->data << " ";
810         clq.deQueue();
811         if( BT->leftChild != NULL )
812         {
813             clq.enQueue( BT->leftChild );
814         }
815         if( BT->rightChild != NULL )
816         {
817             clq.enQueue( BT->rightChild );
818         }
819     }
820 }
821 
822 void _Binary_Tree::allLeafToRootPath( binTree BT, char *path, int &pathLength )
823 {
824     if(BT)
825     {
826         if( !BT->leftChild && !BT->rightChild )
827         {
828             path[pathLength] = BT->data;
829             cout << BT->data << " leaf to root path: " << endl;
830             for( int i = pathLength; i >= 0; i -- )
831             {
832                 if( i != 0 )
833                     cout << path[i] << " --> ";
834                 else
835                     cout << path[i] << "\n";
836             }
837             //cout << endl;
838         }
839         else
840         {
841             path[ pathLength ++ ] = BT->data;
842             allLeafToRootPath( BT->leftChild, path, pathLength );
843             allLeafToRootPath( BT->rightChild, path, pathLength );
844             pathLength --;
845         }
846     }
847 }
848 
849 void _Binary_Tree::binaryTreeLongestPath( binTree BT, elementType *path, int &pathLength, 
850                            elementType *longestPath, int &longestLength )
851 {
852     if(BT)
853     {
854         if( !BT->leftChild && !BT->rightChild )
855         {
856             path[pathLength] = BT->data;
857             if( pathLength > longestLength)
858             {
859             //cout << BT->data << " leaf to root path: " << endl;
860                 //longestPath = pathLength;
861                 for( int i = pathLength; i >= 0; i -- )
862                 {
863                     /*
864                     if( i != 0 )
865                         cout << path[i] << " --> ";
866                     else
867                         cout << path[i] << "\n";
868                     */
869                     longestPath[i] = path[i];
870                 }
871                 longestLength = pathLength;
872             }
873             //longestLength = pathLength;
874             //cout << endl;
875         }
876         else
877         {
878             path[ pathLength ++ ] = BT->data;
879             binaryTreeLongestPath( BT->leftChild, path, pathLength, longestPath, longestLength );
880             binaryTreeLongestPath( BT->rightChild, path, pathLength, longestPath, longestLength );
881             pathLength --;
882         }
883     }
884 }
885 
886 binTree _Binary_Tree::nearestAncestor( binTree BT, bitNode *BNode1, bitNode *BNode2 )
887 {
888 //    if( !_exit( BT, BNode1->data ) )
889     //{
890     //    cout << BNode1->data << " is not in the binary tree!" << endl;
891     //    return NULL;
892     //}
893     //if( !_exit( BT, BNode2->data ) )
894     //{
895     //    cout << BNode2->data << " is not in the binary tree!" << endl;
896     //    return NULL;
897     //}
898     if( !BT || !BNode1 || !BNode2 )
899     {
900         //cout << "NO ANCESTOR!" << endl;
901         return NULL;
902     }
903     if( BT == BNode1 || BT == BNode2 )
904     {
905         //cout << BT->data << endl;
906         return BT;
907     }
908     bitNode *left = nearestAncestor( BT->leftChild, BNode1, BNode2 );
909     bitNode *right = nearestAncestor( BT->rightChild, BNode1, BNode2 );
910     if( left && right )
911     {
912         //cout << BT->data << endl;
913         return BT;
914     }
915     else if(!left)
916     {
917         //cout << right->data << endl;
918         return right;
919     }
920     else
921     {
922         //cout << left->data << endl;
923         return left;
924     }
925 }

  1 // BinaryTree.cpp : Defines the entry point for the console application.
  2 //
  3 
  4 #include "stdafx.h"
  5 #include "_Binary_Tree.h"
  6 #include "charLinkedQueue.h"
  7 
  8 
  9 void test1()
 10 {
 11     _Binary_Tree BT1;
 12     elementType strLine[100][3];
 13     int nRow = 0, nLen = 0;
 14     binTree index;
 15     BT1.readFileToArray(strLine,nLen);
 16     //BT1._Binary_Tree();
 17     
 18     BT1.createBinaryTree( index,strLine, nLen, nRow);
 19     
 20     cout << "The preorder traversal of sequence is" << endl;
 21     BT1.PreOrderTraverse(BT1.getNodePoint());
 22     cout << endl;
 23     cout << "The middle order traversal of sequence is" << endl;
 24     BT1.InOrderTraverse(BT1.getNodePoint()); 
 25     cout << endl;
 26     cout << "The post order traversal of sequence is" << endl;
 27     BT1.PostOrderTraverse(BT1.getNodePoint()); 
 28     cout << endl;
 29     cout << "The level order traversal of sequence is" << endl;
 30     BT1.levelOrderTraverse( BT1.getNodePoint() );
 31     cout << endl;
 32     int n = 1;
 33     BT1.level( BT1.getNodePoint() , n );
 34     cout << "BTree height: "<< BT1.height( BT1.getNodePoint() ) << endl;
 35     cout << "Total node: " << BT1.numberOfBTreeNode( BT1.getNodePoint() ) << endl;
 36     int m = 0;
 37     cout << "Leaf node: " << BT1.numberOfBTreeLeafNode( BT1.getNodePoint(), m ) << endl;
 38     int a = 0;
 39     BT1.numberOfNodeDegreeTwo( BT1.getNodePoint(), a );
 40     cout << "Node degree two: " << a << endl;
 41 }
 42 
 43 void test2()
 44 {
 45     _Binary_Tree BT1;
 46     elementType strLine[100][3];
 47     int nRow = 0, nLen = 0;
 48     binTree index;
 49     BT1.readFileToArray(strLine,nLen);
 50     //BT1._Binary_Tree();
 51     
 52     BT1.createBinaryTree( index,strLine, nLen, nRow);
 53     char ch;
 54     int key;
 55     cout << "Please input a letter as operational character and a number to choose the operation,separated by space.\n\"1\" for searching parent-node，\"2\" for searching sibiling-node and \"3\" for searching child-node." << endl;
 56     while( cin>> ch >> key )
 57     {
 58         if( key == 1 )
 59         {
 60             bool flag = false;
 61             bitNode *index = NULL;
 62             index = BT1.getParent( BT1.getNodePoint(), ch );
 63             if( index && index != BT1.getNodePoint() )
 64                 cout << ch << " parent ---- " << index->data << endl;
 65             else if( index && index->data == ch )
 66                 cout << ch << " is the root node, no parent." << endl;
 67             else if(index)
 68                 cout << ch << " parent ---- " << index->data << endl;
 69         }
 70         else if( key == 2 )
 71         {
 72             BT1.getSibling( BT1.getNodePoint(), ch );
 73         }
 74         else if( key == 3 )
 75         {
 76             bool flag;
 77             BT1.getChild( BT1.getNodePoint(), ch, flag );
 78         }
 79         //Sleep( 1000 * 60 );
 80         //system( "cls" );
 81         //cout << "Please input a letter as operational character and a number to choose the operation,separated by space.\n\"1\" for searching parent-node，\"2\" for searching sibiling-node and \"3\" for searching child-node." << endl;
 82     }
 83 }
 84 
 85 void test3()
 86 {
 87     _Binary_Tree BT1;
 88     elementType strLine[100][3];
 89     int nRow = 0, nLen = 0;
 90     binTree index;
 91     BT1.readFileToArray(strLine,nLen);
 92     //BT1._Binary_Tree();
 93     
 94     BT1.createBinaryTree( index,strLine, nLen, nRow);
 95 
 96     elementType value;
 97     int cnt = 0;
 98     cout << "Please input a letter and the program will judge it in which layer of the binary-tree!" << endl;
 99     while( cin >> value )
100     {
101         int number = 1;
102         BT1.levelJudge( BT1.getNodePoint(), value , number, 1 );
103         cout << value << " ---- " << number << " level!" << endl;
104         cnt ++;
105         //Sleep( 1000 * 60 );
106         if( cnt % 10 == 0 )
107             system( "cls" );
108         
109         cout << "Please input a letter and the program will judge it in which layer of the binary-tree!" << endl;
110     }
111 }
112 
113 void test4()
114 {
115     elementType str[10000];
116     cout << "Please input a character array that will be transformed to the elements of a binary tree.\nAttention the typed array must extend for the complete binary tree!" << endl;
117     while( cin >> str )
118     {
119         _Binary_Tree BT1(str);
120         cout << "The preorder traversal of sequence is" << endl;
121         BT1.PreOrderTraverse(BT1.getNodePoint());
122         cout << endl;
123         cout << "The middle order traversal of sequence is" << endl;
124         BT1.InOrderTraverse(BT1.getNodePoint()); 
125         cout << endl;
126         cout << "The post order traversal of sequence is" << endl;
127         BT1.PostOrderTraverse(BT1.getNodePoint()); 
128         cout << endl;
129         cout << "The level order traversal of sequence is" << endl;
130         BT1.levelOrderTraverse( BT1.getNodePoint() );
131         cout << endl;
132         int n = 1;
133         BT1.level( BT1.getNodePoint() , n );
134         cout << "BTree height: "<< BT1.height( BT1.getNodePoint() ) << endl;
135         cout << "Total node: " << BT1.numberOfBTreeNode( BT1.getNodePoint() ) << endl;
136         int m = 0;
137         cout << "Leaf node: " << BT1.numberOfBTreeLeafNode( BT1.getNodePoint(), m ) << endl;
138         int a = 0;
139         BT1.numberOfNodeDegreeTwo( BT1.getNodePoint(), a );
140         cout << "Node degree two: " << a << endl;
141         Sleep( 1000 * 60 );
142         system( "cls" );
143         cout << "Please input a character array that will be transformed to the elements of a binary tree.\nAttention the typed array must extend for the complete binary tree!" << endl;
144     }
145 }
146 
147 void test5()
148 {
149     _Binary_Tree BT1;
150     elementType strLine[100][3];
151     int nRow = 0, nLen = 0;
152     binTree index;
153     BT1.readFileToArray(strLine,nLen);
154     //BT1._Binary_Tree();
155     
156     BT1.createBinaryTree( index,strLine, nLen, nRow);
157     cout << "The program will exchange the left subtree and right subtree of the file-inputed binary tree!" << endl;
158     cout << "The origin binary tree is as follow:" << endl;
159 
160     cout << "The preorder traversal of sequence is" << endl;
161     BT1.PreOrderTraverse(BT1.getNodePoint());
162     cout << endl;
163     cout << "The middle order traversal of sequence is" << endl;
164     BT1.InOrderTraverse(BT1.getNodePoint()); 
165     cout << endl;
166     cout << "The post order traversal of sequence is" << endl;
167     BT1.PostOrderTraverse(BT1.getNodePoint()); 
168     cout << endl;
169     cout << "The level order traversal of sequence is" << endl;
170     BT1.levelOrderTraverse( BT1.getNodePoint() );
171     cout << endl;
172 
173     BT1.exchangeLeftAndRightSibling( BT1.getNodePoint() );
174     cout << "The following for the exchange of binary tree:" << endl;
175     cout << "The preorder traversal of sequence is" << endl;
176     BT1.PreOrderTraverse(BT1.getNodePoint());
177     cout << endl;
178     cout << "The middle order traversal of sequence is" << endl;
179     BT1.InOrderTraverse(BT1.getNodePoint()); 
180     cout << endl;
181     cout << "The post order traversal of sequence is" << endl;
182     BT1.PostOrderTraverse(BT1.getNodePoint()); 
183     cout << endl;
184     cout << "The level order traversal of sequence is" << endl;
185     BT1.levelOrderTraverse( BT1.getNodePoint() );
186     cout << endl;
187 }
188 
189 void test6()
190 {
191     _Binary_Tree BT1;
192     elementType strLine[100][3];
193     int nRow = 0, nLen = 0;
194     binTree index;
195     BT1.readFileToArray(strLine,nLen);
196     //BT1._Binary_Tree();
197     
198     BT1.createBinaryTree( index,strLine, nLen, nRow);
199     cout << "The program will copy the file-inputed binary tree to another empty one!" << endl;
200     _Binary_Tree BT2;
201 
202     cout << "The origin binary tree is as follow:" << endl;
203     cout << "The preorder traversal of sequence is" << endl;
204     BT1.PreOrderTraverse(BT1.getNodePoint());
205     cout << endl;
206     cout << "The middle order traversal of sequence is" << endl;
207     BT1.InOrderTraverse(BT1.getNodePoint()); 
208     cout << endl;
209     cout << "The post order traversal of sequence is" << endl;
210     BT1.PostOrderTraverse(BT1.getNodePoint()); 
211     cout << endl;
212     cout << "The level order traversal of sequence is" << endl;
213     BT1.levelOrderTraverse( BT1.getNodePoint() );
214     cout << endl;
215 
216     cout << "The empty binary tree is as follow:" << endl;
217 
218     cout << "The preorder traversal of sequence is" << endl;
219     BT2.PreOrderTraverse(BT2.getNodePoint());
220     cout << endl;
221     cout << "The middle order traversal of sequence is" << endl;
222     BT2.InOrderTraverse(BT2.getNodePoint()); 
223     cout << endl;
224     cout << "The post order traversal of sequence is" << endl;
225     BT2.PostOrderTraverse(BT2.getNodePoint()); 
226     cout << endl;
227     cout << "The level order traversal of sequence is" << endl;
228     BT2.levelOrderTraverse( BT2.getNodePoint() );
229     cout << endl;
230     
231     cout << "The following for the copy of binary tree:" << endl;
232 
233     BT1.copyBTree( BT2.getNodePoint(), BT1.getNodePoint() );
234 
235     cout << "The preorder traversal of sequence is" << endl;
236     BT2.PreOrderTraverse(BT2.getNodePoint());
237     cout << endl;
238     cout << "The middle order traversal of sequence is" << endl;
239     BT2.InOrderTraverse(BT2.getNodePoint()); 
240     cout << endl;
241     cout << "The post order traversal of sequence is" << endl;
242     BT2.PostOrderTraverse(BT2.getNodePoint()); 
243     cout << endl;
244     cout << "The level order traversal of sequence is" << endl;
245     BT2.levelOrderTraverse( BT2.getNodePoint() );
246     cout << endl;
247 
248 }
249 
250 void test7()
251 {
252     _Binary_Tree BT1;
253     elementType strLine[100][3];
254     int nRow = 0, nLen = 0;
255     binTree index;
256     BT1.readFileToArray(strLine,nLen);
257     //BT1._Binary_Tree();
258     
259     BT1.createBinaryTree( index,strLine, nLen, nRow);
260     cout << "The program will output the paths that each leaf node of the binary tree to the root node." << endl;
261 
262     cout << "The origin binary tree is as follow:" << endl;
263     cout << "The preorder traversal of sequence is" << endl;
264     BT1.PreOrderTraverse(BT1.getNodePoint());
265     cout << endl;
266     cout << "The middle order traversal of sequence is" << endl;
267     BT1.InOrderTraverse(BT1.getNodePoint()); 
268     cout << endl;
269     cout << "The post order traversal of sequence is" << endl;
270     BT1.PostOrderTraverse(BT1.getNodePoint()); 
271     cout << endl;
272     cout << "The level order traversal of sequence is" << endl;
273     BT1.levelOrderTraverse( BT1.getNodePoint() );
274     cout << endl;
275 
276     int pathLength = 0;
277     elementType *path = new char[ BT1.numberOfBTreeNode( BT1.getNodePoint() ) ];
278     BT1.allLeafToRootPath( BT1.getNodePoint(), path, pathLength );
279     
280 }
281 
282 void test8()
283 {
284     _Binary_Tree BT1;
285     elementType strLine[100][3];
286     int nRow = 0, nLen = 0;
287     binTree index;
288     BT1.readFileToArray(strLine,nLen);
289     //BT1._Binary_Tree();
290     
291     BT1.createBinaryTree( index,strLine, nLen, nRow);
292     cout << "The program will ouput the level order traversal of the file-inputed binary tree." << endl;
293     cout << "The level order traversal of sequence is" << endl;
294     BT1.levelOrderTraverse( BT1.getNodePoint() );
295     cout << endl;
296 }
297 
298 void test9()
299 {
300     _Binary_Tree BT1;
301     char strLine[100][3];
302     int nRow = 0, nLen = 0;
303     binTree index;
304     BT1.readFileToArray(strLine,nLen);
305     //BT1._Binary_Tree();
306     
307     BT1.createBinaryTree( index,strLine, nLen, nRow);
308     
309     cout << "Please input two character and the program will output their nearset ancestor." << endl;
310     elementType ch1, ch2;
311     while( cin >> ch1 >> ch2 )
312     {
313         //BT1.nearestAncestor( binTree BT, bitNode *BNode1, bitNode *BNode2 );
314         bitNode *index1 = BT1.getNodePoint( BT1.getNodePoint(), ch1 );
315         
316         if(!index1)
317         {
318             cout << ch1 << " is not in the binary tree!" << endl;
319         }
320         
321         bitNode *index2 = BT1.getNodePoint( BT1.getNodePoint(), ch2 );
322         
323         if(!index2)
324         {
325             cout << ch2 << " is not in the binary tree!" << endl;
326         }
327         
328         if( index1 && index2 )
329         {
330             bitNode *target = BT1.nearestAncestor( BT1.getNodePoint(), index1, index2 );
331             cout << "The nearset ancestor of " << ch1 << " and " << ch2 << " is " << target->data << endl;
332         }
333         cout << "Please input two character and the program will output their nearset ancestor." << endl;
334     }
335 }
336 
337 void test10()
338 {
339     _Binary_Tree BT1;
340     char strLine[100][3];
341     int nRow = 0, nLen = 0;
342     binTree index;
343     BT1.readFileToArray(strLine,nLen);
344     //BT1._Binary_Tree();
345     
346     BT1.createBinaryTree( index,strLine, nLen, nRow);
347     cout << "The program will output the longest path of the binary tree." << endl;
348     int pathLength = 0, longestLength = 0;
349     elementType *path1 = new char[ BT1.numberOfBTreeNode( BT1.getNodePoint() ) ];
350     elementType *longestPath = new char[ BT1.numberOfBTreeNode( BT1.getNodePoint() ) ];
351     BT1.binaryTreeLongestPath( BT1.getNodePoint(), path1, pathLength, longestPath, longestLength );
352     cout << "Longest path:" << endl;
353      for( int i = longestLength; i >= 0; i -- )
354     {
355         if( i!= 0 )
356             cout << longestPath[i] << " --> ";
357         else
358             cout << longestPath[i] << endl;
359         
360     }
361 }
362 
363 int main(int argc, char* argv[])
364 {
365     //test1();
366     test2();
367     //test3();
368     //test4();
369     //test5();
370     //test6();
371     //test7();
372     //test8();
373     //test9();
374     //test10();
375     return 0;
376 }