二叉树相关操作的算法总结

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;