代码整理3.0 树

结构体定义

typedef struct BiTree
{
	ElemType data;
	struct BiTree *next;
}BiTree;

typedef struct BTNode
{
	int data;
	struct BTNode *lchild;
	struct BTNode *rchild;
}BTNode;

自下而上、自左至右层次遍历
设置队列和栈，根节点入队，队列不空时Q出队，出队元素入栈S，其左右非空子女入队，队列空后，弹出栈S

void level(BiTree *T)
{
	BiTree Q[MAXSIZE];
	int front=-1,rear=-1;
	BiTree S[MAXSIZE];
	int top=-1;
	Q[++rear]=T;
	while(front!=rear)
	{
		p=S.[++front];
		S[++top]=p;
		if(p->lchild)
			Q[++rear]=p->lchild;
		if(p->rchild)
			Q[++rear]=p->rchild;
	}
	while(top!=-1)
	{
		q=S[top--];
	}
}

将二叉树中所有左右子树相互交换
设置栈 根节点入栈 只要栈不为空：出栈栈顶元素，如果出栈元素不是叶子节点 则利用中间变量进行交换 如果左孩子不空，左孩子入栈，右孩子不空，右孩子入栈

void swap(BiTree &T)
{
	BiTree *p;
	if(T)
	{
		swap(T->lchild);
		swap(T->rchild);
		p=T->lchild;
		T->lchild=T->rchild;
		T->rchild=p;
	}
}

void swap(BiTree T)
{
	BiTree S[MAXSIZE];
	int top=-1;
	S[++top]=T;
	while(top!=-1)
	{
		p=S[top--];//出栈栈顶元素
		if(p->lchild||p->rchild)//非叶子节点 交换左右子树
		{
			q=p=>lchild;
			p->lchild=p->rchild;
			p->rchild=q;
			}
		if(p->lchild) //左孩子入栈
			s[++top]=p->lchild;
		if(p->rchild) //右孩子入栈
			s[++top]=p->rchild;
	}
	
}

求二叉树深度

int getdepth(BTNode T)
{
	int depth,depthl,depthr;
	if(T==NULL)
		depth=0;
	else
	{
		depthl=getdepth(T->lchild);
		depthr=getdepth(T->rchild);
		depth=1+(depthl>depthr?depthl:depthr);	
	}
	return depth;
}

非递归求二叉树深度
设置队列 设置last指向下一层(初始化为0) 设置level(初始化为0) 根节点入队 只要队列不空：队头元素出队 如果出队元素左孩子不空左孩子入队 右孩子不空右孩子入队 如果(front==last)则 level++,last=rear;

int depth(BTNode T)
{
	if(!T)
		return 0;
	int front=-1;//指向队头元素
	int rear=-1;//rear指向队尾元素
	int last=0;//指向下一层 当出队到last时 表示last所在层数被访问到
	int level=0;
	BTNode Q[maxsize];
	Q[++rear]=T；
	BTNode p;
	while(front!=rear)//队列不空
	{	
		p=Q[++front];//队头元素出队
		if(p->lchild)
			Q[++rear]=Q->lchild;
		if(p->rchild)
			Q[++rear]=Q->rchild;//
		if(front==last)//该层最后一个节点出队后level+1
		{
			level++;
			last=rear;//last指向该层最后一个节点  
		}				
	}	
}

孩子兄弟表示法求树的高度
树为空高度为0，孩子节点为空 高度为最大兄弟子树的高度+1
否则高度为max{1+孩子子树高度，兄弟子树高度}

typdef struct
{
	int data;
	BTNode *child;
	BTNode *sibling;
}BTNode;

void height(BTNode *bt)
{
	if(bt==NULL)
		 return 0;
	else if(!bt->child)
		return max(1,height(bt->sibling));
	else
	{
		hc=height(bt->child);
		hs=height(bt->sibling);
		if(hc+1>hs)
			return hc+1;
		else return hs;
}
}

求二叉树宽度

typedef struct
{
	BTNode data[maxsize];
	int level[maxsize];//保存data中相同下标结点的层次
	int front,rear;
}Qu;
int getWidth(BTNode b)
{
	BTNode p;
	int k,max,i,n;
	Qu.front=Qu.rear=-1;//队列置空
	Qu.data[Qu.rear]=b;//根节点入队
	Qu.level[Qu,rear]=1;//根节点所在层次为1
	while(Qu.front<Qu.rear)//队不空
	{
		p=Qu.data[++Qu.front];//出队
		k=Qu.level[Qu.front];//出队节点所在层次
		if(p->lchild!=NULL)
		{
			Qu.data[++Qu.rear]=p->lchild;//下一层节点入队
			Qu.level[Qu.rear]=k+1;//尾结点所在层次加1
		}
		if(p->rchild!=NULL)
		{
			Qu.data[++Qu.rear]=p->rchild;
			Qu.level[Qu.rear]=k+1;
		}
	}
	max=0;//保存同一层最多的结点个数
	i=0;//i扫描队中所有元素
	k=1;//从第一层开始找
	while(i<=Qu.rear)
	{
		n=0;
		while(i<=Qu.rear&&Qu.level[i]==k)
		{
			n++;
			i++;
		}
		k=Qu.level[i];
		if(n>max)
			max=n;
	}
	return max;
}

求结点个数

int sum=0;
void count(BTNode *p)
{
	
	if(p!=NULL)
	{
		++sum;
		count(p->lchild);
		count(p->rchild);
	}	
	return sum;
}

统计二叉树中度为1的结点个数

int One(BiTree *T)
{
	if(T==NULL)
		return 0;
	if(T->lchild!=NULL&&T->rchild==NULL
	   ||T->lchild==NULL&&T->rchild!=NULL)
	//当前结点度为1 则总数加1
		return 1+One(T->lchild)+One(T->rchild);
	return One(T->lchild)+One(T->rchild);//当前结点度不为1
}

统计二叉树中度为2的结点个数

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

求双亲表示法求二叉树叶子节点个数

typedef struct BTNode
{
	int data;
	struct BTNode *lchild;
	strcut BTNode *rchild;
}BTNode;

int count(BTNode *bt)
{
	int count=0;
	if(bt==NULL)
		return 0;
	else if(bt->lchild==NULL&&bt->rchild==NULL)
		count=1;
	else
	{
		return count(bt->lchild)+count(bt->rchild);
	}
	return count;
}

孩子兄弟表示法求树的叶子节点个数

typedef struct BTNode
{
	int data;
	struct BTNode *ch;
	struct BTNode *sbl;
}BTNode;
int leaf(BTNode *T)
{
	if(T==NULL)
		return 0;
	if(T->ch==NULL)
		return 1+leaf(T->sbl);
	else
		return leaf(T->ch)+leaf(T->sbl);
}