数据结构代码练习06-CSDN博客

本文链接：https://blog.csdn.net/m0_71844907/article/details/135622545

关于树相关操作

typedef struct BTNode{
	char data;
	struct BTNode *lchild,*rchild;
}BTNode,*BiTree;

//
//计算二叉树中所有节点个数
//法一
int count(BTNode *p){
	int n1,n2;
	if(p==NULL)
		return 0;
	else{
		n1=count(p->lchild);
		n2=count(p->rchild);
		return n1+n2+1;
	}
} 
//法二 
void count2(BTNode *p,int &n){
	if(p!=NULL){
		++n;
		count2(p->lchild,n);
		count2(p->rchild,n);
	} 
}

//
// 计算二叉树中所有叶子节点的个数
//法一
int count(BTNode *p){
	int n1,n2;
	if(p==NULL)
		return 0;
	if(!p->lchild&&!p->rchild)
		return 1;
	else{
		n1=count(p->lchild);
		n2=count(p->rchild);
		return n1+n2;
	}
} 
//法二 
void count2(BTNode *p,int &n){
	if(p!=NULL){
		if(p->lchild==NULL&&p->rchild==NULL){
			++n;
			count2(p->lchild,n);
			count2(p->rchild,n);
		}
	}
}

//
//计算二叉树中所有双分支的节点个数
int count(BTNode *p){
	int n1,n2;
	if(p==NULL){
		return 0;
	} 
	if(p->lchid&&p->rchild){
		n1=count(p->lchild);
		n2=count(p->rchild);
		return n1+n2+1;
	}
	else{
		n1=count(p->lchild);
		n2=count(p->rchild);
		return n1+n2;
	}
} 

//
//计算二叉树深度
//法一
int getDepth(BTNode *p){
	int LD,RD;
	if(p==NULL)
		return 0;
	else{
		LD=getDepth(p->lchild);
		RD=getDepth(p->rchild);
		return(LD>RD?LD:RD)+1;
	}
}
//法二 
void getDepth2(BTNode *p,int &n,int &max){
	if(p!=NULL){
		++n;
		if(n>=max)
			max=n;
		getDepth2(p->lchild,n,max);
		getDepth2(p->rchild,n,max);
		--n;
	}
}

//
//找出二叉树中最大值的点
void Max(BTNode *p,int &max){
	if(p!=NULL){
		if(p->data > max)
			max=p->data;
		Max(p->lchild,max);
		Max(p->rchild,max);
	}
} 

//
//判断两个二叉树是否相似
//指都为空或者只有一个根节点，或左右子树都相似
int fun(BTNode *T1,BTNode *T2){
	int left,right;
	if(T1==NULL&&T2==NULL)
		return 1;
	if(T1==NULL||T2==NULL)
		return 0;
	else{
		left=fun(T1->lchild,T2->rchild);
		right=fun(T1->rchild,T2->lchild);
		return left&right; 
	}
} 

//
//把二叉树中所有结点左右子树交换
void swap(BTNode *p){
	if(p!=NULL){
		swap(p->lchild);
		swap(p->rchild);
		BTNode *temp=p->lchild;
		p->lchild=p->rchild;
		p->rchild=temp;
	}
} 

//
//查找二叉树中data域等于key的结点是否存在，若存在，将q指向它，否则q为空
void fun(BTNode *p,BTNode *&q,int key){
	if(p!=NULl){
		if(p->data==key){
			q=p;
		}
		else{
			fun(p->lchild,q,key);
			fun(p->rchild,q,key);
		}
	}
} 

//
//输出先序遍历第k个结点的值
void trave(BTNode *p,int k,int &n){
	if(p!=NULL){
		++n;
		if(k==n){
			printf("%d",p->data);
			return;
		} 
		trave(p->lchild,k,n);
		trave(p->rchild,k,n);
	}
} 

