二叉树的遍历和线索二叉树 p126 3-18

最新推荐文章于 2023-11-30 20:27:24 发布
最新推荐文章于 2023-11-30 20:27:24 发布
阅读量1.7k 收藏 10
点赞数 1
文章标签： 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42030496/article/details/108585478
版权

3.编写后序遍历二叉树非递归算法

后序非递归遍历二叉树的顺序是先访问左子树，再访问右子树，最后访问根节点，当用堆栈来存储节点时必须分清返回根节点时是从左子树返回的还是从右子树返回的。所以使用辅助指针r，其指向最近访问过的结点。

void PostOrder(BiTree T){
	InitStack(S);
	p=T;
    r=NULL;
	while(p||!IsEmpty(S)){
		if(p){
			push(S,p);
			p=p->lchild;//向左走到底，全部入栈
		}
		else{
			GetTop(S,p);
			if(p->rchild&&p->rchild!=r){    //如果有右子树并且没访问过
				p=p->rchild;    //对右子树全部做同样操作
				push(S,p);
				p=p->lchild;
			}
			else{    //没有右子树或右子树访问过了，此时可以输出栈中节点值，这是个根节点（没有左子树也没有右子树或根据后序遍历右子树已经访问过了，此时可以输出根节点了）
				pop(S,p);
				printf("%d",p->data);
				r=p;      //记录最近访问的结点 
				p=NULL;    //结点访问完后，重置p指针 
			}
		}
	}
}

4.试给出二叉树自下而上，从右到左的层次遍历算法（层次遍历算法）

一般层次遍历时自上而下从左到右，这里遍历顺序恰好相反

利用原有的层次遍历算法，出队的同时将各节点指针入栈，在所有节点入栈后再从栈顶开始依次访问。

具体实现如下：1、根节点入队。2、一个元素出队，遍历这个元素。3、依次把这个元素的右孩子左孩子入队。4、队列不空则跳到2，否则结束。

void InvertLevel(BinTree bt){
	Stack S;
	Queue Q;
	BiTree p;
	
	InitStack(S);    //初始化栈，栈中存放二叉树结点的指针
	InitQueue(Q);      //初始化队列，队列中存放二叉树结点的指针
	EnQueue(Q,bt);
	while(!IsEmpty(Q)){	    
		DeQueue(Q,p);    //出队入栈 
		Push(S,p);      //入栈 
		if(p->lchild)
			EnQueue(Q,p->lchild); //入队左右孩子 
		if(p->rchild)
			EnQueue(Q,p->rchild);
	} //队空时，全部进栈了 
	while(!IsEmpty(S)){
		Pop(S,p);              //出栈可得反向序列 
		printf("%d",p->data);
	}                       
}

基于层次遍历
void LevelOrder(BiTree T){
    Queue  Q;
	InitQueue(Q);
	BiTree 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);		
	} 
}

5.假设二叉树采用二叉链表存储结构，设计一个非递归算法求二叉树的高度（层次遍历算法）

采用层次遍历的算法，设置变量level记录当前节点所在层数，设置变量last指向当前层最右节点，每次层次遍历出队时与last指针比较，若两者相等，则层数加一，并让last指向下一层的最右节点，直到遍历完成。level的值即为树的高度。

非递归

int Btdepth1(BinTree T){
	if(T==NULL)  return 0;
	int front=-1,rear=-1;
	int last=0,level=0;
	BinTree Q[MaxSize];
	Q[++rear]=T;     //入队 
	BinTree 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++;         //妙，rear每次指向层中最后一个节点 
			last=rear;
		} 
	}
	return level;
}

递归

int Btdepth2(BinTree T){
	if(T==NULL) return 0; //递归出口 
	int ldep=Btdepth(T->lchild);
	int rdep=Btdepth(T->rchild);
	if(ldep>rdep) return ldep+1;  //树的高度=子树最大高度+1 
	else return rdep+1;
}

6.根据前序序列和中序序列构造二叉树，假设结点数据值互不相同。

确定根节点在中序中的位置，将中序序列分为两个子序列，递归处理直到所处理的子序列只剩下一个元素

