王道408考研课后习题---二叉树

一、二叉树的链式存储结构

typedef struct BiTNode {
	int data;
	struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

二、习题

第三题：

非递归版的后续遍历
算法思想：
先访问左节点，然后右节点，最后根结点。
首先无脑访问做左的节点，中间遇到的非叶子结点全部记录在栈中，当已经访问到最左结点的时候，从栈中取栈顶一个元素，访问其右节点，然后重复一的步骤，然后弹出栈顶一个元素，访问根结点。
上诉过程中，两次访问根结点，第一次是从左子树过来要找到右子树，此时并不对其访问。第二次，从右子树结点过来，此时需要访问根结点了。因此可以设定一个标记位置，记录是从哪个节点过来的，来决定是否需要访问根结点。

void postOrder(BiTree T) {
	initStack(S);
	BiTree p = T, r = NULL;  // r指针用来记录p指针指向的前一个结点，为了判断
	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;
			} else { // 右子树不存在，或者右子树已经访问过了 直接访问根结点
				pop(S, p);
				visit(p);
				r = p;
				p = NULL;  // 将p置为NULL是为了 继续向栈中取结点
			}

		}
	}
}

非递归版的前中序遍历

void InOrder(BiTree T) {
	initStack(S);
	BiTree p = T;
	while(p || isEmpty(S)) {
		if(p) {
			push(S, p);
			p = p->lchild;
		} else {
			pop(S, p);
			visit(p);
			p = p->rchild;
		}
	}
}

void preOrder(BiTree T) {
	initStack(S);
	BiTree p = T;
	while(p || isEmpty(S)) {
		if(p) {
			visit(p);
			push(S, p);
			p = p->lchild;
		} else {
			pop(S, p);
			p = p->rchild;
		}
	}
}

第四题：

给出二叉树的自下而上、从右到左的层次遍历算法。
算法思路：按照层序遍历的顺序，然后依次入栈即可，最后出栈的顺序就是自下而上、从右往左的访问顺序

void InvertLevel(BiTree T) {
	BiTree p;
	initStack(S);
	initQueue(Q);
	if(T) {
		enqueue(Q, bt);
		while(!isEmpty(Q)) { // 当队列不空时
			dequeue(Q, p);
			push(p);
			if(p->lchild) enqueue(Q, p->lchild);
			if(p->rchild) enqueue(Q, p->rchild);
		}
	}
	while(!isEmpty(S)) {
		pop(S, p);
		visit(p);
	}
}

如果是自上而下，从右往左。这个就需要去记录每一层的结点个数，对于同一层次的结点 进行全入栈然后出栈 再入队，即可实现同一层次的逆序。

void InvertLevel(BiTree T) {
	BiTree p;
	initStack(S);
	initQueue(Q);
	initQueue(ans);  // 该队列为最终存的答案队列
	if(T) {
		enqueue(Q, T);
		while(Q) {
			int len = getLen(Q);  // 计算当前队列的长度
			while(len --) {
				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);
				enqueue(ans, p);
			}
		}
	}
	while(!isEmpty(ans)) { // 访问ans队列的结果即可
		dequeue(ans, p);
		visit(p);
	}
}

第五题：

非递归算法计算 二叉树的高度
算法思路：宽搜

int getTreeHigh(BiTree T) {
	BiTree p;
	initQueue(Q);
	int high = 0;
	if(T) {
		enqueue(Q, T);
		while(Q) {
			int len = getLen(Q);  // 计算当前队列的长度
			while(len --) {
				dequeue(Q, p);
				if(p->lchild) enqueue(Q, p->lchild);
				if(p->rchild) enqueue(Q, p->rchild);
			}
			high ++;  // 访问完一层 树的高度加1
		}
	}
	return high;
}

还有一种逻辑类似的方法

