2023/03/20 机试学习记录

KY212 二叉树遍历

描述

二叉树的前序、中序、后序遍历的定义： 前序遍历：对任一子树，先访问根，然后遍历其左子树，最后遍历其右子树； 中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树； 后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。 给定一棵二叉树的前序遍历和中序遍历，求其后序遍历（提示：给定前序遍历与中序遍历能够唯一确定后序遍历）。

代码

#include<cstdio>
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<stack>
using namespace std;

struct treeNode {
	char data;
	treeNode* leftChild;
	treeNode* rightChild;
	treeNode(char c) : data(c), leftChild(NULL), rightChild(NULL) {}
};

treeNode* reBuild1(string preOrder, string inOrder) {
	if (preOrder.size() == 0)
		return nullptr;
	char rootData = preOrder[0];
	treeNode* root = new treeNode(rootData);
	int position = inOrder.find(rootData);
	root->leftChild = reBuild1(preOrder.substr(1, position), inOrder.substr(0, position));
	root->rightChild = reBuild1(preOrder.substr(position + 1), inOrder.substr(position + 1));
	return root;
}

void postOrder(treeNode* node) {
	if (node == nullptr)
		return;
	postOrder(node->leftChild);
	postOrder(node->rightChild);
	
	cout << node->data;
}
int main() {
	string preOrder, inOrder;
	while (cin >> preOrder >> inOrder) {
		treeNode* root = reBuild1(preOrder, inOrder);
		postOrder(root);
		cout << endl;
	}
	return 0;
}

KY207 二叉排序树

描述

二叉排序树，也称为二叉查找树。可以是一颗空树，也可以是一颗具有如下特性的非空二叉树： 1. 若左子树非空，则左子树上所有节点关键字值均不大于根节点的关键字值； 2. 若右子树非空，则右子树上所有节点关键字值均不小于根节点的关键字值； 3. 左、右子树本身也是一颗二叉排序树。 现在给你N个关键字值各不相同的节点，要求你按顺序插入一个初始为空树的二叉排序树中，每次插入后成功后，求相应的父亲节点的关键字值，如果没有父亲节点，则输出-1。

代码

#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;

struct treeNode {
	int data;
	treeNode* leftChild;
	treeNode* rightChild;
	treeNode(int c) : data(c), leftChild(NULL), rightChild(NULL) {}
};

treeNode* Insert(treeNode* root, int data, int father) {
	if (root == NULL) {
		root = new treeNode(data);
		cout << father << endl;
	}
	else if (data < root->data) {
		root->leftChild = Insert(root->leftChild, data, root->data);
	}
	else {
		root->rightChild = Insert(root->rightChild, data, root->data);
	}
	return root;
}
int main() {
	int n;
	while (cin >> n) {
		treeNode* root = NULL;
		for (int i = 0; i < n; i++) {
			int x;
			cin >> x;
			root = Insert(root, x, -1);
		}
	}
	return 0;
}

KY223 二叉排序树

描述

输入一系列整数，建立二叉排序树，并进行前序，中序，后序遍历。

输入描述：

输入第一行包括一个整数n(1<=n<=100)。 接下来的一行包括n个整数。

输出描述：

可能有多组测试数据，对于每组数据，将题目所给数据建立一个二叉排序树，并对二叉排序树进行前序、中序和后序遍历。 每种遍历结果输出一行。每行最后一个数据之后有一个换行。 输入中可能有重复元素，但是输出的二叉树遍历序列中重复元素不用输出。

代码

#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;

struct treeNode {
	int data;
	treeNode* leftChild;
	treeNode* rightChild;
	treeNode(int c) : data(c), leftChild(NULL), rightChild(NULL) {}
};
treeNode* Insert(treeNode* root, int data) {
	if (root == NULL) {
		root = new treeNode(data);
	}
	else if (data < root->data) {
		root->leftChild = Insert(root->leftChild, data);
	}
	else if (root->data < data) {
		root->rightChild = Insert(root->rightChild, data);
	}
	return root;
}

void PreOrder(treeNode* root) {
	if (root == NULL)
		return;
	cout << root->data << " ";
	PreOrder(root->leftChild);
	PreOrder(root->rightChild);
	return;
}
void InOrder(treeNode* root) {
	if (root == NULL)
		return;
	InOrder(root->leftChild);
	cout << root->data << " ";
	InOrder(root->rightChild);
	return;
}
void PostOrder(treeNode* root) {
	if (root == NULL)
		return;
	PostOrder(root->leftChild);
	PostOrder(root->rightChild);
	cout << root->data << " ";
	return;
}
int main() {
	int n;
	while (cin >> n) {
		treeNode* root = NULL;
		for (int i = 0; i < n; i++) {
			int x;
			cin >> x;
			root = Insert(root, x);
		}
		PreOrder(root);
		cout << endl;
		InOrder(root);
		cout << endl;
		PostOrder(root);
		cout << endl;
	}
	return 0;
}

KY124 二叉搜索树

描述

判断两序列是否为同一二叉搜索树序列

输入描述：

开始一个数n，(1<=n<=20) 表示有n个需要判断，n= 0 的时候输入结束。 接下去一行是一个序列，序列长度小于10，包含(0~9)的数字，没有重复数字，根据这个序列可以构造出一颗二叉搜索树。 接下去的n行有n个序列，每个序列格式跟第一个序列一样，请判断这两个序列是否能组成同一颗二叉搜索树。

#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;

struct treeNode {
	int data;
	treeNode* leftChild;
	treeNode* rightChild;
	treeNode(int c) : data(c), leftChild(NULL), rightChild(NULL) {}
};

treeNode* Insert(treeNode* root, int data) {
	if (root == NULL) {
		root = new treeNode(data);
	}
	else if (data < root->data) {
		root->leftChild = Insert(root->leftChild, data);
	}
	else if (root->data < data) {
		root->rightChild = Insert(root->rightChild, data);
	}
	return root;
}
bool flag;
void check(treeNode* root, treeNode* judge) 
{
	if (root != NULL && judge != NULL) 
	{
		if (root->data != judge->data)
			flag = false;
		check(root->leftChild, judge->leftChild); 
		check(root->rightChild, judge->rightChild);
	}
	else if (root != NULL || judge != NULL)
		flag = false;
}
int main() {
	int n;
	while (cin >> n) {
		string s, com;
		cin >> com;
		treeNode* root = NULL;
		for (int i = 0; i < com.size(); i++) {
			root = Insert(root, com[i] - '0');
		}

		for (int i = 0; i < n; i++) {
			treeNode* root1 = NULL;
			cin >> s;
			for (int i = 0; i < s.size(); i++) {
				root1 = Insert(root1, s[i] - '0');
			}
            flag = true;
			check(root, root1);
			if (flag)
				cout << "YES" << endl;
			else
				cout << "NO" << endl;
		}
	}
	return 0;
}