//
//求二叉树中值为x的层号
void fun(BTNode *p,char x,int L){
	if(p!=NULL){
		if(p->data==x)
			printf("所在层数为：%d",L);
		fun(p->lchild,x,L+1);
		fun(p->rchild,x,L+1); 
	}
} 
 
//
//树中元素为x的结点，删除以它为根的子树
void del(BTNode *&bt,char x){
	if(bt!=NULl) {
		if(bt->data==x){
			bt=NULL;
			return; 
		}
		del(bt->lchild,x);
		del(bt->rchild,x);
		return;
	}
}
 
//
//利用结点的右孩子指针将一个二叉树的叶子结点从左向右连接成一个单链表
void link(BTNode *p,BTNode *&head,BTNode *&tail){
	if(p!=NULL){
		if(!p->lchild&&!p->rchild){
			if(head==NULL){
				head=p;
				tail=p;
			}
			else{
				tail->rchild=p;
				tail=p;
			}
		}
		link(p->lchild,head,tail);
		link(p->rchild,head,tail);
	}
} 

//
//输出根节点到每个叶子结点的路径
void allpath(BTNode *p,char pathstack[],int top){
	if(p!=NULL){
		pathstack[top]=p->data;
		if(!p->lchild&&!p->rchild)
			for(int i=0;i<=top;++i)
				count<<pathstack[i]<<" ";
	count<<end1;
	allpath(p->lchild,pathstack,top+1);
	allpath(p->rchild,pathstack,top+1);
	}
} 

//
//已知满二叉树先序序列存于数组中，设计算法将其变成后序序列
void change(char pre[],int L1,int R1,char post[],int L2,int R2){
	if(L1<=R1){
		post[R2]=pre[L1];
		change(pre,L1+1,(L1+R1+1)/2,post,L2,(L2+R2-1)/2);
		change(pre,(L1+R1+1)/2,R1,post,(L2+R2-1)/2,R2-1);
	}
} 

//
//先序和中序遍历分别存在两个一维数组AB中，试着建立二叉链表
BiTree create(char A[],char B[],int L1,int R1,int L2,int R2){
	BTNode *root=new BTNode;
	root->data=A[L1];
	int i;
	for(i=L2;B[i]!=root->data;i++)
	if(i>L2)
		root->lchild=crate(A,B,L1+1,i-L2+L1,L2,i-1);
	else
		root->lchild=NULL;
	if(i<R2)
		root->rchild=crate(A,B,i-L2+L1,R1,i+1,R2);
	else
		root->rchild=NULL;
	return root;
} 

//
//二叉树以顺序表方式存在于数组A中，设计算法以二叉链表表示
BiTree create(char A[,int i,int n]){
	if(i<n){
		BTNode *t=new BTNode;
		t->data=A[i];
		t->lchild=create(A,2*i+1,n);
		t->rchild=create(A,2*i+2,n);
		return t;	
	}
	return NULL;
}


//
//增加了一个指向双亲结点的parent指针，输出所有节点到根节点的路径 
void fun(BTNode *p,BTNode *q){
	if(p!=NULL){
		p->parent=q;
		q=p;
		fun(p->lchild,q);
		fun(p->rchild,q);
	}
}
void printpath(BTNode *p){
	while(p!=NULL){
		printf("%d",p->data);
		p=p->parent;
	} 
}
void allpath(BTNode *p){
	if(p!=NULL){
		printpath(p);
		allpath(p->lchild);
		allpath(p->rchild);
	}
}

//
//先序非递归遍历二叉树
//法一
void Nonpre(BTNode *bt){
	BTNode *Stack[maxsize];
	int top=-1;
	if(bt!=NULL){
		Stack[++top]=bt;
		while(top!=-1){
			bt=Stack[top--];
			printf("%d",p->data);
			if(bt->rchild!=NULL)
				Stack[++top]=bt->rchild;
			if(bt->lchild!=NULL)
				Stack[++top]=bt->lchild;
		}
	}
} 
//法二 
void Nonpre2(BTNode *bt){
	BTNode *Stack[maxsize];
	int top=-1;
	while(bt||top!=-1){
		if(bt!=NULL){
			printf("%d",bt->data);
			Stack[++top]=bt;
			bt=bt->lchild; 
		}
		else{
			bt=Stack[top--];
			bt=bt->rchild;
		}
	}
}