int Btdepth(BiTree T) {
	if(!T) return 0;  // 树空 直接返回0

	// 定义个静态队列
	int hh = -1, rr = -1;
	int last = 0, level = 0; // last 指向的是当前层最右结点
	BiTree Q[MAXSIZE];
	Q[++ rear] = T;
	BiTree p;
	while(hh < rr) { // 当队列不为空的时候
		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;
}

递归版

int getTreeLevel(BiTree T) {
	if(!T) return 0;
	ldep = getTreeLevel(T->lchild);
	rdep = getTreeLevel(T->rchild);
	return ldep < rdep ? rdep + 1 : ldep + 1;
}

第六题：

根据给定的先序和中序遍历序列，然后构建一个二叉链表。
算法思路：每次先找到根结点，然后递归分解成构建左子树和右子树

// 数组下标从1开始 假设有n个结点  所以 l1~r1属于[1，n]
BiTree preInCreate(int A[],int B[],int l1,int r1,int l2,int r2) {
	BiTree root = new BiTNode;
	root->data = A[l1]; // 先序遍历的顺序第一个元素一定是根结点
	int i;
	for(i = l2; B[i] != root->data; i ++); // 在中序遍历中找到A中的第一个元素，然后分块 继续递归
	llen = i - l2;
	rlen = r2 - i;

	if(llen) root->lchild = preInCreate(A,B,l1 + 1, l1 + llen,l2,l2 + llen - 1);
	else root->lchild = NULL;

	if(rlen) root->rchild = preInCreate(A,B,r1 - rlen + 1, r1, r2-rlen + 1,r2);
	else root->rchild = NULL;

	return root;
}

// 最后类似的给出后续遍历和中序遍历， 只需要调整参数的区间即可

第七题：

判断一个二叉树是否是完全二叉树
算法思路：完全二叉树 只需要考虑其最后一层，只能是最左边有元素，当然可能该层全满
用一个队列 记录当前层次的所有后继结点，然后遍历后继结点，如果出现NULL，那么后面所有结点都是NULL
但凡出现一个非NULL那么该二叉树一定是非完全二叉树

bool isComplete(BiTree T){
	BiTree p;
	initQueue(q);
	if(!T) return 1;  // 空树特判为满二叉树
	enqueue(q, T);
	while(!isEmpty(q)){
		dequeue(q, p);
		if(p){
			enqueue(q,p->lchild);
			enqueue(q,p->rchild);
		}else{
			while(!isEmpty(q)){
				dequeue(q, p);
				if(p) return 0;
			}
		}
	}
	return 1;
}

第八题：

计算一个二叉树所有双分支结点个数

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

第九题：

交换左右子树
算法思路：使用递归算法实现，先交换T结点的左孩子的左右子树，然后交换T结点右孩子的左右子树，最后交换T结点的左右孩子

void swap(BiTree T){
	if(T){
		swap(T->lchild);
		swap(T->rchild);
		auto tmp = T->lchild;
		T->lchild = T->rchild;
		T->rchild = tmp;
	}
}

第十题：

求先序遍历的第K个结点的值
算法思路：可以定义一个全局变量去记录当前已经访问过的结点个数

int cnt = 0;  // 全局变量 统计当前已经访问的结点个数
int preOrder(BiTree T,int k){
	BiTree p = T; 
	initStack(S);
	while(p || !isEmpty(S)){
		if(p){
			cnt ++;
			if(cnt == k) return p->data;
			push(S, p);
			p = p->lchild;
		}else{
			pop(S, p);
			p = p->rchild;
		}
	}
}

第十一题：

对于树中每个元素值为x的结点，删除以他为根的子树，并释放相应的空间。
算法思路：首先遍历树的所有结点（层次遍历），找到数据域为x的结点，递归删除释放其后代

// 递归删除子树的方法
void delete(BiTree T){
	if(T){
		delete(T->lchild);
		delete(T->rchild);
		free(T);
	}
}

// 层次遍历删除
void searchX(BiTree T,int x){
	initQueue(Q);  // 定义一个队列
	BiTree p;      // 定义一个工作指针
	if(T){
		if(T->data == x) delete(T), return;  // 如果是根结点那么 删除完可以直接退出了
		enqueue(Q, T);
		while(!isEmpty(Q)){
			dequeue(Q, p);
			if(p->lchild){
				if(p->lchild->data == x){
					delete(p->lchild);
					p->lchild = NULL;
				}else{
					enqueue(Q, p->lchild);
				}
			}
			if(p->rchild){
				if(p->rchild->data == x){
					delete(p->rchild);
					p->rchild = NULL;
				}else{
					enqueue(Q, p->rchild);
				}
			}
			
		}
	}
}

第十二题：

值为x的结点的所有祖先，x不多于一个

算法思路：采用非递归的后续遍历，最后访问根结点，那么当访问到x的时候，栈中所有元素即为该结点的祖先结点

void PostOrder(BiTree T,int x){
	initStack(S);
	BiTree 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;
			}else{
				pop(S, p);
				if(p->data == x) break;  // 结束循环此时栈中均为x的祖宗结点
				r = p;
				p = NULL;
			}
			
		}
	}
	while(!isEmpty(S)){ // 输出栈中元素
		pop(S, p);
		cout << p->data << ' ';
	}
}

第十三题：

两结点的最近公共祖先
采用后续遍历分别访问p和q，此时p和q的后续遍历的工作栈中即为该结点的祖宗序列，去匹配倒数第一个相同的元素。

