数据结构实验

已于 2023-11-08 10:16:35 修改
阅读量346 收藏 2
点赞数
分类专栏： 数据结构：基础，杂项 文章标签： 数据结构 c++ 算法
于 2023-11-08 10:11:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Landing_on_Mars/article/details/134281947
版权

1. (程序题, 25分)

二叉树结点类型为char,特殊字符为@。输入一个二叉树的扩展先序遍历序列，输出该二叉树的后序序列。

例如：一棵二叉树由ABCDEF共6个结点组成，对空指针域采用@扩展。

输入先序遍历序列：ABD@F@@@CE@@@

输出二叉树的后序遍历序列：FDBECA

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
using namespace std;
typedef long long LL;
const int N = 100;
typedef struct Node {
	char c;
	struct Node* lch;
	struct Node* rch;
}Node;
string s;
void build(Node** root, int& index) {
	if (index >= s.size())return;
	(*root) = (Node*)malloc(sizeof(Node));
	(*root)->c = s[index];
	index++;
	if (s[index] != '@') {
		build(&(*root)->lch, index);
	}
	else {
		(*root)->lch = NULL;
	}
	index++;
	if (s[index] != '@') {
		build(&(*root)->rch, index);
	}
	else {
		(*root)->rch = NULL;
	}
}
void print(Node* r) {
	if (r->lch != NULL) {
		print(r->lch);
	}
	if (r->rch != NULL) {
		print(r->rch);
	}
	printf("%c", r->c);
}
void print1(Node* r) {
	Node* stk[100];
	int f[100];
	int tt = 0;
	Node* p = r;
	while (p != NULL || tt != 0) {
		if (p != NULL) {
			stk[tt] = p;
			f[tt] = 1;
			tt++;
			p = p->lch;
		}
		else {
			if (!f[tt - 1]) {
				printf("%c", stk[tt - 1]->c);
				tt--;
			}
			else {
				p = stk[tt - 1];
				f[tt - 1]--;
				p = p->rch;
			}
		}
	}
}
int main() {
	cin >> s;
	Node* H = (Node*)malloc(sizeof(Node));
	int index = 0;
	build(&(H->lch), index);
	//print(H->lch);//递归遍历
	print1(H->lch);//栈遍历
	return 0;
}

2. (程序题, 25分)

输入二叉树的扩展的先序遍历序列，建立一棵二叉树，然后输出该二叉树的层次遍历序列（要求借助队列实现）

二叉树结点类型为char,特殊字符为@。

输入先序遍历序列：ABD@F@@@CE@@@

输出二叉树的层次遍历序列为：ABCDEF

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
using namespace std;
typedef long long LL;
const int N = 100;
typedef struct Node {
	char c;
	struct Node* lch;
	struct Node* rch;
}Node;
string s;
void build(Node** root, int& index) {
	if (index >= s.size())return;
	(*root) = (Node*)malloc(sizeof(Node));
	(*root)->c = s[index];
	index++;
	if (s[index] != '@') {
		build(&(*root)->lch, index);
	}
	else {
		(*root)->lch = NULL;
	}
	index++;
	if (s[index] != '@') {
		build(&(*root)->rch, index);
	}
	else {
		(*root)->rch = NULL;
	}
}
void print(Node* r) {//递归遍历
	if (r->lch != NULL) {
		print(r->lch);
	}
	if (r->rch != NULL) {
		print(r->rch);
	}
	printf("%c", r->c);
}
void print1(Node* r) {//栈遍历
	Node* stk[100];
	int f[100];
	int tt = 0;
	Node* p = r;
	while (p != NULL || tt != 0) {
		if (p != NULL) {
			stk[tt] = p;
			f[tt] = 1;
			tt++;
			p = p->lch;
		}
		else {
			if (!f[tt - 1]) {
				printf("%c", stk[tt - 1]->c);
				tt--;
			}
			else {
				p = stk[tt - 1];
				f[tt - 1]--;
				p = p->rch;
			}
		}
	}
}
void print2(Node* r) {//层次遍历，手写队列
	Node* que[N];
	int tr = 0, tf = 0;
	que[++tr] = r;
	Node* p = NULL;
	while (tr != tf) {
		if ((tf + 1) % N <= tr) {
			tf = (tf + 1) % N;
			p = que[tf];
		}
		printf("%c", p->c);
		if ((tr + 1) % N != tf && p->lch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->lch;
		}
		if ((tr + 1) % N != tf && p->rch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->rch;
		}
	}
}
int main() {
	cin >> s;
	Node* H = (Node*)malloc(sizeof(Node));
	int index = 0;
	build(&(H->lch), index);
	//print(H->lch);
	//print1(H->lch);
	print2(H->lch);
	return 0;
}

