二叉鏈表的存儲表示
㈠ 若用二叉鏈表作為二叉樹的存儲表示,試用編寫遞歸演算法,統計二叉樹中葉子結點的個數
int count(Node *root) {
if (!root) return 0;
int ret = count(root->leftChild) + count(root->rightChild);
return ret == 0 ? 1 : ret;
}
第一行: 空指針返回0
第二行:統計左右子樹的葉子節點個數
第三行:如果左右子樹的葉子節點個數為0,則本身是一個葉子節點,返回1;否則返回左右子樹的葉子節點個數。
㈡ 以二叉鏈表作為二叉樹的儲存結構,在具有n個結點的二叉鏈表中n(n>0),空鏈域的個數為()
以二叉鏈表作為二叉樹的儲存結構,在具有n個結點的二叉鏈表中n(n>0),空鏈域的個數為n+1。
二叉鏈表結構描述:
typedef struct CSNode{
ElemType data;
struct CSNode *firstchild , *netsibling;
} CSNode,* CSTree;
由於二叉樹的存儲結構比較簡單,處理起來也比較方便,所以有時需要把復雜的樹,轉換為簡單的二叉樹後再作處理。
(2)二叉鏈表的存儲表示擴展閱讀:
二叉樹類型:
1、完全二叉樹——若設二叉樹的高度為h,除第 h 層外,其它各層 (1~h-1) 的結點數都達到最大個數,第h層有葉子結點,並且葉子結點都是從左到右依次排布,這就是完全二叉樹。
2、滿二叉樹——除了葉結點外每一個結點都有左右子葉且葉子結點都處在最底層的二叉樹。
3、平衡二叉樹——平衡二叉樹又被稱為AVL樹(區別於AVL演算法),它是一棵二叉排序樹,且具有以下性質:它是一棵空樹或它的左右兩個子樹的高度差的絕對值不超過1,並且左右兩個子樹都是一棵平衡二叉樹。
㈢ 若用二叉鏈表作為二叉樹的存儲表示,試針對以下問題編寫演算法:統計二叉樹終結點的個數
void CountLeaf (BiTree T, int& count)
{ //遞歸方法,
if ( T )
{
if ((!T->lchild)&& (!T->rchild))
count++;
CountLeaf( T->lchild, count); // 統計左子樹中葉子結點個數
CountLeaf( T->rchild, count); // 統計右子樹中葉子結點個數
}
}
----------
非遞歸,就是採用前序/中序/後序遍歷所有節點,並統計。下面就給你提供分別用三個函數的統計方法(PS:因為計數器定義為全局,所以三個函數不能同時使用,使用其中一個就能統計你要的節點數)。
#include "stdlib.h"
#define MAXNODE 20
#define ISIZE 8
#define NSIZE0 7
#define NSIZE1 8
#define NSIZE2 15
//SHOWCHAR = 1(顯示字元) SHOWCHAR = 0(顯示數字)
#define SHOWCHAR 1
//二叉樹結構體
struct BTNode
{
int data;
BTNode *rchild;
BTNode *lchild;
};
//非遞歸遍堆棧
struct ABTStack
{
BTNode *ptree;
ABTStack *link;
};
static pCounter = 0; //計數器,記錄節點個數
/*
前序遍歷函數pre_Order_Access()<非遞歸演算法>
參數描述:
BTNode *head: 根節點指針
*/
void pre_Order_Access(BTNode *head)
{
BTNode *pt;
ABTStack *ps,*top;
pt = head;
top = NULL;
printf("\n二叉樹的前序遍歷結果<非遞歸>:\t");
while(pt!=NULL ||top!=NULL) /*未遍歷完,或堆棧非空*/
{
while(pt!=NULL)
{
if(SHOWCHAR)
printf("%c ",pt->data); /*訪問根節點*/
else
printf("%d ",pt->data); /*訪問根節點*/
ps = (ABTStack *)malloc(sizeof(ABTStack)); /*根節點進棧*/
ps->ptree = pt;
ps->link = top;
top = ps;
pt = pt->lchild; /*遍歷節點右子樹,經過的節點依次進棧*/
pCounter++;
}
if(top!=NULL)
{
pt = top->ptree; /*棧頂節點出棧*/
ps = top;
top = top->link;
free(ps); /*釋放棧頂節點空間*/
pt = pt->rchild; /*遍歷節點右子樹*/
}
}
}
/*
中序遍歷函數mid_Order_Access()<非遞歸演算法>
參數描述:
BTNode *head: 根節點指針
*/
void mid_Order_Access(BTNode *head)
{
BTNode *pt;
ABTStack *ps,*top;
int counter =1;
pt = head;
top = NULL;
printf("\n二叉樹的中序遍歷結果<非遞歸>:\t");
while(pt!=NULL ||top!=NULL) /*未遍歷完,或堆棧非空*/
{
while(pt!=NULL)
{
ps = (ABTStack *)malloc(sizeof(ABTStack)); /*根節點進棧*/
ps->ptree = pt;
ps->link = top;
top = ps;
pt = pt->lchild; /*遍歷節點右子樹,經過的節點依次進棧*/
pCounter++;
}
if(top!=NULL)
{
pt = top->ptree; /*棧頂節點出棧*/
ps = top;
top = top->link;
free(ps); /*釋放棧頂節點空間*/
if(SHOWCHAR)
printf("%c ",pt->data); /*訪問根節點*/
else
printf("%d ",pt->data); /*訪問根節點*/
pt = pt->rchild; /*遍歷節點右子樹*/
}
}
}
/*
後序遍歷函數last_Order_Access()<非遞歸演算法>
參數描述:
BTNode *head: 根節點指針
*/
void last_Order_Access(BTNode *head)
{
BTNode *pt;
ABTStack *ps,*top;
int counter =1;
pt = head;
top = NULL;
printf("\n二叉樹的後序遍歷結果<非遞歸>:\t");
while(pt!=NULL ||top!=NULL) /*未遍歷完,或堆棧非空*/
{
while(pt!=NULL)
{
ps = (ABTStack *)malloc(sizeof(ABTStack)); /*根節點進棧*/
ps->ptree = pt;
ps->link = top;
top = ps;
pt = pt->lchild; /*遍歷節點右子樹,經過的節點依次進棧*/
pCounter++;
}
if(top!=NULL)
{
pt = top->ptree; /*棧頂節點出棧*/
ps = top;
top = top->link;
free(ps); /*釋放棧頂節點空間*/
printf("%c ",pt->data); /*訪問根節點*/
pt = pt->rchild; /*遍歷節點右子樹*/
}
}
}
㈣ 若用二叉鏈表作為二叉樹的存儲表示,試編寫演算法交換二叉樹中各結點的左右子樹
及層次順序遍歷二叉樹的演算法。
#define M 10
typedef int DataType;/*元素的數據類型*/
typedef struct node
{ DataType data;
struct node *lchild,*rchild;
}BitTNode,*BiTree;
int front=0,rear=0;
BitTNode *que[10];
BitTNode *creat()
{BitTNode *t;
DataType x;
scanf("%d",&x);
if(x==0) t=NULL;
else{ t=(BitTNode *)malloc(sizeof(BitTNode));
t->data=x;
t->lchild=creat();
t->rchild=creat();
}
return(t);
}/*creat*/
/* 前序遍歷二叉樹t */
void preorder(BiTree t)
{ if(t!=NULL)
{ printf("%4d",t->data);
preorder(t->lchild);
preorder(t->rchild);
}
}
/* 中序遍歷二叉樹t */
void inorder(BiTree t)
{ if(t!=NULL)
{ inorder(t->lchild);
printf("%4d",t->data);
inorder(t->rchild);
}
}
/* 後序遍歷二叉樹t */
void postorder(BiTree t)
{ if(t!=NULL)
{ postorder(t->lchild);
postorder(t->rchild);
printf("%4d",t->data);
}
}
void enqueue(BitTNode *t)
{if (front!=(rear+1)%M)
{ rear=(rear+1)%M;
que[rear]=t;
}
}/*enqueue*/
BitTNode * delqueue()
{ if(front==rear)return NULL;
{ front=(front+1)%M;
return (que[front]);
}
}/*delqueue*/
/* 按層次遍歷二叉樹t */
void levorder(BiTree t)
{ BitTNode *p;
if(t!=NULL)
{ enqueue(t);
while (front!=rear)
{ p=delqueue();
printf("%4d",p->data);
if(p->lchild!=NULL) enqueue(p->lchild);
if(p->rchild!=NULL) enqueue(p->rchild);
}
}
}/* levorder */
main()
{BitTNode *root;
root=creat();
printf("\n按先序遍歷次序生成的二叉樹");
printf("\n前序遍歷二叉樹");
preorder(root);
printf("\n中序遍歷二叉樹");
inorder(root);
printf("\n後序遍歷二叉樹");
postorder(root);
printf("\n層次順序遍歷二叉樹");
levorder(root);
}
2、以二叉鏈表作存儲結構,試編寫計算二叉樹深度、所有結點總數、葉子結點數、雙孩子結點個數、單孩子結點個數的演算法
#include <stdio.h>
#define MaxSize 100
typedef char ElemType;
typedef struct node
{
ElemType data;
struct node *left,*right;
} BTree;
BTree * createbt( )
{ BTree *q;
struct node1 *s[30];
int j,i,x;
printf("建立二叉樹,輸入結點對應的編號和值,編號和值之間用逗號隔開\n\n");
printf("i,x = ");
scanf("%d,%c",&i,&x);
while(i != 0 && x != '$')
{ q = (BTree*)malloc(sizeof(BTree)); /*建立一個新結點q*/
q->data = x; q->left = NULL; q->right = NULL;
s[i] = q; /*q新結點地址存入s指針數組中*/
if(i != 1) /*i = 1,對應的結點是根結點*/
{ j = i / 2; /*求雙親結點的編號j*/
if(i % 2 == 0)
s[j]->left = q; /*q結點編號為偶數則掛在雙親結點j的左邊*/
else
s[j]->right = q; /*q結點編號為奇數則掛在雙親結點j的右邊*/
}
printf("i,x = ");
scanf("%d,%c",&i,&x);
}
return s[1]; /*返回根結點地址*/
}
void preorder(BTree *BT)
/* 前序遍歷二叉樹t */
{ if(BT!=NULL)
{ printf("%4c", BT ->data);
preorder(BT ->left);
preorder(BT ->right);
}
}
int BTreeDepth(BTree *BT)
{
int leftdep,rightdep;
if (BT==NULL)
return(0);
else
{
leftdep=BTreeDepth(BT->left);
rightdep=BTreeDepth(BT->right);
if (leftdep>rightdep)
return(leftdep+1);
else
return(rightdep+1);
}
}
int nodecount(BTree *BT)
{
if (BT==NULL)
return(0);
else
return(nodecount(BT->left)+nodecount(BT->right)+1);
}
int leafcount(BTree *BT)
{
if (BT==NULL)
return(0);
else if (BT->left==NULL && BT->right==NULL)
return(1);
else
return(leafcount(BT->left)+leafcount(BT->right));
}
int notleafcount(BTree *BT)
{
if (BT==NULL)
return(0);
else if (BT->left==NULL && BT->right==NULL)
return(0);
else
return(notleafcount(BT->left)+notleafcount(BT->right)+1);
}
int onesoncount(BTree *BT)
{
if (BT==NULL)
return(0);
else if ((BT->left==NULL && BT->right!=NULL) ||
(BT->left!=NULL && BT->right==NULL))
return(onesoncount(BT->left)+onesoncount(BT->right)+1);
else
return(onesoncount(BT->left)+onesoncount(BT->right));
}
int twosoncount(BTree *BT)
{
if (BT==NULL)
return(0);
else if (BT->left==NULL || BT->right==NULL)
return(twosoncount(BT->left)+twosoncount(BT->right));
else if (BT->left!=NULL && BT->right!=NULL)
return(twosoncount(BT->left)+twosoncount(BT->right)+1);
}
main()
{
BTree *B;
B=creatree();
printf("\n按先序遍歷次序生成的二叉樹");
preorder(B);
printf("\n二叉樹深度:%d\n",BTreeDepth(B));
printf("總結點個數:%d\n",nodecount(B));
printf("葉子結點個數:%d\n",leafcount(B));
printf("非葉子結點個數:%d\n",notleafcount(B));
printf("具有雙孩子結點個數:%d\n",twosoncount(B));
printf("具有單孩子結點個數:%d\n",onesoncount(B));
}
如果還沒解決你的問題,可以加我網路HI賬號。
㈤ 用二叉鏈表存儲結構表示下圖所示二叉樹的,並用遞歸方法輸出三種遍歷結果。
//上機題3,已在VC下調試成功。
#include<stdio.h>
#include<malloc.h>
#define MAXSIZE 30
typedef struct bnode{
char data;
struct bnode *lchild,*rchild;
}Bnode,*BTree;
typedef BTree DataType;
typedef struct{
DataType data[MAXSIZE];
int top;
}SeqStack,*PseqStack;//定義一個線性表棧
PseqStack Init_SeqStack(void)
{
PseqStack S;
S=(PseqStack)malloc(sizeof(SeqStack));
if(S)
S->top=-1;
return(S);
}//初始化棧。
int Empty_SeqStack(PseqStack S)
{
if(S->top==-1)
return(1);
else return (0);
}//判斷是否棧空
int Push_SeqStack(PseqStack S,DataType x)
{
if(S->top==MAXSIZE-1)
return (0);
else
{
S->top++;
S->data[S->top]=x;
return (1);
}
}//入棧。
int Pop_SeqStack(PseqStack S,DataType *x)
{
if(Empty_SeqStack(S))
return (0);
else
{
*x=S->data[S->top];
S->top--;
return (1);
}
}//出棧。
BTree CreateBinTree(void)
{
BTree t;
char ch;
ch=getchar();
if(ch=='#') t=NULL;
else
{
t=(Bnode*)malloc(sizeof(Bnode));
t->data=ch;
t->lchild=CreateBinTree();
t->rchild=CreateBinTree();
}
return t;
}//創建一個二叉樹。
void Visit(BTree t)
{
if(t!=NULL)
printf("%c ",t->data);
}//訪問結點t。
void InOrder(BTree t)
{
if(t)
{
InOrder(t->lchild);
Visit(t);
InOrder(t->rchild);
}
}//二叉樹的遞歸中序遍歷。
int HighTree(BTree p)
{
int h1,h2;
if(p==NULL) return 0;
else
{
h1=HighTree(p->lchild);
h2=HighTree(p->rchild);
if(h1>h2) return (h1+1);
return (h2+1);
}
}//遞歸求二叉樹的高度。
void PreOrder(BTree t)
{
PseqStack S;
BTree p=t;
S=Init_SeqStack();
while(p||!Empty_SeqStack(S))
{
if(p)
{
Visit(p);
Push_SeqStack(S,p);
p=p->lchild;
}
else
{
Pop_SeqStack(S,&p);
p=p->rchild;
}
}
}//二叉樹的非遞歸先序遍歷。
void main()
{
BTree T;
int a;
printf("輸入二叉樹的先序排列(空的地方輸入#):");
T=CreateBinTree();
printf("輸出二叉樹的先序遍歷: ");
PreOrder(T);
printf("\n");
printf("輸出二叉樹的中序遍歷: ");
InOrder(T);
printf("\n");
a=HighTree(T);
printf("二叉樹的高度是: %d\n",a);
}
輸入是輸入12##346###5##
㈥ 二叉鏈表作存儲結構
//偶爾看到提問,翻了翻以前的課程設計,大部分功能類似...就直接復制上來啦,不知道能幫上忙不...都這么久了
//vc++ 6.0
#include "iostream.h"
#include "stdlib.h"
#include "stdio.h"
#define OK 1
#define NULL 0
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef char ElemType;//定義二叉樹結點值的類型為字元型
const int MaxLength=10;//結點個數不超過10個
typedef struct BTNode{
ElemType data;
struct BTNode *lchild,*rchild;
}BTNode,* BiTree;
void CreateBiTree(BiTree &T){//按先序次序輸入,構造二叉鏈表表示的二叉樹T,空格表示空樹
char ch;
ch=getchar(); //不能用cin來輸入,在cin中不能識別空格。
if(ch==' ') T=NULL;
else
{
if(!(T=(BTNode *)malloc(sizeof(BTNode)))) cout<<"malloc fail!";
T->data=ch;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
}
void PreOrderTraverse(BiTree T){//先序遍歷
if(T){
cout<<T->data<<' ';
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
}
void InOrderTraverse(BiTree T){ //中序遍歷
if(T){
InOrderTraverse(T->lchild);
cout<<T->data<<' ';
InOrderTraverse(T->rchild);
}
}
void PostOrderTraverse(BiTree T){ //後序遍歷
if(T){
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
cout<<T->data<<' ';
}
}
void LevelOrderTraverse(BiTree T){ //層序遍歷
BiTree Q[MaxLength];
int front=0,rear=0;
BiTree p;
if(T){ //根結點入隊
Q[rear]=T;
rear=(rear+1)%MaxLength;
}
while(front!=rear){
p=Q[front]; //隊頭元素出隊
front=(front+1)%MaxLength;
cout<<p->data<<' ';
if(p->lchild){ //左孩子不為空,入隊
Q[rear]=p->lchild;
rear=(rear+1)%MaxLength;
}
if(p->rchild){ //右孩子不為空,入隊
Q[rear]=p->rchild;
rear=(rear+1)%MaxLength;
}
}
}
int BTDepth(BiTree T){ //二叉樹的深度
if(!T) return 0;
else{
int h1=BTDepth(T->lchild);
int h2=BTDepth(T->rchild);
if(h1>h2) return h1+1;
else return h2+1;
}
}
int Leaf(BiTree T){ //二叉樹的葉子數
if(!T)
return 0;
else if(!T->lchild&&!T->rchild)
return 1;
else
return(Leaf(T->lchild)+Leaf(T->rchild));
}
int NodeCount(BiTree T){ //二叉樹的結點總數
if(!T)
return 0;
else
return NodeCount(T->lchild)+NodeCount(T->rchild)+1;
}
int Initbitree (BiTree T) //空樹
{
T=NULL;
return FALSE;
}
int Isempty(BiTree T) //判斷為空否
{
if(T!=NULL)
return FALSE;
else
return TRUE;
}
int Destroy (BiTree &T) //銷毀
{
if( T != NULL )
{ if(T->lchild!=NULL)
Destroy ( T->lchild );
if(T->rchild!=NULL)
Destroy ( T->rchild );
free(T);
T=NULL;
}
return 1;
}
char Root(BiTree T) //返回根節點
{
if(T==NULL)
return NULL;
else
return T->data;
}
ElemType Value(BiTree &p)
{//返回P所指結點的值
return p->data;
}
ElemType Assign(BiTree p,ElemType value)
{ //給P的結點賦新值
return p->data=value;
}
BiTree Parent(BiTree T, BiTree p)//返回父節點
{
if(T!=NULL)
{
if(T->lchild->data==p->data)
{return T;}
if(T->rchild->data==p->data)
return T;
if(T->lchild)
return Parent(T->lchild,p);
if(T->rchild)
return Parent(T->rchild,p);
}
else return NULL;
}
char LeftChild(BiTree p) //返回p的左孩子的值
{
if(p->lchild) //若p存在左孩子
return p->lchild->data;
if(p->lchild==NULL)
return NULL;
}
char RightChild(BiTree p) // 返回p的右孩子的值
{
if(p->rchild)
return p->rchild->data;
if(p->rchild==NULL)
return NULL;
}
int Deletelchild(BiTree p) //刪除此二叉樹中p節點的左子樹
{
if(p)
{
Destroy(p->lchild);
return OK;
}
return ERROR;
}
int Deleterchild(BiTree p) //刪除此二叉樹中p節點的右子樹
{
if(p)
{
Destroy(p->rchild);
return OK;
}
return ERROR;
}
void search(BiTree T,char h,BiTree &p)//查詢節點
{
if(T==NULL)
return ;
else{
if(T->data==h)p=T;
search(T->lchild,h,p);
search(T->rchild,h,p);
}
}
void main()
{
BiTree T;
BiTree p;
BiTree q;
char ch;
T=NULL;
int select;
while(1){
cout<<"\n\n";
cout<<"**********************************\n";
cout<<"1.創建二叉樹\n";
cout<<"2.前序遞歸遍歷序列\n";
cout<<" 中序遞歸遍歷序列\n";
cout<<" 後序遞歸遍歷序列\n";
cout<<"3.層次遍歷序列\n";
cout<<"4.二叉樹的深度\n";
cout<<"5.葉子結點數目\n";
cout<<"6.求結點總數目\n";
cout<<"7.返回樹根節點\n";
cout<<"8.返回節點p的左孩子\n";
cout<<" 返回節點p的右孩子\n";
cout<<" 返回節點p的 雙親\n";
cout<<"9.判斷是否為空(是返回1,否返回0)\n";
cout<<"10.刪除p節點的左子樹\n";
cout<<"11.刪除p節點的右子樹\n";
cout<<"12.銷毀樹!\n";
cout<<"0.退出\n";
cout<<"**********************************\n";
cout<<"\n請選擇要執行的操作(選擇數字0-12):";
cin>>select;
switch(select){
case 0:
cout<<"退出!";
return;
case 1:
cout<<"請按先序次序輸入各結點的值,以空格表示空節點:"<<endl;
CreateBiTree(T);
cout<<"成功!";
break;
case 2:
if(!T) cout<<"未建立樹,請先建樹!";
else{
cout<<"\n先序遍歷:\n";
PreOrderTraverse(T);
cout<<"\n中序遍歷:\n";
InOrderTraverse(T);
cout<<"\n後序遍歷:\n";
PostOrderTraverse(T);
}
break;
case 3:
if(!T) cout<<"未建立樹,請先建樹!";
else{
cout<<"\n層序遍歷:\n";
LevelOrderTraverse(T);
}
break;
case 4:
cout<<"二叉樹的深度為:\n";
cout<<BTDepth(T);
break;
case 5:
cout<<"\n葉子節點數:\n";
cout<<Leaf(T);
break;
case 6:
cout<<"總節點數:\n";
cout<<NodeCount(T);
break;
case 7:
cout<<"返回根節點:"<<Root(T);
break;
case 8:
cout<<"\n請輸入要查詢的節點p值:";
cin>>ch;
search(T,ch,p);
cout<<ch<<"的左孩子是:"<<LeftChild(p)<<endl;
cout<<ch<<"的右孩子是:"<<RightChild(p)<<endl;
q=Parent(T,p);
cout<<ch<<"的父親是:"<<Value(q)<<endl;
break;
case 9:
cout<<"判斷是否為空(是為1,否為0:)"<<Isempty(T);
break;
case 10:
cout<<"\n請輸入節點p值:";
cin>>ch;
search(T,ch,p);
cout<<Deletelchild( p);
cout<<"刪除了"<<ch<<"的左孩子";
break;
case 11:
cout<<"\n請輸入節點p值:";
cin>>ch;
search(T,ch,p);
cout<<Deleterchild( p);
cout<<"刪除了"<<ch<<"的右孩子";
break;
case 12:
cout<<"銷毀樹!"<<Destroy(T);
break;
default:
cout<<"請確認選擇項為數字1-12!\n";
}
}
}
㈦ 二叉樹的順序存儲方式
二叉樹按照層序遍歷,依次編號,按照編號的順序,存儲在連續存儲單元的方式就是二叉樹的順序存儲。
㈧ 二叉樹的存儲結構是怎樣的有哪些類型的存儲結構對應的c語言描述是
線性表的鏈式存儲結構:
typedef
int
elemtype;
typedef
struct
lnode
{
elemtype
data;
struct
lnode
*next;
}lnode,*linklist;
(被封裝好的每個節點,都有一個數據域data和一個指針域*next用於指向下一個節點)
二叉樹的二叉鏈表:
typedef
int
telemtype;
typedef
struct
bitnode
{
telemtype
data;
struct
bitnode
*lchild,*rchild;
}bitnode,*bitree;
(被封裝好的每個節點,都有一個數據域data和兩個指針域
*lchild,*rchild分別指向左右子樹)
需要什麼類型的數據作為數據域可更改,或者typedef
int
elemtype;和typedef
int
telemtype;中的int,比如改為char、float等或者自定義數據類型。
㈨ 簡述二叉鏈表的類型定義
二叉鏈表是樹的二叉鏈表實現方式。
樹的二叉鏈表實現方式
(孩子兄弟表示法)
以二叉鏈表作為樹的存儲結構。鏈表中結點的兩個鏈域分別指向該結點的第一個孩子結點和它的下一個兄弟結點。
typedefstruct
CSNode{
ElemType
data;
struct
CSNode
*firstchild
,
*netsibling;
}
CSNode,*
CSTree;
由於二叉樹的存儲結構比較簡單,處理起來也比較方便,所以有時需要把復雜的樹,轉換為簡單的二叉樹後再作處理。