PAT练习笔记——9.4 二叉查找树（BST）

最新推荐文章于 2022-06-06 14:07:27 发布

qream

最新推荐文章于 2022-06-06 14:07:27 发布

阅读量277

点赞数

分类专栏： PAT 文章标签： PAT 2019.9 算法笔记

本文链接：https://blog.csdn.net/weixin_44073967/article/details/100823723

版权

PAT 专栏收录该内容

35 篇文章 1 订阅

订阅专栏

2019年9月PAT - 练习笔记——9.4

以下页码标注的是阅读器中实际页码，而不是书本身自印的页码。

第9章提高篇（3）——数据结构专题（2）

9.4 二叉查找树（BST）

这章好难orz

注意

BST左子树<根，右子树≥根
BST的中序遍历序列是不减的
对完全二叉树当中的任何一个结点（设编号为x，其中根结点编号为1），其左孩子结点的编号一定是2x，而右孩子结点的编号一定是2x+1
BST的前序序列中，(a >= u && a <= v) || (a >= v && a <= u)，说明a是u和v的共同最低祖先

A1043 Is it a Binary Search Tree
A1064 Complete Binary Search Tree
A1099 Build a Binary Search Tree

A1043 Is it a Binary Search Tree

A Binary Search Tree (BST) is recursively defined as a binary tree which has the following properties:

The left subtree of a node contains only nodes with keys less than the node’s key.
The right subtree of a node contains only nodes with keys greater than or equal to the node’s key.
Both the left and right subtrees must also be binary search trees.

If we swap the left and right subtrees of every node, then the resulting tree is called the Mirror Image of a BST.

Now given a sequence of integer keys, you are supposed to tell if it is the preorder traversal sequence of a BST or the mirror image of a BST.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (≤1000). Then N integer keys are given in the next line. All the numbers in a line are separated by a space.

Output Specification:

For each test case, first print in a line YES if the sequence is the preorder traversal sequence of a BST or the mirror image of a BST, or NO if not. Then if the answer is YES, print in the next line the postorder traversal sequence of that tree. All the numbers in a line must be separated by a space, and there must be no extra space at the end of the line.

Sample Input 1:

7
8 6 5 7 10 8 11

Sample Output 1:

YES
5 7 6 8 11 10 8

Sample Input 2:

7
8 10 11 8 6 7 5

Sample Output 2:

YES
11 8 10 7 5 6 8

Sample Input 3:

7
8 6 8 5 10 9 11

Sample Output 3:

NO

我的
```
orz
```

《算法笔记》P324

“对镜像树的先序遍历只需要在原树的先序遍历时交换左右子树的访问顺序即可”
“本题也可以在读入数据时同时建立其镜像二叉树，只需要将插入时的比较逻辑反过来即可。这样先序遍历只需要各写一个函数。”

#include <cstdio>
#include <vector>

using namespace std;

struct node {
    int data;
    node *left, *right;
};

void insert(node* &root, int data)
{
    if (root == NULL) {	// 到达空结点时，即为需要插入的位置
        root = new node;
        root->data = data;
        root->left = root->right = NULL;
        return;
    }
    if (data < root->data) insert(root->left, data);
    else insert(root->right, data);
}
void preOrder(node* root, vector<int>& vi)
{
    if (root == NULL) return;
    vi.push_back(root->data);
    preOrder(root->left, vi);
    preOrder(root->right, vi);
}
void preOrderMirror(node* root, vector<int>& vi)
{
    if (root == NULL) return;
    vi.push_back(root->data);
    preOrderMirror(root->right, vi);
    preOrderMirror(root->left, vi);
}
void postOrder(node* root, vector<int>& vi)
{
    if (root == NULL) return;
    postOrder(root->left, vi);
    postOrder(root->right, vi);
    vi.push_back(root->data);
}
void postOrderMirror(node* root, vector<int>& vi)
{
    if (root == NULL) return;
    postOrderMirror(root->right, vi);
    postOrderMirror(root->left, vi);
    vi.push_back(root->data);
}

vector<int> origin, pre, preM, post, postM;
int main()
{
    int n, data;
    node* root = NULL;
    scanf("%d", &n);
    for (int i = 0;i < n;i++) {
        scanf("%d", &data);
        origin.push_back(data);
        insert(root, data);
    }
    preOrder(root, pre);
    preOrderMirror(root, preM);
    postOrder(root, post);
    postOrderMirror(root, postM);
    if (origin == pre) {
        printf("YES\n");
        for (int i = 0;i < post.size();i++) {
            printf("%d", post[i]);
            if (i < post.size() - 1) printf(" ");
        }
    }
    else if (origin == preM) {
        printf("YES\n");
        for (int i = 0;i < postM.size();i++) {
            printf("%d", postM[i]);
            if (i < postM.size() - 1) printf(" ");
        }
    }
    else printf("NO\n");
    return 0;
}

我写的时候总是想把BST的判断和树的建立合并，写不出来orz

柳神：https://www.liuchuo.net/archives/2153

A1064 Complete Binary Search Tree

A Binary Search Tree (BST) is recursively defined as a binary tree which has the following properties:
- The left subtree of a node contains only nodes with keys less than the node’s key.
- The right subtree of a node contains only nodes with keys greater than or equal to the node’s key.
- Both the left and right subtrees must also be binary search trees.
A Complete Binary Tree (CBT) is a tree that is completely filled, with the possible exception of the bottom level, which is filled from left to right.

