二叉树算法

写在前面

树的定义

typedef struct Node
{
    int data;
    struct Node *lchild,*rchild;
}Bnode,*Btree;

---

最近公共祖先

已知一棵二叉树按顺序存储结构进行存储，设计一个算法，求编号分别为i和j的两个节点的最近公共祖先节点的值。

算法思想：

1. 顺序存储采用数组进行存储。
2. i的祖先就是i/2
3. 不断比较i和j的大小，将最大的数取一半，直到i=j，就是找到了最近公共祖先节点。
   

int FindAncestor(int T[],int i,int j)
{
	if(T[i]!=NULL && T[j]!=NULL)
	{
		while(i!=j)
		{
			if(i>j) i=i/2;
			else  j=j/2;
		}
		return i;
	}
	return -1;
}

二叉树的层次遍历

算法思想：

1. 用队列将根节点入队
2. 出队，访问出队节点
3. 若有左子树，将左子树入队
4. 若有右子树，将右子树入队
5. 循环234，直到队列为空

//伪代码
void LevelOrder(Btree T)
{
	InitQueue(Q);
	Btree p;
	EnQueue(Q,T);
	while(!IsEmpty(Q)
	{
		DeQueue(Q,p);
		visit(p);
		if(p->lchild!=NULL)
			EnQueue(Q,p->lchild);
		if(p->rchild!=NULL)
			EnQueue(Q,p->rchild);
	}
}

void LayerOrder(BTree t)
{
    int front=0,rear=0;
    BTree ind[100];
    ind[rear++]=t;
    while(front<rear)
    {
        cout<<ind[front++]->data;//取出并输出顶部元素
        if(t->lchild!=NULL){
            ind[rear++]=t->lchild;
        }
        if(t->rchild!=NULL){
            ind[rear++]=t->rchild;
        }
    }
}

二叉树的高度

算法思想：

1. 后序遍历，递归公式：树高=max(左子树高度, 右子树高度)+1
2. 非递归：采用层次遍历，用类指针last指向每层最后边节点，用变量level记录层数，last每向下一层level+1
   递归

int Btdepth(Btree T)
{
	if(T==NULL) return 0;
	int l=Btdepth(T->lchild);
	int r=Btdepth(T->rchild);
	return (l>r ? l:r)+1
}

非递归

int Btdepth_f(Btree T)
{
	if(T==NULL)return 0;
	Btree Q[Maxsize];//队列
	int front=-1,rear=-1;
	int last=0,level=0;//last记录每层最后边节点
	Btree p;
	while(front<rear)
	{
		p=Q[++front];
		if(p->lchild)
			Q[++rear]=p->lchild;
		if(p->rchild]
			Q[++rear]=p->rchild;
		if(front==last)
		{
			level++;
			last=rear;
		}
	}
	return level;
}

是否为平衡二叉树

算法思想：

1. 左右子树高度差是否超过1

int isBlance(Btree T)
{
	if(T==NULL) return 0;
	int l=Btdepth(T->lchild);
	int r=Btdepth(T->rchild);
	int dis=abs(l-r);
	if(dis>1)return 0;
	else return isBlance(T->lchild)*isBlance(T->rchild); 
}

二叉树所有左右子树交换

算法思想：

1. 递归:后序遍历时候交换左右子树（也可前序遍历）

void Bswap(Btree T)
{
	if(T)
	{
		Bswap(T->lchild);
		Bswap(T->rchild);
		Btree temp=T->lchild;
		T->lchild=T->rchild;
		T->rchild=temp;
	}
}

二叉树度为2节点个数

算法思想：

1. 递归：树双节点=左子树双节点+右子树双节点+1（左右子树都存在）
2. 树双节点=左子树双节点+右子树双节点（左右有任意不存在）

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

二叉树所有节点个数

算法思想：

1. 递归：节点数=左子树节点+右子树节点+1；
2. 递归：前中后续遍历

int countT(Btree T)
{
	if(T==NULL)return 0;
	return countT(T->lchild)+countT(T->rchild);
}

int n=0;
void PreOrder(Btree T)
{
	if(p)
	{
		PreOrder(T->lchild);
		PreOrder(T->rchild);
		n++;
	}
}

二叉树所有叶子节点个数

算法思想：

1. f=左子树叶子节点+右子树叶子节点

int count(Btree T)
{
	if(T==NULL)return 0;
	if(T->lchild==T->rchild==NULL) return 1;
	return count(T->lchild)+count(T->rchild);
}

二叉树值为x节点所在层

算法思想：

1. 前序遍历，本层结点高h，到左子树h+1，从右子树回到上一层h-1

int h=1;
void Find(Btree T,int x)
{
	if(T)
	{
		if(T->data==x)
			print("%d",h);
		h++;
		Find(T->lchild,x);
		Find(T->rchild,x);
		h--;
	}
}

对称二叉树

判断一个二叉树是否对称。

算法思想：

1. 后续遍历

int compare(Btree l,Btree r)
{
	//判断本层是否相等
	if(l==NULL && r!=NULL)return 0;//左空，右不空，不等
	if(l!=NULL && r==NULL)return 0;//左不空，右空，不等
	if(l==NULL && r==NULL)return 1;//左空，右空，相等
	if(l->data != r->data)return 0;//左右值不等，不等
	//若相等进入下一层判断
	int outside=compare(l->lchild,r->rchild);//比较当前左节点的左孩子和右节点的右孩子，即为最外层比较
	int inside=compare(l->rchild,r->lchild);//比较当前左节点的右孩子和右节点的左孩子，即为内层比较
	int res=outside*inside;//内外是否同时相等
	return res;
}