// c6-2.h 二叉樹的二叉鏈表存儲結構(見圖6.7)
typedef struct BiTNode
{
TElemType data;
BiTNode *lchild,*rchild; // 左右孩子指針
}BiTNode,*BiTree;
二叉樹的二叉鏈表存儲結構刪除和插入結點或子樹都很靈活。結點動態生成，可充分利用存儲空間。圖68是圖61(a)所示二叉樹的二叉鏈表存儲結構。bo6-2.cpp是二叉鏈
表存儲結構的基本操作，其中，調用按先序次序構造二叉鏈表的函數CreateBiTree()(算法
6.4)時，不僅要按先序次序輸入結點的值，而且還要把葉子結點的左右孩子指針和度爲1
的結點的空指針輸入。其原因是隻根據結點的先序次序還不能惟一確定樹的形狀。如圖
69所示，三棵樹的先序次序都是abc。這樣，在調用函數CreateBiTree()時，輸入abc就會
產生多義性。如果把葉子結點的左右孩子指針和度爲1的結點的空指針也按先序輸入，則
圖69(a)輸入字符的次序爲(以^代替結點的空指針)abc^^^^；圖69(b)輸入字符的次序
爲ab^^c^^；圖69(c)輸入字符的次序爲a^b^c^^。
bo6-2.cpp 中的許多基本操作都採用了遞歸函數，因爲二叉樹的層數是不定的，正確
採用遞歸函數可簡化編程。注意到這些遞歸函數的特點：第1 是降階的；第2 是有出
口的。
在bo6-2.cpp 和main6-2.cpp 中，採用了編譯預處理的“#define”、“#ifdef”等命令，
通過把main6-2.cpp 的第2 行或第3 行設爲註釋行，使程序可以在結點類型爲整型或字符
型的情況下應用。
// func6-3.cpp bo6-2.cpp和func9-1.cpp調用
void InitBiTree(BiTree &T)
{ // 操作結果：構造空二叉樹T(見圖6.10)
T=NULL;
}
void DestroyBiTree(BiTree &T)
{ // 初始條件：二叉樹T存在。操作結果：銷燬二叉樹T(見圖6.10)
if(T) // 非空樹
{
if(T->lchild) // 有左孩子
DestroyBiTree(T->lchild); // 銷燬左孩子子樹
if(T->rchild) // 有右孩子
DestroyBiTree(T->rchild); // 銷燬右孩子子樹
free(T); // 釋放根結點
T=NULL; // 空指針賦0
}
}
void PreOrderTraverse(BiTree T,void(*Visit)(TElemType))
{ // 初始條件：二叉樹T存在，Visit是對結點操作的應用函數。算法6.1，有改動
// 操作結果：先序遞歸遍歷T，對每個結點調用函數Visit一次且僅一次
if(T) // T不空
{
Visit(T->data); // 先訪問根結點
PreOrderTraverse(T->lchild,Visit); // 再先序遍歷左子樹
PreOrderTraverse(T->rchild,Visit); // 最後先序遍歷右子樹
}
}
void InOrderTraverse(BiTree T,void(*Visit)(TElemType))
{ // 初始條件：二叉樹T存在，Visit是對結點操作的應用函數
// 操作結果：中序遞歸遍歷T，對每個結點調用函數Visit一次且僅一次
if(T)
{
InOrderTraverse(T->lchild,Visit); // 先中序遍歷左子樹
Visit(T->data); // 再訪問根結點
InOrderTraverse(T->rchild,Visit); // 最後中序遍歷右子樹
}
}
// bo6-2.cpp 二叉樹的二叉鏈表存儲(存儲結構由c6-2.h定義)的基本操作(22個)，包括算法6.1～6.4
#define ClearBiTree DestroyBiTree // 清空二叉樹和銷燬二叉樹的操作一樣
#include"func6-3.cpp"
// 包括InitBiTree()、DestroyBiTree()、PreOrderTraverse()和InOrderTraverse()4函數
void CreateBiTree(BiTree &T)
{ // 算法6.4：按先序次序輸入二叉樹中結點的值(可爲字符型或整型，在主程中定義)，
// 構造二叉鏈表表示的二叉樹T。變量Nil表示空(子)樹。有改動
TElemType ch;
scanf(form,&ch);
if(ch==Nil) // 空
T=NULL;
else
{
T=(BiTree)malloc(sizeof(BiTNode)); // 生成根結點
if(!T)
exit(OVERFLOW);
T->data=ch;
CreateBiTree(T->lchild); // 構造左子樹
CreateBiTree(T->rchild); // 構造右子樹
}
}
Status BiTreeEmpty(BiTree T)
{ // 初始條件：二叉樹T存在。操作結果：若T爲空二叉樹，則返回TRUE；否則FALSE
if(T)
return FALSE;
else
return TRUE;
}
int BiTreeDepth(BiTree T)
{ // 初始條件：二叉樹T存在。操作結果：返回T的深度
int i,j;
if(!T)
return 0; // 空樹深度爲0
if(T->lchild)
i=BiTreeDepth(T->lchild); // i爲左子樹的深度
else
i=0;
if(T->rchild)
j=BiTreeDepth(T->rchild); // j爲右子樹的深度
else
j=0;
return i>j?i+1:j+1; // T的深度爲其左右子樹的深度中的大者+1
}
TElemType Root(BiTree T)
{ // 初始條件：二叉樹T存在。操作結果：返回T的根
if(BiTreeEmpty(T))
return Nil;
else
return T->data;
}
TElemType Value(BiTree p)
{ // 初始條件：二叉樹T存在，p指向T中某個結點。操作結果：返回p所指結點的值
return p->data;
}
void Assign(BiTree p,TElemType value)
{ // 給p所指結點賦值爲value
p->data=value;
}
typedef BiTree QElemType; // 設隊列元素爲二叉樹的指針類型
#include"c3-2.h" // 鏈隊列
#include"bo3-2.cpp" // 鏈隊列的基本操作
TElemType Parent(BiTree T,TElemType e)
{ // 初始條件：二叉樹T存在，e是T中某個結點
// 操作結果：若e是T的非根結點，則返回它的雙親，否則返回“空”
LinkQueue q;
QElemType a;
if(T) // 非空樹
{
InitQueue(q); // 初始化隊列
EnQueue(q,T); // 樹根指針入隊
while(!QueueEmpty(q)) // 隊不空
{
DeQueue(q,a); // 出隊，隊列元素賦給a
if(a->lchild&&a->lchild->data==e||a->rchild&&a->rchild->data==e)
// 找到e(是其左或右孩子)
return a->data; // 返回e的雙親的值
else // 沒找到e，則入隊其左右孩子指針(如果非空)
{
if(a->lchild)
EnQueue(q,a->lchild);
if(a->rchild)
EnQueue(q,a->rchild);
}
}
}
return Nil; // 樹空或沒找到e
}
BiTree Point(BiTree T,TElemType s)
{ // 返回二叉樹T中指向元素值爲s的結點的指針。另加
LinkQueue q;
QElemType a;
if(T) // 非空樹
{
InitQueue(q); // 初始化隊列
EnQueue(q,T); // 根指針入隊
while(!QueueEmpty(q)) // 隊不空
{
DeQueue(q,a); // 出隊，隊列元素賦給a
if(a->data==s)
return a;
if(a->lchild) // 有左孩子
EnQueue(q,a->lchild); // 入隊左孩子
if(a->rchild) // 有右孩子
EnQueue(q,a->rchild); // 入隊右孩子
}
}
return NULL;
}
TElemType LeftChild(BiTree T,TElemType e)
{ // 初始條件：二叉樹T存在，e是T中某個結點。操作結果：返回e的左孩子。若e無左孩子,則返回“空”
BiTree a;
if(T) // 非空樹
{
a=Point(T,e); // a是結點e的指針
if(a&&a->lchild) // T中存在結點e且e存在左孩子
return a->lchild->data; // 返回e的左孩子的值
}
return Nil; // 其餘情況返回空
}
TElemType RightChild(BiTree T,TElemType e)
{ // 初始條件：二叉樹T存在，e是T中某個結點。操作結果：返回e的右孩子。若e無右孩子,則返回“空”
BiTree a;
if(T) // 非空樹
{
a=Point(T,e); // a是結點e的指針
if(a&&a->rchild) // T中存在結點e且e存在右孩子
return a->rchild->data; // 返回e的右孩子的值
}
return Nil; // 其餘情況返回空
}
TElemType LeftSibling(BiTree T,TElemType e)
{ // 初始條件：二叉樹T存在，e是T中某個結點
// 操作結果：返回e的左兄弟。若e是T的左孩子或無左兄弟，則返回“空”
TElemType a;
BiTree p;
if(T) // 非空樹
{
a=Parent(T,e); // a爲e的雙親
if(a!=Nil) // 找到e的雙親
{
p=Point(T,a); // p爲指向結點a的指針
if(p->lchild&&p->rchild&&p->rchild->data==e) // p存在左右孩子且右孩子是e
return p->lchild->data; // 返回p的左孩子(e的左兄弟)
}
}
return Nil; // 其餘情況返回空
}
TElemType RightSibling(BiTree T,TElemType e)
{ // 初始條件：二叉樹T存在，e是T中某個結點
// 操作結果：返回e的右兄弟。若e是T的右孩子或無右兄弟，則返回“空”
TElemType a;
BiTree p;
if(T) // 非空樹
{
a=Parent(T,e); // a爲e的雙親
if(a!=Nil) // 找到e的雙親
{
p=Point(T,a); // p爲指向結點a的指針
if(p->lchild&&p->rchild&&p->lchild->data==e) // p存在左右孩子且左孩子是e
return p->rchild->data; // 返回p的右孩子(e的右兄弟)
}
}
return Nil; // 其餘情況返回空
}
Status InsertChild(BiTree p,int LR,BiTree c) // 形參T無用
{ // 初始條件：二叉樹T存在，p指向T中某個結點，LR爲0或1，非空二叉樹c與T不相交且右子樹爲空
// 操作結果：根據LR爲0或1，插入c爲T中p所指結點的左或右子樹。p所指結點的
// 原有左或右子樹則成爲c的右子樹
if(p) // p不空
{
if(LR==0)
{
c->rchild=p->lchild;
p->lchild=c;
}
else // LR==1
{
c->rchild=p->rchild;
p->rchild=c;
}
return OK;
}
return ERROR; // p空
}
Status DeleteChild(BiTree p,int LR) // 形參T無用
{ // 初始條件：二叉樹T存在，p指向T中某個結點，LR爲0或1
// 操作結果：根據LR爲0或1，刪除T中p所指結點的左或右子樹
if(p) // p不空
{
if(LR==0) // 刪除左子樹
ClearBiTree(p->lchild);
else // 刪除右子樹
ClearBiTree(p->rchild);
return OK;
}
return ERROR; // p空
}
typedef BiTree SElemType; // 設棧元素爲二叉樹的指針類型
#include"c3-1.h" // 順序棧
#include"bo3-1.cpp" // 順序棧的基本操作
void InOrderTraverse1(BiTree T,void(*Visit)(TElemType))
{ // 採用二叉鏈表存儲結構，Visit是對數據元素操作的應用函數。算法6.3，有改動
// 中序遍歷二叉樹T的非遞歸算法(利用棧)，對每個數據元素調用函數Visit
SqStack S;
InitStack(S);
while(T||!StackEmpty(S))
{
if(T)
{ // 根指針進棧，遍歷左子樹
Push(S,T);
T=T->lchild;
}
else
{ // 根指針退棧，訪問根結點，遍歷右子樹
Pop(S,T);
Visit(T->data);
T=T->rchild;
}
}
printf("\n");
}
void InOrderTraverse2(BiTree T,void(*Visit)(TElemType))
{ // 採用二叉鏈表存儲結構，Visit是對數據元素操作的應用函數。算法6.2，有改動
// 中序遍歷二叉樹T的非遞歸算法(利用棧)，對每個數據元素調用函數Visit
SqStack S;
BiTree p;
InitStack(S);
Push(S,T); // 根指針進棧
while(!StackEmpty(S))
{
while(GetTop(S,p)&&p)
Push(S,p->lchild); // 向左走到盡頭
Pop(S,p); // 空指針退棧
if(!StackEmpty(S))
{ // 訪問結點，向右一步
Pop(S,p);
Visit(p->data);
Push(S,p->rchild);
}
}
printf("\n");
}
void PostOrderTraverse(BiTree T,void(*Visit)(TElemType))
{ // 初始條件：二叉樹T存在，Visit是對結點操作的應用函數
// 操作結果：後序遞歸遍歷T，對每個結點調用函數Visit一次且僅一次
if(T) // T不空
{
PostOrderTraverse(T->lchild,Visit); // 先後序遍歷左子樹
PostOrderTraverse(T->rchild,Visit); // 再後序遍歷右子樹
Visit(T->data); // 最後訪問根結點
}
}
void LevelOrderTraverse(BiTree T,void(*Visit)(TElemType))
{ // 初始條件：二叉樹T存在，Visit是對結點操作的應用函數
// 操作結果：層序遞歸遍歷T(利用隊列)，對每個結點調用函數Visit一次且僅一次
LinkQueue q;
QElemType a;
if(T)
{
InitQueue(q); // 初始化隊列q
EnQueue(q,T); // 根指針入隊
while(!QueueEmpty(q)) // 隊列不空
{
DeQueue(q,a); // 出隊元素(指針),賦給a
Visit(a->data); // 訪問a所指結點
if(a->lchild!=NULL) // a有左孩子
EnQueue(q,a->lchild); // 入隊a的左孩子
if(a->rchild!=NULL) // a有右孩子
EnQueue(q,a->rchild); // 入隊a的右孩子
}
printf("\n");
}
}
// main6-2.cpp 檢驗bo6-2.cpp的主程序，利用條件編譯選擇數據類型(另一種方法)
#define CHAR // 字符型
// #define INT // 整型(二者選一)
#include"c1.h"
#ifdef CHAR
typedef char TElemType;
TElemType Nil=' '; // 字符型以空格符爲空
#define form "%c" // 輸入輸出的格式爲%c
#endif
#ifdef INT
typedef int TElemType;
TElemType Nil=0; // 整型以0爲空
#define form "%d" // 輸入輸出的格式爲%d
#endif
#include"c6-2.h"
#include"bo6-2.cpp"
void visitT(TElemType e)
{
printf(form" ",e);
}
void main()
{
int i;
BiTree T,p,c;
TElemType e1,e2;
InitBiTree(T);
printf("構造空二叉樹後,樹空否？%d(1:是0:否)樹的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
e1=Root(T);
if(e1!=Nil)
printf("二叉樹的根爲"form"\n",e1);
else
printf("樹空，無根\n");
#ifdef CHAR
printf("請先序輸入二叉樹(如:ab三個空格表示a爲根結點,b爲左子樹的二叉樹)\n");
#endif
#ifdef INT
printf("請先序輸入二叉樹(如:1 2 0 0 0表示1爲根結點,2爲左子樹的二叉樹)\n");
#endif
CreateBiTree(T);
printf("建立二叉樹後,樹空否？%d(1:是0:否) 樹的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
e1=Root(T);
if(e1!=Nil)
printf("二叉樹的根爲"form"\n",e1);
else
printf("樹空，無根\n");
printf("中序遞歸遍歷二叉樹:\n");
InOrderTraverse(T,visitT);
printf("\n後序遞歸遍歷二叉樹:\n");
PostOrderTraverse(T,visitT);
printf("\n請輸入一個結點的值: ");
scanf("%*c"form,&e1);
p=Point(T,e1); // p爲e1的指針
printf("結點的值爲"form"\n",Value(p));
printf("欲改變此結點的值，請輸入新值: ");
scanf("%*c"form"%*c",&e2); // 後一個%*c吃掉回車符，爲調用CreateBiTree()做準備
Assign(p,e2);
printf("層序遍歷二叉樹:\n");
LevelOrderTraverse(T,visitT);
e1=Parent(T,e2);
if(e1!=Nil)
printf("%c的雙親是"form"\n",e2,e1);
else
printf(form"沒有雙親\n",e2);
e1=LeftChild(T,e2);
if(e1!=Nil)
printf(form"的左孩子是"form"\n",e2,e1);
else
printf(form"沒有左孩子\n",e2);
e1=RightChild(T,e2);
if(e1!=Nil)
printf(form"的右孩子是"form"\n",e2,e1);
else
printf(form"沒有右孩子\n",e2);
e1=LeftSibling(T,e2);
if(e1!=Nil)
printf(form"的左兄弟是"form"\n",e2,e1);
else
printf(form"沒有左兄弟\n",e2);
e1=RightSibling(T,e2);
if(e1!=Nil)
printf(form"的右兄弟是"form"\n",e2,e1);
else
printf(form"沒有右兄弟\n",e2);
InitBiTree(c);
printf("構造一個右子樹爲空的二叉樹c:\n");
#ifdef CHAR
printf("請先序輸入二叉樹(如:ab三個空格表示a爲根結點,b爲左子樹的二叉樹)\n");
#endif
#ifdef INT
printf("請先序輸入二叉樹(如:1 2 0 0 0表示1爲根結點,2爲左子樹的二叉樹)\n");
#endif
CreateBiTree(c);
printf("先序遞歸遍歷二叉樹c:\n");
PreOrderTraverse(c,visitT);
printf("\n層序遍歷二叉樹c:\n");
LevelOrderTraverse(c,visitT);
printf("樹c插到樹T中,請輸入樹T中樹c的雙親結點c爲左(0)或右(1)子樹: ");
scanf("%*c"form"%d",&e1,&i);
p=Point(T,e1); // p是T中樹c的雙親結點指針
InsertChild(p,i,c);
printf("先序遞歸遍歷二叉樹:\n");
PreOrderTraverse(T,visitT);
printf("\n中序非遞歸遍歷二叉樹:\n");
InOrderTraverse1(T,visitT);
printf("刪除子樹,請輸入待刪除子樹的雙親結點左(0)或右(1)子樹: ");
scanf("%*c"form"%d",&e1,&i);
p=Point(T,e1);
DeleteChild(p,i);
printf("先序遞歸遍歷二叉樹:\n");
PreOrderTraverse(T,visitT);
printf("\n中序非遞歸遍歷二叉樹(另一種方法):\n");
InOrderTraverse2(T,visitT);
DestroyBiTree(T);
}代碼的運行結果：
構造空二叉樹後,樹空否？1(1:是0:否)樹的深度=0
樹空，無根
請先序輸入二叉樹(如:ab三個空格表示a爲根結點,b爲左子樹的二叉樹)
abdg e c f (見圖611)
建立二叉樹後,樹空否？0(1:是0:否) 樹的深度=4
二叉樹的根爲a
中序遞歸遍歷二叉樹:
g d b e a c f
後序遞歸遍歷二叉樹:
g d e b f c a
請輸入一個結點的值: d
結點的值爲d
欲改變此結點的值，請輸入新值: m
層序遍歷二叉樹:
a b c m e f g
m的雙親是b
m的左孩子是g
m沒有右孩子
m沒有左兄弟
m的右兄弟是e
構造一個右子樹爲空的二叉樹c:
請先序輸入二叉樹(如:ab三個空格表示a爲根結點,b爲左子樹的二叉樹)
hijl k (見圖612)
先序遞歸遍歷二叉樹c:
h i j l k
層序遍歷二叉樹c:
h i j k l
樹c插到樹T中,請輸入樹T中樹c的雙親結點c爲左(0)或右(1)子樹: b 1
先序遞歸遍歷二叉樹: (見圖613)
a b m g h i j l k e c f
中序非遞歸遍歷二叉樹:
g m b l j i k h e a c f
刪除子樹,請輸入待刪除子樹的雙親結點左(0)或右(1)子樹: h 0
先序遞歸遍歷二叉樹: (見圖614)
a b m g h e c f
中序非遞歸遍歷二叉樹(另一種方法):
g m b h e a c f