BTnode *CreateBt(char pre[],char in[],int l1,int r1,int l2,int r2){
	BTnode *s=(BTnode *)malloc(sizeof(BTnode));
	int i;
	if(l1>r1) return NULL;	
	s->lchild=s->rchild=NULL;
	for(i=l2;i<=r2;i++)
		if(in[i]==pre[l1]) break;
	s->data=in[i];   //确定根节点位置 
	s->lchild=CreateBt(pre,in,l1+1,l1+i-l2,l2,i-1);
	s->rchild=CreateBt(pre,in,l1+i-l2+1,r1,i+1,r2);
	return s; 
}

7.二叉树按二叉链表形式存储，写一个判别给定二叉树是否是完全二叉树的算法（层次遍历算法）

根据完全二叉树的定义，具有n个结点的完全二叉树和满二叉树中编号从1-n的结点一一对应。

采用层次遍历算法，将所有结点加入队列（包括空节点）。遇到空节点时，看其后是否右非空节点。若有，则不是完全二叉树。

bool IsComplete(BiTree T){
	InitQueue(Q);
	if(T==NULL)  
		return 1;//空树为满二叉树
	EnQueue(Q,T);
	while(!IsEmpty(Q)){
		DeQueue(Q,p);
		if(p!=NULL){
			EnQueue(Q,p->rchild);
			EnQueue(Q,p->lchild);
		}
		else
			while(!IsEmpty(Q)){
	 //遍历的时候空节点也入队了，此时表示出现结点为空结点而队列非空
	 //若空节点之后又出现非空节点，那么一定不是完全二叉树 
				DeQueue(Q,p);
				if(p) return 0;
			}
	} 
	return 1;
}

8.假设二叉树采用二叉链表存储结构存储，设计一个算法，计算给定二叉树的所有双分支结点个数（中序遍历算法）

递归模型 f(b) 如下：（是双分支结点，则此节点+左右子树中的双分支节点，否则不加）

int DsonNode(BiTree b){
	if(b==NULL) 
		return 0;
	else if(b->rchild!=NULL&&b->lchild!=NULL)
		return DsonNode(b->rchild)+DsonNode(b->lchild)+1; //是双分支就+1 
	else 
		return DsonNode(b->rchild)+DsonNode(b->lchild); //不是就+0 
}

 改造二叉树递归遍历算法

（二叉树的前中后序遍历算法中的visit根节点，可以根据题目的需要做改变）设计一个全局变量cnt用于计数双分支结点个数

int cnt=0;
void InOrder(BiTree T){
	if(T!=NULL){
		InOrder(T->lchild);
		if(T->lchild!=NULL&&T->rchild!=NULL)
			cnt++;
		InOrder(T->rchild);
	}
}

9.设树B是一棵采用链式结构存储的二叉树，编写一个把树B中所有节点的左右子树交换的函数（后序遍历算法）

采用递归算实现交换二叉树的左右子树，首先交换b节点的左孩子的左右子树，然后交换b右孩子的左右子树，最后交换b节点的左右孩子，当结点为空时递归结束（后序遍历的思想）（前中后序都可以，就是对遍历到的每个结点的孩子进行交换，与遍历顺序其实是无关的，前序就是：先交换b的左右孩子然后再对b的左右子树交换，中序就是：先交换b的左孩子的左右子树，然后交换b的左右孩子，最后交换b的右孩子的左右子树）

void swap(BiTree b){
	if(b){
		swap(b->lchild);
		swap(b->rchild);
		temp=b->lchild;
		b->lchild=b->rchild;
		b->rchild=temp;
	}
}

10.假设二叉树采用二叉链表存储结构存储，设计一个算法，求先序遍历序列中第k（1<=k<=二叉树结点个数）个结点的值（前序遍历算法）

设置一个全局变量 i 记录已访问过的结点的序号，其初值是根节点在先序序列中的序号，即1.当二叉树b为空时返回特殊字符“#”，当i==k时表示找到了满足条件的结点，返回b->data；当i!=k时，递归的在左子树中查找，若找到则返回该值，否则继续递归的在右子树中查找，并返回其结果。 （二叉树的遍历算法可以引申出大量的算法题，必须熟练掌握（本题基于前序遍历算法：访问根节点，递归访问左右子树（添加改动：对根节点进行递归出口判断第k个值是否存在）））

