问题 A: DS二叉排序树之创建和插入
题目描述
给出一个数据序列，建立二叉排序树，并实现插入功能
对二叉排序树进行中序遍历，可以得到有序的数据序列
输入
第一行输入t，表示有t个数据序列
第二行输入n，表示首个序列包含n个数据
第三行输入n个数据，都是自然数且互不相同，数据之间用空格隔开
第四行输入m，表示要插入m个数据
从第五行起，输入m行，每行一个要插入的数据，都是自然数且和前面的数据不等
以此类推输入下一个示例
输出
第一行输出有序的数据序列，对二叉排序树进行中序遍历可以得到
从第二行起，输出插入第m个数据后的有序序列，输出m行
以此类推输出下一个示例的结果
样例输入
1
6
22 33 55 66 11 44
3
77
50
10
样例输出
11 22 33 44 55 66
11 22 33 44 55 66 77
11 22 33 44 50 55 66 77
10 11 22 33 44 50 55 66 77
AC代码
#include<iostream>
using namespace std;
struct BiNode {
int data;
BiNode* lChild, * rChild;
BiNode(int data = 0, BiNode* lChild = NULL, BiNode* rChild = NULL) :data(data), lChild(lChild), rChild(rChild) {}
};
class BSTree {
BiNode* root;
void destruct(BiNode* node) {
if (!node)
return;
destruct(node->lChild);
destruct(node->rChild);
delete node;
}
void print(BiNode* node) {
if (!node)
return;
print(node->lChild);
cout << node->data << " ";
print(node->rChild);
}
void SearchNode(BiNode*& root, int data) {
if (!root)
{
root = new BiNode(data);
return;
}
if (root->data == data)
return;
if (root->data > data)
SearchNode(root->lChild, data);
else
SearchNode(root->rChild, data);
}
public:
BSTree() { root = NULL; }
void CreateBST()
{
root = NULL;
int n, data;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> data;
SearchNode(root, data);
}
}
void insert(int data) {
SearchNode(root, data);
}
void print() {
print(root);
putchar('\n');
}
~BSTree()
{
destruct(root);
}
};
int main() {
int n;
cin >> n;
while (n--)
{
BSTree b;
b.CreateBST();
b.print();
int t;
cin >> t;
while (t--)
{
int temp;
cin >> temp;
b.insert(temp);
b.print();
}
}
return 0;
}
问题 B: DS二叉排序树之查找
题目描述
给出一个数据序列，建立二叉排序树，并实现查找功能
对二叉排序树进行中序遍历，可以得到有序的数据序列
输入
第一行输入t，表示有t个数据序列
第二行输入n，表示首个序列包含n个数据
第三行输入n个数据，都是自然数且互不相同，数据之间用空格隔开
第四行输入m，表示要查找m个数据
从第五行起，输入m行，每行一个要查找的数据，都是自然数
以此类推输入下一个示例
输出
第一行输出有序的数据序列，对二叉排序树进行中序遍历可以得到
从第二行起，输出查找结果，如果查找成功输出查找次数，如果查找失败输出-1
以此类推输出下一个示例的结果
样例输入
1
6
22 33 55 66 11 44
7
11
22
33
44
55
66
77
样例输出
11 22 33 44 55 66
2
1
2
4
3
4
-1
AC代码
#include<iostream>
using namespace std;
struct BiNode {
int data;
BiNode* lChild, * rChild;
BiNode(int data = 0, BiNode* lChild = NULL, BiNode* rChild = NULL) :data(data), lChild(lChild), rChild(rChild) {}
};
class BSTree {
BiNode* root;
void destruct(BiNode* node) {
if (!node)
return;
destruct(node->lChild);
destruct(node->rChild);
delete node;
}
void print(BiNode* node) {
if (!node)
return;
print(node->lChild);
cout << node->data << " ";
print(node->rChild);
}
void insert(BiNode*& root, int data) {
if (!root)
{
root = new BiNode(data);
return;
}
if (root->data == data)
return;
if (root->data > data)
insert(root->lChild, data);
else
insert(root->rChild, data);
}
public:
BSTree() { root = NULL; }
void CreateBST()
{
root = NULL;
int n, data;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> data;
insert(root, data);
}
}
void insert(int data) {
insert(root, data);
}
void print() {
print(root);
putchar('\n');
}
int find(int data)
{
int cnt = 0;
BiNode* p = root;
while (p)
{
cnt++;
if (p->data == data)
return cnt;
if (p->data > data)
p = p->lChild;
else
p = p->rChild;
}
return -1;
}
~BSTree()
{
destruct(root);
}
};
int main() {
int n;
cin >> n;
while (n--)
{
BSTree b;
b.CreateBST();
b.print();
int t;
cin >> t;
while (t--)
{
int temp;
cin >> temp;
cout << b.find(temp) << endl;
}
}
return 0;
}
问题 C: DS二叉排序树之删除
题目描述
给出一个数据序列，建立二叉排序树，并实现删除功能
对二叉排序树进行中序遍历，可以得到有序的数据序列
输入
第一行输入t，表示有t个数据序列
第二行输入n，表示首个序列包含n个数据
第三行输入n个数据，都是自然数且互不相同，数据之间用空格隔开
第四行输入m，表示要删除m个数据
从第五行起，输入m行，每行一个要删除的数据，都是自然数
以此类推输入下一个示例
输出
第一行输出有序的数据序列，对二叉排序树进行中序遍历可以得到
从第二行起，输出删除第m个数据后的有序序列，输出m行
以此类推输出下一个示例的结果
样例输入
1
6
22 33 55 66 11 44
3
66
22
77
样例输出
11 22 33 44 55 66
11 22 33 44 55
11 33 44 55
11 33 44 55
提示
当删除数据不在序列中，那么删除操作等于不执行，所以输出序列不变化
AC代码
#include<iostream>
using namespace std;
struct BiNode {
int data;
BiNode* lChild, * rChild;
BiNode(int data = 0, BiNode* lChild = NULL, BiNode* rChild = NULL) :data(data), lChild(lChild), rChild(rChild) {}
};
class BSTree {
BiNode* root;
void destruct(BiNode* node) {
if (!node)
return;
destruct(node->lChild);
destruct(node->rChild);
delete node;
}
void print(BiNode* node) {
if (!node)
return;
print(node->lChild);
cout << node->data << " ";
print(node->rChild);
}
void insert(BiNode*& root, int data) {
if (!root)
{
root = new BiNode(data);
return;
}
if (root->data == data)
return;
if (root->data > data)
insert(root->lChild, data);
else
insert(root->rChild, data);
}
void deleteNode(BiNode*& node, int data) {
if (!node)
return;
if (node->data > data) {
deleteNode(node->lChild, data);
return;
}
if (node->data < data) {
deleteNode(node->rChild, data);
return;
}
if (node->lChild && node->rChild) {
BiNode* p = node->lChild;
while (p->rChild)
p = p->rChild;
node->data = p->data;
deleteNode(node->lChild, p->data);
return;
}
BiNode* p = node;
if (node->lChild == NULL)
node = node->rChild;
else if (node->rChild == NULL)
node = node->lChild;
delete p;
}
public:
BSTree() { root = NULL; }
void CreateBST()
{
root = NULL;
int n, data;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> data;
insert(root, data);
}
}
void insert(int data) {
insert(root, data);
}
void print() {
print(root);
putchar('\n');
}
int find(int data)
{
int cnt = 0;
BiNode* p = root;
while (p)
{
cnt++;
if (p->data == data)
return cnt;
if (p->data > data)
p = p->lChild;
else
p = p->rChild;
}
return -1;
}
void erase(int data) { deleteNode(root, data); }
~BSTree()
{
destruct(root);
}
};
int main() {
int n;
cin >> n;
while (n--)
{
BSTree b;
b.CreateBST();
b.print();
int t;
cin >> t;
while (t--)
{
int temp;
cin >> temp;
b.erase(temp);
b.print();
}
}
return 0;
}
问题 D: DS查找—二叉树平衡因子
题目描述
二叉树用数组存储，将二叉树的结点数据依次自上而下,自左至右存储到数组中，一般二叉树与完全二叉树对比，比完全二叉树缺少的结点在数组中用0来表示。
计算二叉树每个结点的平衡因子，并按后序遍历的顺序输出结点的平衡因子。
–程序要求–
若使用C++只能include一个头文件iostream；若使用C语言只能include一个头文件stdio
程序中若include多过一个头文件，不看代码，作0分处理
不允许使用第三方对象或函数实现本题的要求
输入
测试次数t
每组测试数据一行，数组元素个数n，后跟n个字符，二叉树的数组存储。
输出
对每组测试数据，按后序遍历的顺序输出树中结点的平衡因子（测试数据没有空树）
样例输入
2
6 ABC00D
24 ABCD0EF0000H00000000000I
样例输出
B 0
D 0
C 1
A -1
D 0
B 1
I 0
H 1
E 2
F 0
C 2
A -2
AC代码
#include<iostream>
using namespace std;
int getLeftChild(int index) { return 2 * index + 1; }
int getRightChild(int index) { return 2 * index + 2; }
int getHign(const string& tree, int index = 0) {
if (tree[index] == '0')
return 0;
return max(getHign(tree, getLeftChild(index)), getHign(tree, getRightChild(index))) + 1;
}
int getBalanceFoctor(const string& tree, int index) {
return getHign(tree, getLeftChild(index)) - getHign(tree, getRightChild(index));
}
void dispalyBalanceFoctor(const string& tree, int index = 0) {
if (tree[index] == '0')
return;
dispalyBalanceFoctor(tree, getLeftChild(index));
dispalyBalanceFoctor(tree, getRightChild(index));
cout << tree[index] << " " << getBalanceFoctor(tree, index) << endl;
}
int main() {
int n;
cin >> n;
while (n--)
{
string tree;
int len;
cin >> len >> tree;
tree.append(2 * len, '0');
dispalyBalanceFoctor(tree);
}
return 0;
}
问题 E: DS二叉树判断–同一棵二叉树？
题目描述
二叉树分别以数组存储方式创建、以先序遍历序列创建。输入二叉树的数组存储、先序遍历结果，判断根据它们创建的二叉树是否是同一棵二叉树。
输入
测试次数t
每组测试数据两行：
第一行：二叉树的数组存储（英文字母表示树结点，#表示空树）
第二行：二叉树的先序遍历结果(英文字母表示树结点，#表示空树）
输出
对每组测试数据，如果两种方式创建的是同一棵二叉树，输出YES，否则，输出NO。
样例输入
3
ABCDE
ABD##E##C##
ABC##DE####W##F
AB##CDW###E#F##
abc##d
ab##c#d##
样例输出
YES
YES
NO
AC代码
#include<iostream>
using namespace std;
int getLeftChild(int index) { return 2 * index + 1; }
int getRightChild(int index) { return 2 * index + 2; }
void preOrderTravel(const string& tree, string& s, int index = 0) {
s.push_back(tree[index]);
if (tree[index] == '#')
return;
preOrderTravel(tree, s, getLeftChild(index));
preOrderTravel(tree, s, getRightChild(index));
}
string getPreOrderTravel(const string& tree) {
string s;
preOrderTravel(tree, s);
return s;
}
int main() {
int n;
cin >> n;
while (n--) {
string tree, s;
cin >> tree >> s;
tree.append(tree.length() * 2, '#');
if (getPreOrderTravel(tree) == s)
puts("YES");
else
puts("NO");
}
return 0;
}
354
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
