二叉樹相關操作的算法總結

1.二叉樹的順序存儲

#define MAXSIZE 100				//二叉樹的最大結點數
typedef TElemType SqBiTree[MAXSIZE]; //0號單元存儲根結點
SqBiTree bt;

2.二叉樹的鏈式存儲結構

typedef struct BiTNode
{
	TElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

3.二叉樹的先序遍歷

void PreOrderTraverse(BiTree T)
{
	if(T)
	{
		cout << T->data;			//訪問根結點
		PreOrderTraverse(T->lchild);//遞歸遍歷左子樹
		PreOrderTraverse(T->rchild);//遞歸遍歷右子樹
	}
}

4.二叉樹的中序遍歷

void InOrderTraverse(BiTree T)
{
	if(T)
	{
		InOrderTraverse(T->lchild); //遞歸遍歷左子樹
		cout << T->data;			//訪問根結點
		InOrderTraverse(T->rchild); //遞歸遍歷右子樹
	}
}

5.二叉樹的後序遍歷

void PostOrderTraverse(BiTree T)
{
	if(T)
	{
		PosTOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
		cout << T->data;
	}
}

6.二叉樹的非遞歸遍歷

void InOrderTraverse(BiTree T)
{
	InitStack(S);			//初始化棧
	p = T;
	BiTree q;
	while(p || !StackEmpty(S))
	{
		if(p)
		{
			Push(S,p);
			p = p->lchild;  //根指針入棧，遍歷左子樹
		}
		else
		{
			Pop(S,q);		//出棧
			cout << q->data;//訪問根結點
			p = p->rchild;  //遍歷右子樹
		}
	}
}

7.利用先序遍歷算法創建二叉樹

//按先序次序輸入二叉樹中結點的值，創建二叉鏈表表示的二叉樹
void CreateBiTree(BiTree &T)
{
	char ch;
	cin >> ch;
	if(ch == '#')
		T = NULL;			//遞歸結束，建空樹
	else
	{
		T = new BiTNode;
		T->data = ch;		//生成根結點
		CreateBiTree(T->lchild);	//遞歸創建左子樹
		CreateBiTree(T->rchild);	//遞歸創建右子樹
	}
}

8.計算二叉樹結點個數

int NodeCount(BiTree T)
{
	if(T == NULL)
		return 0;
	else
		return NodeCount(T->lchild)+NodeCount(T->rchild)+1;
}

9.計算二叉樹中葉子結點個數

int LeafCount(BiTree T)
{
	if(T == NULL)
		return 0;
	if(T->lchild==NULL && T->rchild==NULL)
		return 1;
	else
		return LeafCount(T->lchild)+LeafCount(T->rchild);
}

10.計算二叉樹的深度

int Depth(BiTree T)
{
	if(T == NULL)
		return 0;
	else
	{
		m = Depth(T->lchild);
		n = Depth(T->rchild);
		if(m > n)
			return m+1;
		else 
			return n+1;
	}
}

11.線索二叉樹的結點定義

typedef struct BiThrNode
{
	TElemType data;
	struct BiThrNode *lchild,*rchild;
	unsigned char LTag,RTag;
}BiThrNode,*BiThrTree;

12.以結點p爲根結點的子樹中序線索化

//pre是全局變量,初始化時其右孩子指針爲空
void InThreading (BiThrTree p)
{ 
	if (p)
	{   
		InThreading( p->lchild );  // 左子樹線索化
        if ( !p->lchild ) 
        { 
        	p->LTag=1;
            p->lchild=pre;
        } // 前驅線索
        if ( !pre->rchild )
        { 
        	pre->RTag=1; 
        	pre->rchild=p; 
        } //後繼線索
        pre = p;                     // 保持pre指向p的前驅
        InThreading(p->rchild);      //右子樹線索化
	}
}

//中序遍歷二叉樹T,並將其中序線索化, Thrt 指向頭結點.
void InorderThreading(BiThrTree  & Thrt, BiThrTree  T)
{ 
	Thrt =new BiThrNode; // 建頭結點
	Thrt ->LTag = 0; 
	Thrt ->RTag = 1;   
	Thrt ->rchild = Thrt; //右指針回指
	if(!T) 
		Thrt ->lchild = Thrt;    // 若二叉樹空,則左指針回指
	else 
	{
		Thrt ->lchild = T;     
		pre = Thrt; //將頭結點與樹相連
		InThreading(T);          // 中序遍歷進行中序線索化
		pre ->rchild = Thrt;   
		pre ->RTag = 1;     //最後一個結點線索化
		Thrt ->rchild = pre;
	}
}

13.遍歷中序線索二叉樹

//T指向頭結點，頭結點的左鏈lchild指向樹的根結點
void InOrderTraverse_Thr(BiThrTree T)
{
	p = T->lchild;   //從頭結點進入到根結點；
	// 空樹或遍歷結束時，p==T
	while(p != T)           
	{  
		//先找到中序遍歷起點
		while(p->LTag == 0)  
			p = p->lchild;  
		cout << p->data;  //訪問左子樹爲空的結點
		//p->rchild=T即爲最後一個結點
		while(p->RTag==1 && p->rchild!=T)
		{
			p = p->rchild; 
			cout << p->data;
		}
		p = p->rchild; 
	}
}

14.樹的孩子兄弟存儲表示

typedef struct CSNode
{
	ElemType data;
	struct CSNode *firstson,*nextsibling;
}CSNode,*CSTree;

15.哈夫曼樹的存儲表示

typedef struct
{
	int weight;
	int parent,lchild,rchild;
}HTNode,*HuffmanTree;