1099 Build A Binary Search Tree (30分)

本文介绍了一种算法,通过给定的二叉树结构和一组整数,构建唯一的二叉搜索树(BST)。文章详细阐述了如何通过中序遍历确保BST的性质,再进行层序遍历来输出树的结构。最后,提供了完整的C++代码实现。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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.

figBST.jpg

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

题意:给你一棵二叉树的结构(n个结点),然后给你n个数,把树填进二叉树中,构成一棵二叉排序树。

思路:二叉排序树的中序遍历为递增序列,把二叉树结构建好后,输出中序遍历节点下标,然后再把给定的n个数递增排序。用一个数组来记录下标(0-N-1)与数的对应关系,然后再把二叉树结构层序遍历,并按下标顺序输出对应的数,既为结果。

#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
struct node
{
    int data;
    node * lchild;
    node * rchild;
};
int n;
vector<vector<int> > vec;
vector<int> in_order_num(n);
vector<int> in_num(n);
node * creat_tree(int start){
    if(start == -1){
        return NULL;
    }

    node * root = new node();
    root -> data = start;

    root -> lchild = creat_tree(vec[start][0]);
    root -> rchild = creat_tree(vec[start][1]);


    return root;



}
int q = 0;
void in_order(node * t){
    if(t == NULL){
        return;
    }
    in_order(t -> lchild);
    in_order_num[t -> data] = in_num[q];
    q++;
    in_order(t -> rchild);
}

void level_order(node *t){
    queue<node *> que;
    que.push(t);

    while (!que.empty())
    {
        printf("%s%d",que.front() == t ? "" : " ", in_order_num[que.front() -> data]);
        if(que.front() -> lchild != NULL){
            que.push(que.front() -> lchild);
        }
        if(que.front() -> rchild != NULL){
            que.push(que.front() -> rchild);
        }
        que.pop();
    }
    


}
int main(){

    cin >> n;
    vec.resize(n);
    in_order_num.resize(n);
    in_num.resize(n);
    for(int i = 0; i < n; i++){
        int l, r;
        scanf("%d %d", &l, &r);
        vec[i].push_back(l);
        vec[i].push_back(r);
    }
    for(int i = 0; i < n; i++){
  
        scanf("%d", &in_num[i]);

    }
    sort(in_num.begin(), in_num.end());
    
    node * tree = creat_tree(0);
    in_order(tree);
    level_order(tree);



    return 0;
}

 

【Solution】 To convert a binary search tree into a sorted circular doubly linked list, we can use the following steps: 1. Inorder traversal of the binary search tree to get the elements in sorted order. 2. Create a doubly linked list and add the elements from the inorder traversal to it. 3. Make the list circular by connecting the head and tail nodes. 4. Return the head node of the circular doubly linked list. Here's the Python code for the solution: ``` class Node: def __init__(self, val): self.val = val self.prev = None self.next = None def tree_to_doubly_list(root): if not root: return None stack = [] cur = root head = None prev = None while cur or stack: while cur: stack.append(cur) cur = cur.left cur = stack.pop() if not head: head = cur if prev: prev.right = cur cur.left = prev prev = cur cur = cur.right head.left = prev prev.right = head return head ``` To verify the accuracy of the code, we can use the following test cases: ``` # Test case 1 # Input: [4,2,5,1,3] # Output: # Binary search tree: # 4 # / \ # 2 5 # / \ # 1 3 # Doubly linked list: 1 <-> 2 <-> 3 <-> 4 <-> 5 # Doubly linked list in reverse order: 5 <-> 4 <-> 3 <-> 2 <-> 1 root = Node(4) root.left = Node(2) root.right = Node(5) root.left.left = Node(1) root.left.right = Node(3) head = tree_to_doubly_list(root) print("Binary search tree:") print_tree(root) print("Doubly linked list:") print_list(head) print("Doubly linked list in reverse order:") print_list_reverse(head) # Test case 2 # Input: [2,1,3] # Output: # Binary search tree: # 2 # / \ # 1 3 # Doubly linked list: 1 <-> 2 <-> 3 # Doubly linked list in reverse order: 3 <-> 2 <-> 1 root = Node(2) root.left = Node(1) root.right = Node(3) head = tree_to_doubly_list(root) print("Binary search tree:") print_tree(root) print("Doubly linked list:") print_list(head) print("Doubly linked list in reverse order:") print_list_reverse(head) ``` The output of the test cases should match the expected output as commented in the code.
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值