3. (程序题, 25分)

求二叉树的高度

输入二叉树的扩展的先序遍历序列，建立一棵二叉树，然后输出二叉树的高度（深度）。

输入：

AB@E@R@@CF@@@
输出：
4

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
using namespace std;
typedef long long LL;
const int N = 100;
typedef struct Node {
	char c;
	struct Node* lch;
	struct Node* rch;
}Node;
string s;
void build(Node** root, int& index) {
	if (index >= s.size())return;
	(*root) = (Node*)malloc(sizeof(Node));
	(*root)->c = s[index];
	index++;
	if (s[index] != '@') {
		build(&(*root)->lch, index);
	}
	else {
		(*root)->lch = NULL;
	}
	index++;
	if (s[index] != '@') {
		build(&(*root)->rch, index);
	}
	else {
		(*root)->rch = NULL;
	}
}
void print(Node* r) {//递归遍历
	if (r->lch != NULL) {
		print(r->lch);
	}
	if (r->rch != NULL) {
		print(r->rch);
	}
	printf("%c", r->c);
}
void print1(Node* r) {//栈遍历
	Node* stk[100];
	int f[100];
	int tt = 0;
	Node* p = r;
	while (p != NULL || tt != 0) {
		if (p != NULL) {
			stk[tt] = p;
			f[tt] = 1;
			tt++;
			p = p->lch;
		}
		else {
			if (!f[tt - 1]) {
				printf("%c", stk[tt - 1]->c);
				tt--;
			}
			else {
				p = stk[tt - 1];
				f[tt - 1]--;
				p = p->rch;
			}
		}
	}
}
void print2(Node* r) {//层次遍历，手写队列
	Node* que[N];
	int tr = 0, tf = 0;
	que[++tr] = r;
	Node* p = NULL;
	while (tr != tf) {
		if ((tf + 1) % N <= tr) {
			tf = (tf + 1) % N;
			p = que[tf];
		}
		printf("%c", p->c);
		if ((tr + 1) % N != tf && p->lch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->lch;
		}
		if ((tr + 1) % N != tf && p->rch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->rch;
		}
	}
}
int F(Node* r) {//利用层次遍历查找树的深度
	int ret = 0, f[1000] = { 0 };
	Node* que[N];
	int tr = 0, tf = 0;
	que[++tr] = r;
	f[tr] = 1;
	Node* p = NULL;
	while (tr != tf) {
		if ((tf + 1) % N <= tr) {
			tf = (tf + 1) % N;
			p = que[tf];
			ret = max(ret, f[tf]);
		}
		if ((tr + 1) % N != tf && p->lch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->lch;
			f[tr] = f[tf] + 1;
		}
		if ((tr + 1) % N != tf && p->rch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->rch;
			f[tr] = f[tf] + 1;
		}
	}
	return ret;
}
int main() {
	cin >> s;
	Node* H = (Node*)malloc(sizeof(Node));
	int index = 0;
	build(&(H->lch), index);
	//print(H->lch);
	//print1(H->lch);
	//print2(H->lch);
	int ans = F(H->lch);
	cout << ans << endl;
	return 0;
}