//
//中序非递归遍历二叉树
void NOnin(BTNode *bt){
	BTNode *Stack[maxsize];
	int top=-1;
	while(top!=-1||bt){
		if(bt!=NULL){
			Stack[++top]=bt;
			bt=bt->lchild;
		}
		else{
			bt=Stack[top--];
			printf("%d",bt->data);
			bt=bt->rchild;
		}
	}
} 

//
//后序非递归遍历二叉树
//法一 
void Nonpost(BTNode *bt){
	BTNode *St[maxsize],*tag=NULL;
	int top=-1;
	while(bt||top!=-1){
		if(bt!=NULL){
			St[++top]=bt;
			bt=bt->lchild;
		}
		else{
			bt=St[top];
			if(bt->rchild&&bt->rchild!=tag)
				bt=bt->rchild;
			else{
				bt=St[top--];
				printf("%d",bt->data);
				tag=bt;
				bt=NULL;
			}
		}
	}
}
//法二 
void Nonpost2(BTNode *bt){
	if(bt!=NULL){
		BTNode *Stack1[maxsize];
		BTNode *Stack2[maxsize];
		int top1=-1,top2=-1;
		Stack[++top1]=bt;
		while(top1!=-1){
			bt=Stack1[top1--];
			Stack2[++top2]=bt;
			if(bt->lchild=NULL)
				Stack1[++top1]=bt->lchild;
			if(bt->rchild=NULL)
				Stack1[++top1]=bt->rchild;
		}
		while(top2!=-1){
			bt=Stack2[top2--];
			printf("%d",bt->data);
		}
	}
	
}

//
//在二叉树中查找值为x的结点，打印出值为x的所有祖先
void Nonpost(BTNode *bt,char x){
	BTNode *St[maxsize],*tag=NULL;
	int top=-1;
	while(bt||top!=-1){
		if(bt!=NULL){
			St[++top]=bt;
			bt=bt->lchild;
		}
		else{
			bt=Stack[top];
			if(bt->rchild&&bt->rchild!=tag){
				bt=bt->rchild;
			}
			else{
				bt=St[top--];
				if(bt->data==x)
					while(top!=-1)
						printf("%d",St[top--]->data);
				tag=bt;
				bt=NULL; 
			}
		}
	}
} 

//
//层次遍历
void level(BTNode *p){
	int front=0,rear=0;
	BTNode *que[maxsize];
	if(p!=NULL){
		que[++rear]=p;
		while(front!=rear){
			p=que[++front];
			printf("%d",p->data);
			if(p->lchild!=NULL)
				que[++rear]=p->lchild;
			if(p->rchild!=NULL)
				que[++rear]=p->rchild;	
		}
	}
} 

//
//试给出自下而上从右到左的层级遍历
void level(BTNode *p){
	BTNode *stack[maxsize];
	int top=-1;
	int front=0,rear=0;
	BTNode *que[maxsize];
	if(p!=NULL){
		que[++rear]=p;
		while(front!=rear){
			p=que[++front];
			stack[++top]=p;
			if(p->lchild!=NULl)
				que[++rear]=p->lchild;
			if(p->rchild!=NULl)
				que[++rear]=p->rchild; 
		}
	}
	for(int i=top;i>-1;--i)
		printf("%d",stack[i]->data);
} 

//
//用层次遍历求解二叉树的高度
int depth(BTNode *boot){
	if(boot==NULL)
		return 0;
	int front=0,rear=0;
	int last=1,level=0;
	BTNode *q[maxsize];
	q[++rear]=boot;
	BTNode *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;
} 