int i=1;         //记录已经访问过的序号
ElemType PreNode(BiTree b,int k){  //前序遍历根据需要改造 
	if(b==NULL)  return '#';
	if(i==k)     return b->data;
	i++;     
	char ch；
	ch=PreNode(b->lchild,k);   
	if(ch!='#')    return ch;
	else{        
		ch=PreNode(b->rchild,k); 
		return ch;  
 //因为题目限定了一定能找到，所以不在左子树必定在右子树，无需进行找不到的判断
	}
}

11.已知二叉树以二叉链表存储，编写算法：对于树中每个元素值为x的结点，删去以它为根的子树，释放相应的空间（删除子树：后序遍历算法，找父节点：层次遍历算法）

删除以元素值x为根的子树，只要能删除其左右子树，就可以释放值为x的根节点，因此宜采用后序遍历。

删除值为x的结点，意味着应将其父节点的左右孩子指针置空，用层次遍历易于找到某结点的父节点。本题要求删除树种每个元素值为x的结点的子树，因此要遍历完整二叉树。

void DeleteXTree(BiTree bt){ 
//后序遍历：删除树，先删左右子树，再删根节点 
	if(bt){
		DeleteXTree(bt->lchild);
		DeleteXTree(bt->rchild);
		free(bt);
	}	
}

void Search(BiTree bt,Elemtype x){
	Queue Q;
	InitQueue(Q);
	EnQueue(Q,bt);
	
	if(bt==NULL) return;	
	if(bt->data==x){
		DeleteXTree(bt);
		return ;
	} 	

	while(!IsEmpty(Q)){
		DeQueue(Q,p);
		if(p->lchild){
			if(p->lchild->data==x){
				DeleteXTree(p->lchild);
				p->lchild=NULL;
			}
			else	EnQueue(Q,p->lchild);
		}		
		if(p->rchild){
			if(p->rchild->data==x){
				DeleteXTree(p->rchild);
				p->rchild=NULL;
			}
			else 	EnQueue(Q,p->rchild);    				
		}
	}	 
}

12.在二叉树中查找值为x的结点，试编写算法打印值为x的结点的所有祖先，假设值为x的结点不多于一个

一般情况下树的题目，用递归比较好

判断左右子树里有没有x，从下向上输出所有祖先结点

bool Ancestors(Node *root,int x){
	if(root==NULL) return false;
	if(root->data==x) return true;  //这两个出口为下一个递归判断条件服务 
	if(Ancestors(root->lchild,x)||Ancestors(root->rchild,x)){
		printf("%d",root->data);   //任一孩子有x就输出这个根 
		return true;
	}
	return false;
}

13.设一棵二叉树的结点结构为(LLINK,INFO,RLINK)，ROOT为指向该二叉树根节点的指针，p和q分别为指向该二叉树种任意两个结点的指针，试编写算法ANCESTOR(ROOT,p,q,r)，找到p和q的最近公共祖先结点r。（后序非递归）（递归）

后序遍历非递归：（重在思想，后序遍历中存入栈中的结点全都是其祖先）设p在q的左边：算法思想：采用后序非递归算法，栈中存放二叉树结点的指针，当访问到某结点时，栈中所有元素均为该节点的祖先。后序遍历必然先遍历到结点p，栈中元素均为p的祖先，先将栈复制到另一辅助栈中。继续遍历到结点q时，将栈中元素从栈顶开始逐个到辅助栈中匹配，第一个匹配（即相等）的元素就是最近公共祖先。

typedef struct{
	BiTree t;
	int tag;   //0表示左孩子已被访问，1表示右孩子已被访问 
}stack;