4. (程序题, 25分)

求二叉树的叶子结点个数

输入二叉树的扩展的先序遍历序列，建立一棵二叉树，然后输出二叉树的叶子结点个数。

输入先序遍历序列：ABD@F@@@CE@@@

输出二叉树的叶子结点个数：2

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
using namespace std;
typedef long long LL;
const int N = 100;
typedef struct Node {
	char c;
	struct Node* lch;
	struct Node* rch;
}Node;
string s;
void build(Node** root, int& index) {
	if (index >= s.size())return;
	(*root) = (Node*)malloc(sizeof(Node));
	(*root)->c = s[index];
	index++;
	if (s[index] != '@') {
		build(&(*root)->lch, index);
	}
	else {
		(*root)->lch = NULL;
	}
	index++;
	if (s[index] != '@') {
		build(&(*root)->rch, index);
	}
	else {
		(*root)->rch = NULL;
	}
}
void print(Node* r) {
	if (r->lch != NULL) {
		print(r->lch);
	}
	if (r->rch != NULL) {
		print(r->rch);
	}
	printf("%c", r->c);
}
void print1(Node* r) {
	Node* stk[100];
	int f[100];
	int tt = 0;
	Node* p = r;
	while (p != NULL || tt != 0) {
		if (p != NULL) {
			stk[tt] = p;
			f[tt] = 1;
			tt++;
			p = p->lch;
		}
		else {
			if (!f[tt - 1]) {
				printf("%c", stk[tt - 1]->c);
				tt--;
			}
			else {
				p = stk[tt - 1];
				f[tt - 1]--;
				p = p->rch;
			}
		}
	}
}
void print2(Node* r) {
	Node* que[N];
	int tr = 0, tf = 0;
	que[++tr] = r;
	Node* p = NULL;
	while (tr != tf) {
		if ((tf + 1) % N <= tr) {
			tf = (tf + 1) % N;
			p = que[tf];
		}
		printf("%c", p->c);
		if ((tr + 1) % N != tf && p->lch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->lch;
		}
		if ((tr + 1) % N != tf && p->rch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->rch;
		}
	}
}
int F(Node* r) {
	int ret = 0, f[1000] = { 0 };
	Node* que[N];
	int tr = 0, tf = 0;
	que[++tr] = r;
	f[tr] = 1;
	Node* p = NULL;
	while (tr != tf) {
		if ((tf + 1) % N <= tr) {
			tf = (tf + 1) % N;
			p = que[tf];
			ret = max(ret, f[tf]);
		}
		//printf("%c", p->c);
		if ((tr + 1) % N != tf && p->lch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->lch;
			f[tr] = f[tf] + 1;
		}
		if ((tr + 1) % N != tf && p->rch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->rch;
			f[tr] = f[tf] + 1;
		}
	}
	return ret;
}
int F1(Node* r) {
	int ret = 0;
	Node* que[N];
	int tr = 0, tf = 0;
	que[++tr] = r;
	Node* p = NULL;
	while (tr != tf) {
		if ((tf + 1) % N <= tr) {
			tf = (tf + 1) % N;
			p = que[tf];
		}
		if (p->lch == NULL && p->rch == NULL) {
			ret++;
			continue;
		}
		//printf("%c", p->c);
		if ((tr + 1) % N != tf && p->lch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->lch;
		}
		if ((tr + 1) % N != tf && p->rch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->rch;
		}
	}
	return ret;
}
int main() {
	cin >> s;
	Node* H = (Node*)malloc(sizeof(Node));
	int index = 0;
	build(&(H->lch), index);
	//print(H->lch);
	//print1(H->lch);
	//print2(H->lch);
	//int ans=F(H->lch);
	int ans = F1(H->lch);//利用层次遍历查找叶子节点，写法有很多，只要满足p->lch == NULL && p->rch == NULL就行
	cout << ans << endl;
	return 0;
}

