PAT A 1099. Build A Binary Search Tree (30)

本文详细介绍了如何使用递归方法计算二叉查找树的子树大小,对输入序列进行排序,然后根据左右子树的大小递归构建树。最后通过广度优先搜索(BFS)输出层序遍历的结果。

摘要生成于 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.

    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、递归统计各个子树的左右子树的大小

    2、对输入的数值排序

    3、由根向叶根据左右子树大小,递归求得相应位置对应的值,并构建树

    4、bfs层序遍历输出


    代码:

    #include <iostream>
    #include <algorithm>
    #include <vector>
    #include <deque>
    using namespace std;
    
    struct node	//树中的点
    {
    	int val;	//值
    	node *left,*right;	//左右子节点
    	node(int v):val(v),left(NULL),right(NULL){}
    };
    
    int cal_sub(int id,vector<int> &sub,vector<int> &child);	//计算相应id节点的左右子树大小
    node *build(int id,int begin,vector<int> &child,vector<int> &sub,vector<int> &val);	//构造树
    
    int main()
    {
    	int n;
    	cin>>n;
    
    	vector<int> child(2*n,-1);	//i*2,i*2+1,分别为节点i的两个孩子
    	vector<int> num_sub(2*n,-1);	//i*2,i*2+1,分别为节点i的两个子树的大小
    	for(int i=0;i<n;i++)
    		cin>>child[2*i]>>child[2*i+1];
    	cal_sub(0,num_sub,child);	//递归计算子树的大小
    
    	vector<int> val(n);		//输入的序列
    	for(int i=0;i<n;i++)
    		cin>>val[i];
    	sort(val.begin(),val.end());	//排序
    
    	node *root=build(0,0,child,num_sub,val);	//树,构造
    	deque<node*> queue(1,root);	//bfs队列
    	node *tnp1;
    	while(!queue.empty())	//bfs
    	{
    		tnp1=queue.front();
    		queue.pop_front();
    		if(tnp1!=NULL)
    		{
    			if(tnp1->left!=NULL)
    				queue.push_back(tnp1->left);
    			if(tnp1->right!=NULL)
    				queue.push_back(tnp1->right);
    			cout<<tnp1->val;
    			if(!queue.empty())
    				cout<<" ";
    		}
    	}
    
    	return 0;
    }
    
    int cal_sub(int id,vector<int> &sub,vector<int> &child)	//id,子树大小存储序列,左右孩子信息
    {
    	if(id==-1)
    		return 0;
    	if(sub[2*id]==-1)
    	{
    		sub[2*id]=cal_sub(child[id*2],sub,child);
    		sub[2*id+1]=cal_sub(child[id*2+1],sub,child);
    	}
    	return sub[2*id]+sub[2*id+1]+1;
    }
    
    //不构造树,用序列来存储其实就可以了……id,相应子树的最小元素在整个树中的位置,节点孩子序列,子树大小序列,值序列。
    node *build(int id,int begin,vector<int> &child,vector<int> &sub,vector<int> &val)
    {
    	if(id==-1)
    		return NULL;
    	node *root=new node(val[begin+sub[id*2]]);
    	root->left=build(child[id*2],begin,child,sub,val);
    	root->right=build(child[id*2+1],begin+sub[id*2]+1,child,sub,val);
    	return root;
    }
    

    
【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、付费专栏及课程。

余额充值