stack s[],s1[];
BiTree Ancestor(BiTree ROOT,BiTNode *p,BiTNode *q,BiTNode *r){
	int top=0，top1;     //top是栈顶位置，用于做匹配 
	bt=ROOT;
	while(bt!=NULL||top>0){
		while(bt!=NULL&&bt!=p&&bt!=q){     
	//后序遍历：根节点不能输出，所以沿左分支向下结点依次入栈
	//并标记左孩子已经被访问 
			while(bt!=NULL){
				s[++top].t=bt;
				s[top].tag=0;
				bt=bt->lchild;
			}
		}
		while(top!=0&&s[top].tag==1){
	//设p在q的左侧，遇到p时，栈中元素均为p的祖先 
			if(s[top].t==p){      
	//找到了p，则把当前栈中元素拷贝到辅助栈 
				for(int i=1;i<=top;i++){
					s1[i]=s[i];
					top1=top;
				}
			}
			if(s[top].t==q){
	//找到了q，则把栈中元素与s1中元素做匹配，注意是从栈顶开始匹配，从挨近p结点的位置开始匹配 
				for(i=top;i>0;i--){
					for(j=top1;j>0;j--){
						if(s1[j].t==s[i].t)
							return s[i].t;
					}							
				}	
				top--;//退栈				
			}
		}
		if(top!=0){    //左子树中没找到，则标记已访问左子树，开始向右分支遍历 
			s[top].tag=1;
			bt=s[top].t->rchild;
		}	
	}
	return NULL;             //无公共祖先 
}

递归：递归遍历左右子树，找pq，递归结束后可以知道pq在左子树还是右子树，

  1. 若pq都不在左子树，那么他们都在右子树，右子树先遍历到的结点就是公共祖先
  2. 若left不空，说明左子树中有节点，那么看看右子树，若right时空的，说明全在左子树，那么左子树中先遍历到的就是公共祖先
  3. 否则，left和right都不空，说明pq在root异侧，则root就是公共祖先
  4. 注意：结点本身也可以是自己的祖先

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q){
// 如果 p和q中有等于 root的，那么它们的最近公共祖先即为root（一个节点也可以是它自己的祖先）
	if(root==NULL||root==q||root==p)
		return root;

// 递归遍历左右子树，只要在左子树中找到了p或q，则先找到谁就返回谁
	struct TreeNode *left = lowestCommonAncestor(root->left, p, q);
	struct TreeNode *right = lowestCommonAncestor(root->right, p, q);

// 如果在左子树中 p和 q都找不到，则 p和 q一定都在右子树中，
//右子树中先遍历到的那个就是最近公共祖先（一个节点也可以是它自己的祖先）
	if(left==NULL) 
		return right;

// 否则，如果 left不为空，在左子树中有找到节点（p或q），
//这时候要再判断一下右子树中的情况，如果在右子树中，p和q都找不到，
//则 p和q一定都在左子树中，左子树中先遍历到的那个就是最近公共祖先（一个节点也可以是它自己的祖先）
	if(right==NULL) 
		return left;

//否则，当 left和 right均不为空时，说明 p、q节点分别在 root异侧, 最近公共祖先即为 root  
	return root; 
}

14.假设二叉树采用二叉链表存储，设计算法，求非空二叉树的宽度（即具有结点树最多的那一层的结点个数）

采用层次遍历的方法求出所有节点的层次，并将所有结点和对应层次放在一个队列中，然后通过扫描队列求出各层的结点总数，最大的层结点总数即为二叉树的宽度。 

typedef struct{
	BiTree data[MaxSize];   //注意：保存的是结点而不是结点内容 
	int level[MaxSize];     //保存data中相同下标结点的层次 
	int front,rear;
}Qu;

int BTWidth(BiTree b){
	BiTree 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){     //数组做队列判断条件是f<r     InitQueue，Dequeue，Enqueue的判断条件是队列空 
		p=Qu.data[++Qu.front];   //数组做队列出队时f++   Dequeue 
		k=Qu.level[Qu.front];   //出队结点：p    出队结点层次=k
		if(p->lchild!=NULL){     //左孩子不空左孩子进队 
			Qu.data[++Qu.rear]=p->lchild;   //数组做队列进队时r++    EnQueue 
			Qu.level[Qu.rear]=k+1;
		}
		if(p->rchild!=NULL){
			Qu.data[++Qu.rear]=p->rchild;
			Qu.level[Qu.rear]=k+1;
		}
	}
	max=0;i=0;            //max保存同层最多的结点个数 
	k=1;                 //k表示从第一层开始查找 
	while(i<=Qu.rear){         //i扫描队中所有元素 
		n=0;               //n统计第k层的结点个数 
		while(i<=Qu.rear&&Qu.level[i]==k){
			n++;
			i++;
		}
		k=Qu.level[i];
		if(n>max) max=n;
	}
	return max;
}

15.设有一棵满二叉树（所有节点值均不同），已知其先序序列为pre，设计一个算法求其后序序列post。