5. (程序题, 25分)

求森林的叶子结点个数：

输入森林对应的二叉树的先序遍历序列，建立一棵二叉树，将该二叉树看作一个森林的孩子兄弟表示法，输出森林的叶子结点个数。

二叉树结点类型为char,特殊字符为@。

输入二叉树的先序遍历序列：ABD@F@@@CE@@@

输出森林的叶子结点个数：3

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
using namespace std;
typedef long long LL;
const int N = 100;
typedef struct Node {
	char c;
	struct Node* lch;
	struct Node* rch;
}Node;
string s;
void build(Node** root, int& index) {
	if (index >= s.size())return;
	(*root) = (Node*)malloc(sizeof(Node));
	(*root)->c = s[index];
	index++;
	if (s[index] != '@') {
		build(&(*root)->lch, index);
	}
	else {
		(*root)->lch = NULL;
	}
	index++;
	if (s[index] != '@') {
		build(&(*root)->rch, index);
	}
	else {
		(*root)->rch = NULL;
	}
}
void print(Node* r) {
	if (r->lch != NULL) {
		print(r->lch);
	}
	if (r->rch != NULL) {
		print(r->rch);
	}
	printf("%c", r->c);
}
void print1(Node* r) {
	Node* stk[100];
	int f[100];
	int tt = 0;
	Node* p = r;
	while (p != NULL || tt != 0) {
		if (p != NULL) {
			stk[tt] = p;
			f[tt] = 1;
			tt++;
			p = p->lch;
		}
		else {
			if (!f[tt - 1]) {
				printf("%c", stk[tt - 1]->c);
				tt--;
			}
			else {
				p = stk[tt - 1];
				f[tt - 1]--;
				p = p->rch;
			}
		}
	}
}
void print2(Node* r) {
	Node* que[N];
	int tr = 0, tf = 0;
	que[++tr] = r;
	Node* p = NULL;
	while (tr != tf) {
		if ((tf + 1) % N <= tr) {
			tf = (tf + 1) % N;
			p = que[tf];
		}
		printf("%c", p->c);
		if ((tr + 1) % N != tf && p->lch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->lch;
		}
		if ((tr + 1) % N != tf && p->rch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->rch;
		}
	}
}
int F(Node* r) {
	int ret = 0, f[1000] = { 0 };
	Node* que[N];
	int tr = 0, tf = 0;
	que[++tr] = r;
	f[tr] = 1;
	Node* p = NULL;
	while (tr != tf) {
		if ((tf + 1) % N <= tr) {
			tf = (tf + 1) % N;
			p = que[tf];
			ret = max(ret, f[tf]);
		}
		//printf("%c", p->c);
		if ((tr + 1) % N != tf && p->lch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->lch;
			f[tr] = f[tf] + 1;
		}
		if ((tr + 1) % N != tf && p->rch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->rch;
			f[tr] = f[tf] + 1;
		}
	}
	return ret;
}
int F1(Node* r) {
	int ret = 0;
	Node* que[N];
	int tr = 0, tf = 0;
	que[++tr] = r;
	Node* p = NULL;
	while (tr != tf) {
		if ((tf + 1) % N <= tr) {
			tf = (tf + 1) % N;
			p = que[tf];
		}
		if (p->lch == NULL && p->rch == NULL) {
			ret++;
			continue;
		}
		//printf("%c", p->c);
		if ((tr + 1) % N != tf && p->lch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->lch;
		}
		if ((tr + 1) % N != tf && p->rch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->rch;
		}
	}
	return ret;
}
int F2(Node* r) {
	int ret = 0;
	Node* que[N];
	int tr = 0, tf = 0;
	que[++tr] = r;
	Node* p = NULL;
	while (tr != tf) {
		if ((tf + 1) % N <= tr) {
			tf = (tf + 1) % N;
			p = que[tf];
		}
		if (p->lch == NULL) {
			ret++;
		}
		if ((tr + 1) % N != tf && p->lch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->lch;
		}
		if ((tr + 1) % N != tf && p->rch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->rch;
		}
	}
	return ret;
}
int main() {
	cin >> s;
	Node* H = (Node*)malloc(sizeof(Node));
	int index = 0;
	build(&(H->lch), index);
	//print(H->lch);
	//print1(H->lch);
	//print2(H->lch);
	//int ans=F(H->lch);
	//int ans = F1(H->lch);
	int ans = F2(H->lch);//判断条件：没有左孩子，同样的，有多种做法
	cout << ans << endl;
	return 0;
}

