实验6
学号： 姓名： 专业：
6.1 实验目的
掌握二叉树的动态链表存储结构及表示。
掌握二叉树的三种遍历算法（递归和非递归两类）。
运用二叉树三种遍历的方法求解有关问题。
6.2 实验要求
按照C++面向对象方法编写二叉树类；二叉树的测试数据可用多种方式进行输入，如键盘输入、静态写入、文件读入等。//最难的是从文件把数据读进去！
设计二叉树的二叉链表存储结构，编写算法实现下列问题的求解。
<1>打印出二叉树的三种遍历序列。
<2>设计算法按中序次序输出二叉树中各结点的值及其所对应的层次数。
<3>求二叉树的高度。
<4>求二叉树的结点数。
<5>求二叉树的叶子结点数。
<6>求二叉树的度为2的结点数。
<7>键盘输入一个元素x，求其父节点、兄弟结点、子结点的值，不存在时给出相应提示信息。对兄弟结点和孩子结点，存在时要明确指出是左兄弟、左孩子、右兄弟或右孩子。
<8>键盘输入一个元素x，求其在树中的层次，不存在时给出相应提示信息。
<9>将按顺序方式存储在数组中的二叉树转换为二叉链表形式。（数组中要扩展为完全二叉树）。
<10>交换二叉树中每个结点的左右孩子指针的值。（即：左子树变为右子树，右子树变为左子树）。
（下面为选做实验，有兴趣的同学完成）
<11>复制一棵二叉树T到T1。
<12>输出二叉树从每个叶子结点到根结点的路径（经历的结点）。
<13>对二叉链表表示的二叉树，按从上到下，从左到右打印结点值，即按层次打印。（提示：需要使用队列）
<14>对二叉链表表示的二叉树，求2个结点最近的共同祖先。
实验测试数据基本要求：
<15>求二叉树中一条最长的路径长度（边数），并输出路径上的个结点值。
实验测试数据基本要求：
6.3 实验数据要求
自我编写测试样例，要求每个功能函数的测试样例不少于两组
6.4 运行结果截图及说明
图1 测试（1）、（2）、（3）、（4）、（5）、（6）
图2 测试（1）、（2）、（3）、（4）、（5）、（6）
图3 测试（1）、（2）、（3）、（4）、（5）、（6）
图4 测试（1）、（2）、（3）、（4）、（5）、（6）
图5 测试（1）、（2）、（3）、（4）、（5）、（6）
图6 测试（1）、（2）、（3）、（4）、（5）、（6）
图7 测试（1）、（2）、（3）、（4）、（5）、（6）
图8 测试（1）、（2）、（3）、（4）、（5）、（6）
图9 测试（1）、（2）、（3）、（4）、（5）、（6）
图10 测试（1）、（2）、（3）、（4）、（5）、（6）
图11 测试（1）、（2）、（3）、（4）、（5）、（6）
图12 测试（1）、（2）、（3）、（4）、（5）、（6）
图13 测试（1）、（2）、（3）、（4）、（5）、（6）
图14 测试（1）、（2）、（3）、（4）、（5）、（6）
图15 测试（1）、（2）、（3）、（4）、（5）、（6）
图16 测试（1）、（2）、（3）、（4）、（5）、（6）
图17 测试（1）、（2）、（3）、（4）、（5）、（6）
图18 测试（1）、（2）、（3）、（4）、（5）、（6）
图19 测试（1）、（2）、（3）、（4）、（5）、（6）
图20 测试（1）、（2）、（3）、（4）、（5）、（6）
图21 测试（1）、（2）、（3）、（4）、（5）、（6）
图22 测试（1）、（2）、（3）、（4）、（5）、（6）
图23 测试（1）、（2）、（3）、（4）、（5）、（6）
图24 测试（7）
图25 测试（7）
图26 测试（7）
图27 测试（7）
图28 测试（7）
图29 测试（7）
图30 测试（7）
图31 测试（8）
图32 测试（8）
图33 测试（9）
图34 测试（9）
图35 测试（10）
图36 测试（10）
图37 测试（11）
图38 测试（11）
图39 测试（12）
图40 测试（12）
图41 测试（13）
图42 测试（13）
图43 测试（14）
图44 测试（14）
图45 测试（15）
图46 测试（15）
6.5 附源代码
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 }
6.6 调试过程中出现的bug总结
往事不堪回首。
刚开始应该写成将data写成string或者直接将整个函数写成模板的，写完了最后测试时才发现现在的写法有诸多不便；但修改的话就又要重构一遍，懒得整了。
刚开始尝试写英文注释的，后面知难而退了；不过原来的英文注释我保留了。
附测试数据及对应二叉树图形：
bt4.btr
BinaryTree
A 0 1
B 0 1
C 0 1
D 0 0
bt8.btr
BinaryTree
1 1 1
2 1 1
3 1 1
4 0 0
5 0 0
6 0 1
7 0 0
8 0 0
bt9.btr
BinaryTree
a 1 1
b 1 1
d 0 0
e 1 1
g 0 0
h 0 0
c 1 0
f 0 1
i 0 0
bt10.btr
BinaryTree
A 1 1
B 1 1
C 0 0
D 1 0
E 0 0
F 1 1
G 0 1
H 0 0
I 1 0
J 0 0
bt12.btr
BinaryTree
A 1 1
B 1 1
C 0 0
D 1 1
E 0 0
F 0 0
G 1 1
H 1 1
I 0 0
J 1 0
K 0 0
L 0 0
bt14.btr
BinaryTree
A 1 0
B 1 1
C 1 1
D 0 1
E 0 0
F 1 0
G 0 1
H 0 0
I 1 0
J 1 1
K 0 0
L 1 0
M 1 0
N 0 0
bt15.btr
BinaryTree
A 1 1
B 1 1
D 1 0
G 0 0
E 1 1
H 0 0
I 0 0
C 0 1
F 1 1
J 1 1
L 0 0
M 0 1
N 1 0
O 0 0
K 0 0
bt21.btr
BinaryTree
a 1 1
b 1 1
c 1 1
d 1 1
e 0 0
f 0 0
g 0 0
h 1 1
i 0 0
j 0 0
k 1 1
l 1 1
m 0 0
n 0 0
o 1 1
p 0 1
q 0 0
r 1 1
s 0 0
t 1 0
u 0 0
bt261.btr
BinaryTree
a 1 1
b 1 1
c 1 1
d 1 1
e 0 0
f 0 0
g 1 0
h 0 0
i 1 1
j 0 1
k 0 0
l 1 0
m 0 0
n 1 1
o 1 1
p 1 1
q 0 0
r 0 0
s 0 0
t 1 1
u 1 1
v 0 0
w 0 0
x 1 1
y 0 0
z 0 0
bt262.btr
BinaryTree
a 1 1
b 1 1
c 1 1
d 0 1
e 1 1
f 0 1
g 0 0
h 1 1
i 0 0
j 0 0
k 1 1
l 0 0
m 0 0
n 1 1
o 0 0
p 0 0
q 1 1
r 0 1
s 1 1
t 0 0
u 0 0
v 1 1
w 0 1
x 0 0
y 0 1
z 0 0
full4.btr
BinaryTree
a 1 1
b 1 1
c 1 1
d 0 0
e 0 0
f 1 1
g 0 0
h 0 0
i 1 1
j 1 1
k 0 0
l 0 0
m 1 1
n 0 0
o 0 0
full5.btr
BinaryTree
a 1 1
b 1 1
c 1 1
d 1 1
e 0 0
f 0 0
g 1 1
h 0 0
i 0 0
j 1 1
k 1 1
l 0 0
m 0 0
n 1 1
o 0 0
p 0 0
q 1 1
r 1 1
s 1 1
t 0 0
u 0 0
v 1 1
w 0 0
x 0 0
y 1 1
z 1 1
1 0 0
2 0 0
3 1 1
4 0 0
5 0 0
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
