数据结构 04-树6 Complete Binary Search Tree (30 分)

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

 

 

题目要求给定一个序列建立完全二叉搜索树, 然后输出层序遍历结果

按部就班的来, 先建立一个给定序列的完全二叉树

　　因为完全二叉搜索树的中序遍历就是从小到大的一个序列  ,将给定的序列存入数组, 从小到大排序, 然后按照中序遍历的结点顺序给结点赋 数组对应次序位置的值 

    void inOrderTraversal(tnode* p){
        if(!p)return;
        inOrderTraversal(p->left);
        p->data=numList[count++];
        inOrderTraversal(p->right);
    }

　　然后层序遍历输出结点值就可以

　　

　　可以看看别人怎么做的  https://www.liuchuo.net/archives/2161

　　

 

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef int ElementType;
class tnode{
public:
    ElementType data;
    tnode* left{nullptr};
    tnode* right{nullptr};
    tnode()=default;
    tnode(int d):data{d}{};
};

class CBSTtree {
public:
    tnode* root{nullptr};
    vector<int> numList;
    int count{0};
    CBSTtree():root{nullptr}{};
    void initiation(){
        
    }
    tnode* insertNode(tnode* &p,int &n){
        if(!p){
            p=new tnode{n};
        }else{
            if(!p->left){
                p->left=new tnode{n};
            }else if(!p->right){
                p->right=new tnode{n};
            }
        }
        return p;
    }
    void build(){
        vector<tnode*> nodeList;
        vector<tnode*>::iterator it;
        tnode* p;
        int n,temp;
        cin >> n;
        cin >> temp;
        numList.push_back(temp);
        root=insertNode(root, temp);
        nodeList.push_back(root);
        for(int i=0;i<n-1;i++){
            if(nodeList.size()){
                cin >> temp;
                numList.push_back(temp);
                p=nodeList.front();
                p=insertNode(p, temp);
                if(p->left&&p->right){
                    nodeList.push_back(p->left);
                    nodeList.push_back(p->right);
                    nodeList.erase(nodeList.begin());
                }
            }
        }
        sort(numList.begin(), numList.end());
    }
    void inOrderTraversal(tnode* p){
        if(!p)return;
        inOrderTraversal(p->left);
        p->data=numList[count++];
        inOrderTraversal(p->right);
    }
    void levelOrderTraversal(tnode* root){
        vector<tnode*> nodeList;
        tnode* p=root;
        int count=0;
        nodeList.push_back(p);
        while(nodeList.size()){
            p=nodeList.front();
            if(p->left){
                nodeList.push_back(p->left);
            }
            if(p->right){
                nodeList.push_back(p->right);
            }
            if(count!=0)cout << " ";
            cout << p->data;
            count ++;
            nodeList.erase(nodeList.begin());
        }
        
    }
};

int main(){
    CBSTtree t;
    t.build();
    t.inOrderTraversal(t.root);
    t.levelOrderTraversal(t.root);
    return 0;
}