6. (程序题, 25分)

输入二叉树的扩展先序遍历序列，建立一棵二叉树，然后建立该二叉树的中序线索二叉树，在中序线索二叉树基础上中序遍历，输出中序遍历序列。二叉树各结点数据类型为字符型，空节点数据为@

二叉树结点类型为char,特殊字符为@。

输入先序遍历序列：ABD@F@@@CE@@@

输出二叉树的中序遍历序列为：DFBAEC

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
using namespace std;
typedef long long LL;
const int N = 100;
typedef struct Node {
	char c;
	struct Node* lch;
	struct Node* rch;
	int ltag, rtag;
}Node;
string s;
void build(Node** root, int& index) {
	if (index >= s.size())return;
	(*root) = (Node*)malloc(sizeof(Node));
	(*root)->c = s[index];
	index++;
	if (s[index] != '@') {
		build(&(*root)->lch, index);
	}
	else {
		(*root)->lch = NULL;
	}
	index++;
	if (s[index] != '@') {
		build(&(*root)->rch, index);
	}
	else {
		(*root)->rch = NULL;
	}
}
Node* pre = NULL;
void F(Node* r) {
	if (r == NULL)return;
	F(r->lch);
	if (r->lch == NULL) {
		r->ltag = 1;
		r->lch = pre;
	}
	else {
		r->ltag = 0;
	}
	if (pre != NULL) {
		if (pre->rch == NULL) {
			pre->rtag = 1;
			pre->rch = r;
		}
		else {
			pre->rtag = 0;
		}
	}
	pre = r;
	F(r->rch);
}
void print(Node* r) {
	Node* p = r;
	while (p != NULL) {
		while (p->lch != NULL && p->ltag == 0) {
			p = p->lch;
		}
		cout << p->c;
		while (p->rtag && p->rch != NULL) {
			p = p->rch;
			cout << p->c;
		}
		p = p->rch;
	}
}
int main() {
	cin >> s;
	Node* H = (Node*)malloc(sizeof(Node));
	int index = 0;
	build(&(H->lch), index);
	F(H->lch);//线索化二叉树，跟书上的写法略微不一样，怎么方便怎么来
	print(H->lch);
	return 0;
}

7. (程序题, 25分)

输入二叉树的扩展的先序遍历序列，建立一棵二叉树，输出中序遍历序列（要求非递归算法）。

二叉树结点类型为char,特殊字符为@。

输入先序遍历序列：ABD@F@@@CE@@@