Stack S1[], S2[];
BiTree ancestor(BiTree root, BiTree a, BiTree b){
	initStack(S1);
	BiTree p = T, r = NULL;
	while(p || !isEmpty(S1)){
		if(p){
			push(S1, p);
			p = p->lchild;
		}else{
			getTop(S1, p);
			if(p->rchild && p->rchild != r){
				p = p->rchild;
			}else{
				pop(S1, p);
				if(p == a) break;  // 结束循环此时栈中均为x的祖宗结点
				r = p;
				p = NULL;
			}
			
		}
	}
	
	initStack(S2);
	BiTree p = T, r = NULL;
	while(p || !isEmpty(S2)){
		if(p){
			push(S2, p);
			p = p->lchild;
		}else{
			getTop(S2, p);
			if(p->rchild && p->rchild != r){
				p = p->rchild;
			}else{
				pop(S2, p);
				if(p == b) break;  // 结束循环此时栈中均为x的祖宗结点
				r = p;
				p = NULL;
			}
			
		}
	}
	for(int i = S1.top;i >= 0;i --){
		for(int j = S2.top; j >= 0;j --){
			if(S1[i] == S2[j]) return S1[i];  
		}
	}
	return NULL;  // 没有找到相同元素 返回NULL
	
}

第十四题：

二叉树的宽度，即最大的层次结点的个数
算法思路：层次遍历

int getWidth(BiTree T){
	int maxv = -1;  // 初始化最大值
	BiTree p;
	initQueue(Q);
	enqueue(Q, T);
	while(!isEmpty(Q)){
		int size = length(Q); // 计算当前队列Q的长度
		maxv = max(maxv, size);
		while(size --){
			dequeue(Q, p);
			if(p->lchild) enqueue(Q, p->lchild);
			if(p->rchild) enqueue(Q, p->rchild);
		}		
	}
	return maxv;
}

第十五题：

已知一棵满二叉树的先序序列，求其后序序列

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

第十六题：

将二叉树的叶子结点按从左到右的顺序连成一个单链表，表头指针为head,链接时用叶结点的有指针来存放单链表的指针

算法思想：采用中序遍历，遇到结点为孩子，则上一个叶结点指向当前结点

LinkList inOrder(BiTree T){
	BiTree pre = NULL;
	LinkList head;
	if(T){
		inOrder(T->lchild);
		if(T->lchild == NULL && T->rchild == NULL){
			if(pre == NULL){
				head = T;
				pre = T;
			}else{
				pre->rchild = T;
				pre = T;
			}
		}
		inOrder(T->rchild);
	}
	return head;
}

第十七题：

判断二叉树的相似
算法思路：同时遍历两个二叉树

int similar(BiTree T1, BiTree T2){
	if(T1 == NULL && T2 == NULL) return 1; // 如果他们同时走到为NULL的话，相似
	else if (T1 == NULL || T2 == NULL) return 0;  // 一个非空一个空 不相似
	else return similar(T1->lchild,T2->lchild) && similar(T1->rchild,T2->rchild);
}

第十八题：

中序线索二叉树里查找指定结点p在后序的前驱结点的算法
算法思路：

• 如果p结点是非叶子结点，其有右子女，则右子女一定是后序前驱
• 没有右子女，有左子女，则左子女一定是后序前驱。
• 如果p结点是叶子结点，顺着左线索往前找一个结点，如果不是中序遍历的第一个结点，那么其左子树就是其后续前驱
• 如果该结点为中序遍历的第一个结点（其为空）,那么直接返回NULL即可

BiTree InPostPre(BiTree T,BiTree p){
	BiTree q;
	if(p->rchild == 0) q = p->rchild;
	else if(p->lchild == 0) q = p->lchild;
	else if(p->lchild == NULL) q == NULL;  //  该点为中序序列的第一个结点，无前驱
	else{
		if(p->ltag == 1 && p->lchild != NULL) p = p->lchild;
		if(p->ltag == 0) q = p->lchild;
		else q = NULL;   // p结点就是第一个后序结点， 所以无前驱
	}
}

第十九题：

计算二叉树的带权路径长度（WPL）

int wpl = 0;   // 全局变量
int preOrder(BiTree root,int deep){
	
	if(root->lchild == NULL && root->rchild == NULL) wpl += deep * root->data;
	if(root->lchild != NULL) preOrder(root->lchild, deep+1);
	if(root->lchild != NULL) preOrder(root->rchild, deep+1);
}

第二十题：

输出二叉树的中序序列，每一颗子树都用括号括起来

void ToExe(BiTree *root, int deep){
	if(root == NULL) return;
	else if(root->lchild == NULL && root->rchild == NULL) cout << root->data;
	else{
		if(deep > 1) cout << "(";
		ToExe(root->lchild, deep+1);
		cout << root->data;
		ToExe(root->rchild, deep+1);
		if(deep > 1) cout << ")";
	}
}

第二十一题：

判断一个用顺序存储的二叉树是否为二叉搜索树
算法思路：若一个树为二叉搜索树，则中序遍历得到的的序列一定是递增的，由此可以判断

int a[], cnt;  // 用来存储访问到的序列 cnt为其元素个数
int inOrder(BiTree T){
	if(T){
		inOrder(T->lchild);
		a[cnt++] = T->data;
		inOrder(T->rchild);
	}
}
bool judge(){
	for(int i = 1;i < cnt;i ++){
		if(a[i - 1] > a[i]) return false;
	}
	return true;
}