对于一般二叉树仅根据先序序列或后序序列不能确定另一个遍历序列，但是满二叉树任意一个节点的左右子树含有相等的节点数，同时，先序序列的第一个节点作为后序序列的最后一个节点。

void PreToPost(ElemType pre[],int l1,int h1,ElemType post[],int l2,int h2){
	int half;
	if(h1>=l1){
		post[h2]=pre[l1];
		half=(h1-l1)/2;
		PreToPost(pre,l1+1,l1+half,post,l2,l2+half-1);  //转换左子树 
		PreToPost(pre,l1+half+1,h1,post,l2+half,h2-1);   //转换右子树 
	}
}

16.设计一个算法将二叉树的叶节点按从左到右的顺序连成一个单链表，表头指针为head。二叉树按二叉链表的方式存储，链接时用叶节点的右指针域来存放单链表指针

通常使用的树的遍历对叶节点的访问都是从左到右，所以都可以，这里采用中序递归遍历。设置前驱指针为pre，初始为空。第一个叶节点由指针head指向，遍历到叶节点时，就将它前驱的rchild指针指向它，最后一个叶节点的rchild为空。 

Link head,pre=NULL;
LinkList InOrder(BiTree bt){
	 if(bt){
        InOrder(bt->lchild);
        if(bt->lchild==NULL&&bt->rchild==NULL){
            if(pre==NULL){
                head=bt;
                pre=bt;
            }
            else{
                pre->rchild=bt;
                pre=bt;
            }
            InOrder(bt->rchild);
            pre->rchild=NULL;
        }
	 }
	 return head;
}

 

17.试设计判断两棵二叉树是否相似的算法。所谓二叉树T1T2相似，指的是都空或都只有一个根节点或左子树与左子树相似且右子树与右子树相似 

本题采用递归思想，若都空，则相似；若一个空一个不空，则必然不相似；否则递归的比较他们的左右子树是否相似

两空，一空，都不空的三种情况

int Similar(BiTree T1,BiTree T2){
	int leftS,rightS;
	if(T1==NULL&&T2==NULL) return 1;
	esle if(T1==NULL||T2==NULL)   return 0;
	else{
		leftS=similar(T1->lchild,T2->lchild);
		rightS=similar(T1->rchild,T2->rchild);
		return leftS&&rightS;  //仅当都为1的时候返回1 
	}
}

天勤（1）设计算法计算给定二叉树的所有节点

实质遍历二叉树

int n=0;    //先序遍历
void count(BTnode *p){
	if(p){
		++n;
		count(p->lchild);
		count(p->rchild);
	}
}

//后序遍历
int count(BTnode *p){
	int n1,n2;
	if(p==NULL){
		return 0;
	}
	else {
		n1=count(p->lchild);
		n2=count(p->rchild);
		return 1+n1+n2;
	}
}

（2）计算给定二叉树的所有叶子结点

int n=0;     //采用前序遍历 
void count(BTnode *p){
	if(p){
		if(p->lchild==NULL&&p->rchild==NULL) ++n;
		count(p->lchild);
		count(p->rchild);
	}
} 

//对应后序遍历 
int count(BTnode *p){
	int n1,n2;
	if(p==NULL){
		return 0;
	}else if(p->lchild==NULL&&p->rchild==NULL)   return 1;
	else {
		n1=count(p->lchild);
		n2=count(p->rchild);
		return n1+n2;
	}
}

（5）增加一个指向双亲结点的parent指针，设计算法给这个指针赋值，并输出所有节点到根节点的路径

修改二叉链表结点数据结构，将所有结点的parent指针指向双亲结点，打印所有节点到根节点的路径。

typedef struct BTnode{
	char data;
	struct BTnode *rchild;
	struct BTnode *lchild;
	struct BTnode *parent;
}BTnode;
//给parent指针赋值 
void triBTree(BTnode *p,BTnode *q){//q始终指向当前访问结点p的双亲结点 
	if(p){
		p->parent=q;
		q=p;
		triBTree(p->lchild,q);
		triBTree(p->rchild,q);
	}	
}
//任给一个节点求其到根节点的路径 
void printPath(BTnode *p){
	while(p){
		printf("%d",p->data);
		p=p->parent;
	}
}

（6）假设满二叉树b的先序序列存在长度为n的数组中，设计算法将其转换为后序遍历序列