输出二叉树的中序遍历序列为：DFBAEC

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
using namespace std;
typedef long long LL;
const int N = 100;
typedef struct Node {
	char c;
	struct Node* lch;
	struct Node* rch;
}Node;
string s;
void build(Node** root, int& index) {
	if (index >= s.size())return;
	(*root) = (Node*)malloc(sizeof(Node));
	(*root)->c = s[index];
	index++;
	if (s[index] != '@') {
		build(&(*root)->lch, index);
	}
	else {
		(*root)->lch = NULL;
	}
	index++;
	if (s[index] != '@') {
		build(&(*root)->rch, index);
	}
	else {
		(*root)->rch = NULL;
	}
}
void print(Node* r) {//递归，中序遍历
	if (r->lch != NULL) {
		print(r->lch);
	}
	if (r->rch != NULL) {
		print(r->rch);
	}
	printf("%c", r->c);
}
void print1(Node* r) {//栈，中序遍历
	Node* stk[100];
	int f[100];
	int tt = 0;
	Node* p = r;
	while (p != NULL || tt != 0) {
		if (p != NULL) {
			stk[tt] = p;
			f[tt] = 1;
			tt++;
			p = p->lch;
		}
		else {
			if (!f[tt - 1]) {
				//printf("%c", stk[tt - 1]->c);
				tt--;
			}
			else {
				printf("%c", stk[tt - 1]->c);
				p = stk[tt - 1];
				f[tt - 1]--;
				p = p->rch;
			}
		}
	}
}
void print2(Node* r) {//层次遍历
	Node* que[N];
	int tr = 0, tf = 0;
	que[++tr] = r;
	Node* p = NULL;
	while (tr != tf) {
		if ((tf + 1) % N <= tr) {
			tf = (tf + 1) % N;
			p = que[tf];
		}
		printf("%c", p->c);
		if ((tr + 1) % N != tf && p->lch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->lch;
		}
		if ((tr + 1) % N != tf && p->rch != NULL) {
			tr = (tr + 1) % N;
			que[tr] = p->rch;
		}
	}
}
int main() {
	cin >> s;
	Node* H = (Node*)malloc(sizeof(Node));
	int index = 0;
	build(&(H->lch), index);
	//print(H->lch);
	//cout << endl;
	print1(H->lch);
	//print2(H->lch);
	return 0;
}

8. (程序题, 25分)

二叉树中求结点的祖先

在二叉链表表示的二叉树中（值域为字符型），查找值为x的结点的所有祖先结点并输出。

输入说明：

利用二叉树的先序递归创建二叉树，键盘输入字符序列，已*代表空结点，中间不允许有重复的值，建立二叉树，接着输入字符x。

输出说明：

若x为根，输出：“没有祖先结点”。

若x不存在，则输出：“x不存在”；

否则，依次输出x的祖先结点，从离x最近的父节点开始，输出到根节点，数据之间用一个空格分隔。

注意：此处的输入请采用C++模式，用cin来接收数据。

输入：
ABD**E*F**C**
F
输出：
E B A

输入：
ABD**E*F**C**
G
输出：
G不存在

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
using namespace std;
typedef long long LL;
const int N = 100;
typedef struct Node {
	char c;
	struct Node* lch;
	struct Node* rch;
}Node;
string s;
char x;
void build(Node** root, int& index) {
	if (index >= s.size())return;
	(*root) = (Node*)malloc(sizeof(Node));
	(*root)->c = s[index];
	index++;
	if (s[index] != '*') {
		build(&(*root)->lch, index);
	}
	else {
		(*root)->lch = NULL;
	}
	index++;
	if (s[index] != '*') {
		build(&(*root)->rch, index);
	}
	else {
		(*root)->rch = NULL;
	}
}
void print(Node* r) {
	if (r->lch != NULL) {
		print(r->lch);
	}
	if (r->rch != NULL) {
		print(r->rch);
	}
	printf("%c", r->c);
}
void F(Node* r) {
	if (r->c == x) {
		cout << "没有祖先结点" << endl;
		return;
	}
	Node* p = r;
	Node* stk[N];
	int tt = -1, f[N];
	while (tt != -1 || p != NULL) {
		if (p != NULL) {
			f[++tt] = 1;
			stk[tt] = p;
			p = p->lch;
		}
		else {
			if (f[tt]) {
				p = stk[tt];
				f[tt] = 0;
				p = p->rch;
			}
			else {
				tt--;
			}
		}
		if (p != NULL && p->c == x) {
			break;
		}
	}
	if (tt == -1) {
		cout << x << "不存在" << endl;
	}
	while (tt != -1) {
		cout << stk[tt--]->c << " ";
	}
	cout << endl;
}
int main() {
	cin >> s >> x;
	Node* H = (Node*)malloc(sizeof(Node));
	int index = 0;
	build(&(H->lch), index);
	F(H->lch);//用栈来写中序遍历
	return 0;
}