Now given a sequence of distinct non-negative integer keys, a unique BST can be constructed if it is required that the tree must also be a CBT. You are supposed to output the level order traversal sequence of this BST.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (≤1000). Then N distinct non-negative integer keys are given in the next line. All the numbers in a line are separated by a space and are no greater than 2000.

Output Specification:

For each test case, print in one line the level order traversal sequence of the corresponding complete binary search tree. All the numbers in a line must be separated by a space, and there must be no extra space at the end of the line.

Sample Input:
```
10
1 2 3 4 5 6 7 8 9 0
```
Sample Output:
```
6 3 8 1 5 7 9 0 2 4
```
1. 我的
```
忘记完全二叉树的性质了orz
```
  1. 《算法笔记》P328
    1. “步骤1：在配套用书9.1.3节已经讲过，如果使用数组来存放完全二叉树，那么对完全二叉树当中的任何一个结点（设编号为x，其中根结点编号为1），其左孩子结点的编号一定是2x，而右孩子结点的编号一定是2x+1。那么就可以开一个数组CBT[max]，其中CBT[1]~CBT[n]按层序存放完全二叉树的n个结点，这个数组就存放了一棵完全二叉树，只不过暂时还没有为其元素进行赋值。”
    2. “步骤2：考虑到对一棵二叉排序树来说，其中序遍历序列是递增的，那么思路就很清晰了：先将输入的数字从小到大排序，然后对CBT数组表示的二叉树进行中序遍历，并在遍历过程中将数字从小到大填入数组，最后就能得到一棵完全二叉排序树。而由于CBT数组就是按照二叉树的层序拍存放结点的，因此只需要将数组元素按顺序输出即为层序遍历序列”
```
#include <cstdio>
#include <algorithm>

using namespace std;

const int maxn = 1010;

int n, number[maxn], CBT[maxn], index = 0;
void inOrder(int root)
{
    if (root > n) return;
    inOrder(root * 2);
    CBT[root] = number[index++];
    inOrder(root * 2 + 1);
}

int main()
{
    scanf("%d", &n);
    for (int i = 0;i < n;i++) scanf("%d", &number[i]);
    sort(number, number + n);
    inOrder(1);
    for (int i = 1;i <= n;i++) {
        printf("%d", CBT[i]);
        if (i < n) printf(" ");
    }
    return 0;
}
```
A1099 Build a Binary Search Tree

A Binary Search Tree (BST) is recursively defined as a binary tree which has the following properties:
- The left subtree of a node contains only nodes with keys less than the node’s key.
- The right subtree of a node contains only nodes with keys greater than or equal to the node’s key.
- Both the left and right subtrees must also be binary search trees.
Given the structure of a binary tree and a sequence of distinct integer keys, there is only one way to fill these keys into the tree so that the resulting tree satisfies the definition of a BST. You are supposed to output the level order traversal sequence of that tree. The sample is illustrated by Figure 1 and 2.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤100) which is the total number of nodes in the tree. The next N lines each contains the left and the right children of a node in the format left_index right_index, provided that the nodes are numbered from 0 to N−1, and 0 is always the root. If one child is missing, then −1 will represent the NULL child pointer. Finally N distinct integer keys are given in the last line.

Output Specification:

For each test case, print in one line the level order traversal sequence of that tree. All the numbers must be separated by a space, with no extra space at the end of the line.

Sample Input:
```
9
1 6
2 3
-1 -1
-1 4
5 -1
-1 -1
7 -1
-1 8
-1 -1
73 45 11 58 82 25 67 38 42
```
Sample Output:
```
58 25 82 11 38 67 45 73 42
```
1. 我的
```
#include <iostream>
#include <vector>
#include <algorithm> 
#include <queue> 

using namespace std;

typedef struct {
	int left;
	int key;
	int right;
}Node;

int n = 0;
vector<Node> tree;
vector<int> keys;

int index = 0;
void InTravel(int now)
{
	if (index >= n) return;
	
	int left = tree[now].left, right = tree[now].right;
	if (left != -1) InTravel(left);
	tree[now].key = keys[index++];
	if (right != -1) InTravel(right);
}

void LevelTravel(int root)
{
	queue<int> q;
	q.push(root);
	
	while (!q.empty()) {
		int now = q.front(); 
		int left = tree[now].left, right = tree[now].right;
		if (left != -1) q.push(left);
		if (right != -1) q.push(right);
		q.pop();
		
		if (now != root) printf(" ");
		printf("%d", tree[now].key);
	}
}

int main(void)
{
	scanf("%d", &n);
	tree.resize(n);
	keys.resize(n);
	
	for (int i = 0;i < n;++i) {
		int left = 0, right = 0;
		scanf("%d %d", &left, &right);
		tree[i] = {left, -1, right};
	}
	for (int i = 0;i < n;++i) scanf("%d", &keys[i]);
	sort(keys.begin(), keys.end());
	
	InTravel(0);
	LevelTravel(0);
	
	return 0;
}
```
2. 《算法笔记》P330

qream

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
PAT练习笔记——9.4 二叉查找树（BST）

2019年9月PAT - 练习笔记——9.4以下页码标注的是阅读器中实际页码，而不是书本身自印的页码。第9章提高篇（3）——数据结构专题（2）9.4 二叉查找树（BST）这章好难orz注意BST左子树<根，右子树≥根BST的中序遍历序列是不减的对完全二叉树当中的任何一个结点（设编号为x，其中根结点编号为1），其左孩子结点的编号一定是2x，而右孩子结点的编号一定是2x+1...
复制链接

扫一扫