只需将根节点移动到整个序列的末尾，然后继续递归处理序列的前一半和后一半

void change(char pre[],int l1,int r1,char post[],int l2,int r2){
	if(l1<=r1){
        int half=(l1-r1)/2;
		post[r2]=pre[l1];
		change(pre,l1+1,half+l1,post,l2,half+l2-1);
		change(pre,half+l1+1,r1,post,half+l2,r2-1);
	}
}

（7）二叉链表存储二叉树，设计算法求二叉树b中值为x的结点的层号

int L=1;
void high_x(BTnode *b,int x){
	if(b){
		if(p->data==x) printf("%d",L);
		++L;
		high_x(p->lchild,x);
		high_x(p->rchild,x);
		--L;	
	}
}

（10）二叉树的双序遍历：对于二叉树的每个节点，先访问这个节点，再按照双序遍历它的左子树，然后再一次访问这个节点，再双序遍历右子树。

void Double_order(BTnode *t){
	if(t){
		Visit(t); //已经定义的访问t的函数 
		Double_order(t->lchild);
		Visit(t) ;
		Double_order(t->rchild);
	}
}

 （11）设中序线索二叉树类型为TBTnode *InThTree

（1）设计算法在一棵中序线索二叉树中寻找节点t的子树上中序下的最后一个节点

沿着t的右子树链一直走下去，直到遇到其右指针为右线索的节点为止

TBTnode *inLast(TBTnode *t){
	TBTnode *p=t;
	while(p&&!p->rtag)	p=p->rchild;
	return p;
}

（2）找t的中序前驱

若t有左线索，则其左线索所指结点即为中序前驱；若无左线索，则其左子树中中序最后一个节点为它的中序前驱

TBTnode *inPrior(TBTnode *t){
	TBTnode *p=t->lchild;
	if(p&&!t->ltag) p=inLast(p);
	return p;
}

（3）找t的前序后继

分三种情况：1、节点有左孩子 2、节点只有右孩子  3、节点没有孩子，此时其前序后继是此节点的右线索走到无右线索节点这个节点就是前序后继

TBTnode *preNext(TBTnode *t){
	TBTnode *p;
	if(!t->ltag) p=t->lchild;
	else if(!t->rtag) p=t->rchild;
	else{
		p=t;
		while(p&&p->rtag) p=p->rchild;
		if(p) p=p->rchild;
	}
	return p;
}

 