Landing_on_Mars
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构锐格实验三--实验四：二叉树的常见操作
nefu_Luxembourg的博客
05-10 1130
7080 題目內容: 输入森林对应的二叉树的先序遍历序列，建立一棵二叉树，该二叉树就是森林的孩子兄弟表示法，输出森林的叶子结点个数。 二叉树结点类型为char,特殊字符为@。 例如：森林如下所示 image.png 该森林对应的二叉树的扩展形式如下图所示，将该二叉树看成是森林的孩子兄弟表示法。对空指针域采用@扩展。 image.png 输入二叉树的先序遍历序列：ABD@F@@@CE@@@ 输出森林的叶子结点个数：3 输入输出说明: 输入： ABD@@E@R@@CF@@GI@@@ 输出： 5 在这里插入代码片
[PTA][C语言][数据结构]树—二叉树遍历
weixin_52192405的博客
11-13 4271
二叉树遍历的几个题
数据结构——二叉树的多种操作（C语言实现）
weixin_43204126的博客
11-02 1535
文章目录一 数据结构：二 创建树1.根据输入扩展先序序列创建二叉树2.按照前序和中序遍历结果来创建二叉树3.按照中序和后序遍历结果来创建二叉树三 遍历二叉树1.递归遍历2.非递归遍历前序中序后序层次四 其他操作1.交换左右子树2.寻找最近共同祖先3.根结点到叶子结点的路径4.以树的形态递归打印二叉树5.统计结点个数6.计算某层叶子结点个数7.打印叶子结点所在层8.中序输出叶子五 栈操作六 队列操作...
先序创建二叉树、按逆中序输出该树
coder-itl
11-07 664
【问题描述】二叉树可以采用两种方式存储，其中经常使用的是二叉链表存储方式。利用扩展先序序列创建以二叉链表存储的二叉树，按树状打印此二叉树，求此二叉树的高度以及叶子结点的个数，并输出。 【输入形式】 输入某二叉树的扩展先序序列。（二叉树中元素为 char 类型） 注意：输入的扩展先序序列必须是某二叉树的扩展序列，不能随意输入。 【输出形式】 逆时针旋转90度的二叉树，根节点层次号为 1，每进一层，显示3个空格；输出的二叉树的叶子结点个数和高度，各占一行。 程序实现   /**.
由用户输入一棵扩充二叉树的先序遍历序列 (原二叉树的节点数据均为自然数，扩充二叉树的先序序列中，-1为扩充节点)，先创建该二叉树的二叉链存储结构，然后依次输出每层的结点个数。
weixin_45881557的博客
12-07 169
输入示例:1 2 9 -1 -1 -1 3 4 -1 -1 5 6 -1 -1 -1。输出示例:1 2 3 1 【每个数字后均有空格】由用户输入一棵扩充二叉树的先序遍历序列 (原。序序列中，-1为扩充节点)，先创建该二叉树的。二叉树的节点数据均为自然数，扩充二叉树的先。二叉链存储结构，然后依次输出每层的结点个。
数据结构实验报告汇总
12-28
大学上数据结构课程自己写的数据结构实验，供参考 其中包括：学生管理系统（链表），算术表达式求值（栈和队列），KMPandBF算法，Huffman树和Huffman编码，完全二叉树的操作，学生管理系统plus（排序和查找）
数据结构实验迷宫问题实验报告
11-18
数据结构实验迷宫问题实验报告 本实验报告主要是关于数据结构实验中的迷宫问题，通过设计数据结构存储迷宫、设计存储结构保存从入口到出口的通路、设计算法完成迷宫问题的求解，并分析算法的时间复杂度。 首先，...
北京科技大学数据结构实验
11-27
北京科技大学为计算机科学与技术专业的大二学生提供了丰富的数据结构实验，旨在帮助他们深入理解理论知识，并通过实践提升编程技能。 实验报告-计140.doc可能包含了整个实验课程的概述、实验目的、实验环境、实验...
数据结构实验报告答案.pdf
08-22
数据结构实验报告答案
西北工业大学数据结构实验报告
07-12
包含11次数据结构实验报告以及配套代码，结构完整，符合要求，实验成绩97分。 啰嗦几句： 更加建议大家自己写，我这个更多的是自己的资源存档 有问题的话私信，看到会回复 关于代码，因为当时比较仓促，还没有进行...
二叉树（五）中序线索二叉树的建立
青衣煮茶
12-03 4185
如果ltag值为0，表示lchild指向结点的左孩子，如果ltag=1，表示lchild结点指向结点的前驱；如果rtag=0，表示rchild指向结点的右孩子，如果rtag=1，表示rchild指向结点的后继。 要求输入一个先序创建二叉树所需要的先序序列，按照中序方式输出该二叉树所对应的线索二叉树的每个结点，包括它的ltag，data，rtag三个域的值。二叉树的数据域类型为字符型，扩展二叉树的...
输入二叉树先序序列，输出先序，中序，后序序列
令狐_JackieHao的博客
05-26 8087
/*==================================================== 程序功能：输入二叉树先序序列，输出先序，中序，后序序列 作者：令狐荣豪 完成日期：2019/5/19 =====================================================*/ #include<stdio.h> #include<st...
数据结构—链式二叉树-C语言
h_number_1的博客
07-11 1072
上述内容，即是我个人对数据结构-链式二叉树-搜索二叉树-C语言的个人见解以及自我实现。若有大佬发现哪里有问题可以私信或评论指教一下我这个小萌新。
堆、栈和队列（数据结构）
weixin_50956409的博客
07-10 1142
堆：用于实现优先队列和动态数据结构，操作复杂，适用于需要优先级排序的场景。队列：用于实现先进先出（FIFO）的数据结构，操作简单，适用于需要顺序处理的场景。栈：用于实现后进先出（LIFO）的数据结构，操作简单，适用于需要后入先出的场景。每种数据结构都有其特定的应用场景和优势。在实际编程中，选择合适的数据结构可以大大提高程序的效率和性能。堆上的内存需要程序员手动管理，容易发生内存泄漏。为了避免内存泄漏，程序员应该在不再需要动态分配的内存时，使用free()函数将其释放。
数据结构专项-字符串
qq_52241267的博客
07-16 354
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。深拷贝和浅拷贝：浅拷贝实际上是复制了被拷贝对象的引用，也就是说浅拷贝的和被拷贝对象指向的是同一块内存空间，而深拷贝则是连同引用的对象也被拷贝，两者指向的是不同的内存空间。然后计算乘法，故之后是*，再计算加法，因此+要在6的前面，不然就是计算4*(x+3)+6了，故选D。中缀表达式中应该先计算x+3，因此后缀表达式中+应该出现在x和3的后面，排除BC。
数据结构第26节 广度优先搜索
hummhumm的专栏
07-14 928
首先，我们需要定义迷宫的结构。我们可以用一个二维数组来表示迷宫，其中0代表可通行的空地，1代表墙。为了存储迷宫中的每个位置状态，我们需要创建一个节点类，包含位置坐标和从起点到该位置的距离。int x;int y;this.x = x;this.y = y;
【Java--数据结构】二叉树
最新发布
2301_80898480的博客
07-16 871
如有错误，欢迎指出~
数据结构实验与习题.doc
12-02
数据结构实验与习题.doc

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值