//
//判断二叉树是否为完全二叉树
bool fun(BTNode *p){
	BTNode *q[maxsize];
	int front=0,rear=0;
	if(p==NULL)
		return true;
	q[++rear]=p;
	while(front!=rear){
		p=q[++front];
		if(p!=NULL){
			q[++rear]=p->lchild;
			q[++rear]=p->rchild;
		}
		else
			while(front!=rear){
				p=q[++rear];
				if(p!=NULL)
					return false; 
			}
	} 
	return true;
}

typedef struct TNode{
	char data;
	struct TNode *lchild,*rchild;
	int ltag=0,rtag=0;
}TNode,*iTree;//线索二叉树结构体

//ltag/Rtag=0左右孩子，ltag/Rtag=1前驱/后继

//
//建立中序线索二叉树
void InTh(TNode *&p,TNode *&pre){
	if(p!=NULL){
		InTh(p->lchild,pre);
		if(p->lchild==NULL){
			p->lchild=pre;
			p->ltag=1; 
		} 
		if(pre&&pre->rchild==NULL){
			pre->rchild=p;
			pre->rtag=1;
		}
		pre=p;
		InTh(p->rchild,pre);
	}
} 

//
//中序遍历线索二叉树
TNode *Forst(TNode *p){
	while(p->ltag==0)
		p=p->lchild;
	return p; 
} 
TNode *Next(Tnode *p){
	if(p->rtag==0)
		return First(p->rchild);
	else
		return p->rchild;
}
void In(TNode *p){
	TNode *q=First(p);
	for(;q!=NULL;q=Next(q))
		printf("%d",p->data);
}

//
//先序建立二叉搜索树并先序遍历
void preTh(TNode *&p,TNode *&pre){
	if(p!=NULL){
		if(p->lchild==NULL){
			p->lchild=pre;
			p->ltag=1;
		}
		if(pre&&pre->rchild==NULL){
			pre->rchild=p;
			pre->rtag=1;
		} 
		pre=p;
		if(p->ltag!=1)
			preTh(p->lchild,pre);
		if(p->rtag!=1)
			preTh(p->rchild,pre);
	} 
} //先序建立线索二叉树
TNode *Next(TNode *p){
	if(p->ltag!=1)
		return p->lchild;
	return p->rchild;
} 
void qq(TNode *p){
	TNode *q=p;
	for(;q!=NULL;q=Next(q))
		printf("%d",p->data);
}//先序遍历线索二叉树 

//
//寻找中序线索二叉树的前驱结点
TNode *fun(TNode *T,TNode *p){
	TNode *q;
	if(p->rtag==0)
		q=p->rchild;
	else if(p->ltag==0)
		q=p->lchild;
	else if(p->lchild==NULL)
		q=NULL;
	else{
		while(p->ltag==1&&p->lchild)
			p=p->lchild;
		if(p->ltag==0)
			q=p->lchild;
		else
			q=NULL;
	} 
	return q;
} 

//
//用孩子兄弟表示法求树所有叶子节点个数
int fun(BTNode *p){
	if(p==NULL)
		return 0;
	if(p->lchild==NULL)
		return fun(p->rchild)+1; 
}

//
//用孩子兄弟表示法求树的高度 
void fun(BTNode *T,int n,int &max){
	if(max<n)
		max=n;
	if(T->lchild!=NULL)
		fun(T->lchild,n+1,max);
	if(T->rchild!=NULL)
		fun(T->rchild,n,max);
}

//
//已知一棵树的层次序列和每个节点的度，编写算法构造此树的孩子兄弟链表
void create(CBNode *&T,char e[],int degree[],int n){
	CBNode *p=new CBNode[maxsize];
	int i,j,d,k=0;
	for(i=0;i<n;++i){
		p[i].data=e[i];
		p[i].lchild=NULL;
		p[i].rchild=NULL;
	}
	for(i=0;i<n;++i){
		d=degree[i];
		if(d){
			p[i].lchild=&p[++k];
			for(j=2;j<=d;++j){
				++k;
				p[k-1].rchild=&p[k];
			}
		}
	}
	T=p;
}