云淡风轻__
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
二叉树题目----4 前序遍历重构二叉树 AND 求二叉树中所有结点的个数
LXY的博客
10-07 177
前序遍历重构二叉树 思路 整个二叉树用数组存储 因为先序遍历它先遍历根，再遍历左，左边没有跑完是不会去遍历右边的，所以遍历左子树，就是数组元素每回向后一个，个数-1 遍历右边时，就是数组起始位置+左子树跑到的位置+每次往后走一个，大小就是减去左子树用掉的个数+每回个数-1 因为要返回遍历的位置，和遍历用掉的个数，所以每回都要返回两个值，用结构体返回。 #include<stdlib....
求二叉树右子树中大于给定值的结点数量
qq_45787083的博客
11-23 1375
【问题描述】使用先序遍历序列建立链式存储结构的二叉树，输入一个n，求出二叉树的右子树中大于n的结点数量。 【输入形式】按先序遍历序列输入二叉树的结点信息；输入一个值n。（结点的数值为正整数，0表示空） 【输出形式】输出右子树中大于n的结点的数量。 【样例输入】 19 6 8 0 0 45 0 0 20 33 0 0 1 0 0 18 【样例输出】 2 #include<stdio.h>//求左子树大于n的节点个数 #include<stdlib.h> #include<iost
设一棵二叉树的结点结构为（LLINK,INFO,RLINK），ROOT为指向该二叉树根结点的指针，p和q分别为指向该二叉树中任意两个结点的指针，试编写一个算法ANCESTOR(ROOT,p,q,r)，
syh666233的博客
09-09 1857
思路：在做这道题之前，如果知道怎么求某个结点所有祖先结点就很好求了。在这个前提下，我们把p的祖先和q的祖先分别存放在两个栈里面，并且设p在q的左边，那么p的祖先一定也是q的祖先，然后对比两个栈中的元素，第一个相等的元素就是最近的公共祖先结点，下面是示意图， 把路径都找到过后，就挨个出栈，并且比较。 代码没时间写了，以后有时间再更吧，不过如果会写某个结点所有祖先的那道题，这道题其实是一样的。 ...
使用先序遍历序列建立链式存储结构的二叉树，输入一个n，求出二叉树的右子树中大于n的结点数量。
qq_25565903的博客
11-06 459
【问题描述】使用先序遍历序列建立链式存储结构的二叉树，输入一个n，求出二叉树的右子树中大于n的结点数量。 【输入形式】按先序遍历序列输入二叉树的结点信息；输入一个值n。（结点的数值为正整数，0表示空） 【输出形式】输出右子树中大于n的结点的数量。
设一棵二叉树的结点结构为（LLINK,INFO,RLINK），ROOT为指向该二叉树根结点的指针，p和q分别为指向该二叉树中任意两个结点的指针，编写一个算法ANCESTOR(ROOT,p,q,r),找
weixin_43405277的博客
04-23 1796
设一棵二叉树的结点结构为(LLINK,INFO,RLINK）ROOT为指向该二叉树根结点的指针，p和q分别为指向该二叉树中任意两个结点的指针，编写一个算法ANCESTOR(ROOT,p,q,r),找到p和q的最近公共祖先结点. 思路: 采用非递归后续遍历算法,因为在访问一个结点p时,栈中结点恰好是p结点的所有祖先,从栈底到栈顶结点再加上p结点,刚好构成从根结点到p结点的一条路径. 栈内数据: 伪代码: BiTree Ancestor(BiTree ROOT,BiTNode *p,BiTNode *q
数据结构 严蔚敏 代码
03-14
范例1-18 字符串的抽取 36 ∷相关函数：substr函数 1.1.19 字符串的分割 38 范例1-19 字符串的分割 38 ∷相关函数：partition函数 1.1.20 字符串的插入 40 范例1-20 字符串的插入 40 ∷相关函数：insert函数 1.1.21 ...
严蔚敏 数据结构(C语言版) 代码 23490 书中算法
04-21
5.3　遍历二叉树和线索二叉树　103 5.3.1　遍历二叉树　103 5.3.2　线索二叉树　109 5.4　树和森林　114 5.4.1　树的存储结构　114 5.4.2　森林与二叉树的转换　116 5.4.3　树和森林的遍历　116 5.5　赫夫曼树及其...
数据结构（王）c元代码
10-23
范例1-18 字符串的抽取 36 ∷相关函数：substr函数 1.1.19 字符串的分割 38 范例1-19 字符串的分割 38 ∷相关函数：partition函数 1.1.20 字符串的插入 40 范例1-20 字符串的插入 40 ∷相关函数：insert函数 1.1.21 ...
数据结构算法实现(严蔚敏版配套实现程序)
02-26
范例1-18 字符串的抽取 36 ∷相关函数：substr函数 1.1.19 字符串的分割 38 范例1-19 字符串的分割 38 ∷相关函数：partition函数 1.1.20 字符串的插入 40 范例1-20 字符串的插入 40 ∷相关函数：insert函数 1.1.21 ...
数据结构算法实现（严蔚敏版配套实现程序）
03-13
范例1-18 字符串的抽取 36 ∷相关函数：substr函数 1.1.19 字符串的分割 38 范例1-19 字符串的分割 38 ∷相关函数：partition函数 1.1.20 字符串的插入 40 范例1-20 字符串的插入 40 ∷相关函数：insert函数 1.1.21 ...
计算任意二叉树T中其数据域大于等于x的结点个数并返回该值
Mixzi的博客
04-02 3347
#include <stdio.h> typedef struct node { int data; struct node* lchild, * rchild; }BinTNode; int SearchXNum(BinTNode *T,int x){ int n; if (T==NULL) { return 0; } if (T->data>=x) { n = 1; } else { n = 0; } return n + SearchXNu.
王道——数据结构——树与二叉树（3）
不会就用洛必达的博客
05-03 994
系列文章目录 王道——数据结构——树与二叉树（1） 王道——数据结构——树与二叉树（2） 文章目录系列文章目录前言一、5.3节 前言 本文为王道数据结构的第五章——树与二叉树的编程题。 运行软件：vscode 使用c++文件编写 本文所使用的树为《王道——数据结构——树与二叉树（1）》中建立的树 一、5.3节 11、已知二叉树以二叉链表存储，编写算法完成：对于树中的每个元素值为x的结点，删去以它为根节点的子树，并释放相应的空间。 // 第十一题 使用层次遍历主树，发现结点值为x时，对x的子树进行后续
《数据结构》上机实验(第七章) —树与二叉树Ⅱ
Miss Z的博客
08-30 1687
9. 设一棵二叉树中各结点的值互不相同，其先序遍历序列和中序遍历序列分别存于两个一维数组A[1…n]和B[1…n]中，建立该二叉树的二叉链表。 算法思想： 在这里插入代码片 运行结果 10. 二叉树按二叉链表形式存储，写一个判别给定二叉树是否是完全二叉树的算法。 算法思想： 在这里插入代码片 运行结果 ...
求节点值为x的所有祖先节点
skykone1的博客
05-19 939
//求节点值为x的所有祖先节点 typedef struct{ BiTree t; int tag; //tag=0表示左子女已被访问，tag=1表示右子女已被访问。 }stack; void Search(BiTree bt,ElemType x){ stack s[]; top=0; while(bt!=NULL||top>0){ while(bt!=NULL&&bt->data!=x){ //此时bt->data==x是在入栈时候发现了x节点，放弃继.
2022王道数据结构考研复习指导习题代码（树与二叉树）
qq_18431031的博客
05-16 1734
5.2二叉树的概念 1.已知一棵二叉树按顺序存储结构进行存储，设计一个算法，求编号分别i和j的两个结点的最近公共祖先结点的值。
假设二叉树采用链接方式存储，编写一个计算一颗二叉树t的高度的函数
xueba8的博客
11-08 4703
如上图，如果是按照对称序周游的话，则节点序列为：B D A E C F；是在B开始探索，B没有左节点则B的左return 0 即B节点的h1= 0，B有一个右节点D,则进入D开始探索，D左右都没有节点则D的左右都是return 0 即D节点h1 = 0, h2 = 0， 然后执行D节点的①即h = h2 +1即h=0 + 1 返回1给B的h2。然后执行B节点的①即h = h2 + 1即h = 1+
设一棵二叉树的结点结构为(LLINK,INFO,RLINK)，ROOT 为指向该二叉树根结点的指针,p和q分别为指向该二叉树中任意两个结点的指针,试编写算法ANCESTOR (ROOT,p,q)
最新发布
gc的博客
11-30 382
考虑使用递归，找祖先，所以使用后序递归遍历；最近公共祖先是说离 p和q最近的祖先，p和q本身就可以时最近公共祖先。3、若其左右递归返回值都不为空，则 ROOT 是最近公共祖先。否则若左递归返回值不为空，则其返回值则为最近公共祖先。否则若右递归返回值不为空，则其返回值则为最近公共祖先。1、如果p和q本身就是公共祖先，则直接返回。
数据结构二叉树的链式存储
qq_45562742的博客
08-16 129
typedef struct BiTNode{ int data; struct BiTNode *lchild, *rchild; }BiTNode, *BiTree; //定义一棵空树 BiTree root = NULL; //插入根节点 root = (BiTree)malloc(sizeof(BiTNode)); root->data = {1}; root->lchild = NULL; root->rchild = NULL; //插入新结点 BiTN.
c语言实现二叉树的存储结构,数据结构之---C语言实现二叉树的顺序存储
weixin_33941707的博客
05-18 1249
//二叉树的顺序存储//这里利用循环队列存储数据//杨鑫#include#include#include#include#define MAXQSIZE 5 // 最大队列长度(对于循环队列，最大队列长度要减1)#define MAX_TREE_SIZE 100 // 二叉树的最大结点数#define ClearBiTree InitBiTree // 在顺序存储结构中，两函数完全一样typede...
深度优先搜索遍历和二叉树遍历
09-01
深度优先搜索（DFS）遍历和二叉树遍历是两个不同的概念。 深度优先搜索遍历（DFS）是一种用于图或树的遍历算法。它从起始节点开始，沿着路径尽可能深地探索直到无法继续，然后回溯到上一个节点继续探索其他路径。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值