查询二叉树——Binary Sort Tree 设计与实现

二叉排序树（Binary Sort Tree）又称二叉查找树。 它或者是一棵空树；或者是具有下列性质的二叉树：

（1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

（2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值；

（3）左、右子树也分别为二叉排序树；

本代码是基本的结构，而更优的结构可以保证查询速度更快。

Size Balanced Tree(SBT)

AVL树

红黑树

Treap（Tree+Heap）

这些均可以使查找树的高度为O(log(n))。

如果插入次序是经过排序的，那么这种普通的二叉排序树的效果就差得一塌糊涂，由于树的偏移，树的深度是O（n），对于增删改查四个操作，每次操作都是O(n)的，这种情况完全不能满足要求。

 

 

#define LENGTH 5
#include <iostream>
#include <vector>
#include <windows.h>
#include <cmath>
using namespace std;
class Balanced_Binary_Tree{
private:
    int infor;
    int balance_index;
    Balanced_Binary_Tree *left;
    Balanced_Binary_Tree *right;
    Balanced_Binary_Tree *father;
public:
    friend int get_height(Balanced_Binary_Tree*);
    friend void print_tree(Balanced_Binary_Tree*);
    friend Balanced_Binary_Tree* exist(int);
    friend Balanced_Binary_Tree* get_max(Balanced_Binary_Tree*);
    friend Balanced_Binary_Tree* get_min(Balanced_Binary_Tree*);
    friend Balanced_Binary_Tree* search(int);
    friend void insert_node(int);
    friend void delete_node(int);
    friend void rotate(Balanced_Binary_Tree*);
    friend int max_distance(Balanced_Binary_Tree*);// a function for count the max distance between any two node in a BT
    friend void Balanced_Binary_Tree_Test();
    Balanced_Binary_Tree(int a){
        infor=a;
        left=NULL;
        right=NULL;
        father=NULL;
        Set_Balance_Index();
    }
    Balanced_Binary_Tree(){
        left=NULL;
        right=NULL;
        father=NULL;
        infor = -1;
        Set_Balance_Index();
    }
    void Set_Balance_Index(){
        balance_index = get_height(left) - get_height(right);
    }
    ~Balanced_Binary_Tree(){cout<<"Delete    "<<infor<<"    !"<<endl;}
    void print(){
        cout<<infor;
    }
};
static Balanced_Binary_Tree* Start = new Balanced_Binary_Tree(-2147483648);
int get_height(Balanced_Binary_Tree* t)
{
    if(t == NULL)
        return 0;
    else{
        int leftH=get_height((*t).left);
        int rightH=get_height((*t).right);
        return (leftH > rightH)?(leftH+1):(rightH+1);
    }
}
//返回这个节点的高度
int max_distance(Balanced_Binary_Tree* root){
    if(root == NULL)return 0;
    else{
        int distance;
        distance = get_height((*root).left)+get_height((*root).right);
        return distance;
    }
}
//返回整个树的最大距离
Balanced_Binary_Tree* exist(int a){
    if((*Start).right == NULL)
    {            
        return NULL;
    }
    else{
        Balanced_Binary_Tree *t = new Balanced_Binary_Tree();
        t = (*Start).right;
        while(t!=NULL){
            if(a<(*t).infor){
                t=(*t).left;
            }
            else if(a>(*t).infor){
                t=(*t).right;
            }
            else if(a == (*t).infor)
                break;
        }//while
        return t;
    }//else
}//
//exist 判断一个数据是否在排序树上，找到返回引用，未找到返回NULL；这是用在对数据进行判定的
Balanced_Binary_Tree* search(int a){
    if(exist(a)==NULL)
    {
        if((*Start).right == NULL)
        {            
            return Start;
        }
        else{
            Balanced_Binary_Tree *t = new Balanced_Binary_Tree();
            Balanced_Binary_Tree *q = new Balanced_Binary_Tree();
            t = (*Start).right;
            while(t!=NULL){
                q = t;
                if(a<(*t).infor){
                    t=(*t).left;
                }
                else{
                    t=(*t).right;
                }
            }//while
            return q;
        }//else
    }//if(!exist a)
    else return NULL;
}//
//search 查找一个数据应该插入的位置；不存在树时候返回头结点，存在树的时候，返回最后的结点的引用；这用于处理对数据插入过程中的插入位置判断。
void insert_node(int a)
{
    if(exist(a)==NULL)
    {
        Balanced_Binary_Tree *n = new Balanced_Binary_Tree(a);
        Balanced_Binary_Tree *t;
        t = search(a);
        (*n).father = t;
        if((*t).infor>a)
        {    (*t).left=n;    }
        else 
        {    (*t).right=n;    }
        // 首先将这个节点插入树上
        while(t!=Start){
            t->Set_Balance_Index();
            if(abs(t->balance_index)>=2)
                break;
            t = t->father;
        }
        //判断这个树是不是平衡的
        if(t!=Start){
            rotate(t);
        }//这个子树不平衡
        //if(t!=Start)
    }//if(exist(a)==NULL)
}
//插入数据，如果数据不存在，就插入
//当平衡的二叉排序树因为插入节点而失去平衡的时候，仅仅需要对最小不平衡子树进行平衡旋转处理。
//因为经过旋转处理的子树深度与之前相同，因此不影响插入路径上所有祖先节点的平衡度。
void rotate(Balanced_Binary_Tree *t){
            if(t->balance_index == 2){
                t->left->Set_Balance_Index();
                if(t->left->balance_index == 1){
                    Balanced_Binary_Tree *temp;
                    temp = t->left;
                    if((t->father->infor)>(t->infor))
                        t->father->left = temp;                    
                    else 
                        t->father->right = temp;
                    temp->father = t->father;
                    t->left = temp->right;
                    if(temp->right != NULL){
                        temp->right->father = t;                    
                    }
                    temp->right = t;
                    t->father = temp;    
                }//if(t->left->balance_index == 1)
                else{
                    Balanced_Binary_Tree *A,*B,*C;
                    A = t;
                    B = t->left;
                    C = B->right;
                    if((A->father->infor)>(A->infor))
                        A->father->left = C;                    
                    else 
                        A->father->right = C;
                    C->father = A->father;

                    A->father = C;
                    B->father = C;

                    A->left = C->right;
                    if(C->right != NULL)
                        C->right->father = A;

                    B->right = C->left;
                    if(C->left != NULL)
                        C->left->father = B;

                    C->right = A;
                    C->left = B;                    

                }//if(t->left->balance_index == -1)
            }//if(t->balance_index == 2)
            else {
                if(t->right->balance_index == -1){
                    Balanced_Binary_Tree *temp;
                    temp = t->right;
                    if((t->father->infor)>(t->infor))
                        t->father->left = temp;                    
                    else 
                        t->father->right = temp;
                    temp->father = t->father;
                    t->right = temp->left;
                    if(temp->left != NULL){
                        temp->left->father = t;
                    }
                    temp->left = t;
                    t->father = temp;
                }//if(t->right->balance_index == -1)
                else{
                    Balanced_Binary_Tree *A,*B,*C;
                    A = t;
                    B = t->right;
                    C = B->left;
                    if((A->father->infor)>(A->infor))
                        A->father->left = C;                    
                    else 
                        A->father->right = C;
                    C->father = A->father;
                    
                    A->father = C;
                    B->father = C;

                    A->right = C->left;
                    if(C->left != NULL)
                        C->left->father = A;

                    B->left = C->right;
                    if(C->right != NULL)
                        C->right->father = B;

                    C->right = B;
                    C->left = A;
                }//if(t->right->balance_index == 1)
            }
}


Balanced_Binary_Tree* get_min(Balanced_Binary_Tree* a)
{
    Balanced_Binary_Tree *t;
    t=a;
    while((*a).left!=NULL){
        t=a;
        a=(*a).left;
    }
    return t;
}
//找到最左节点
Balanced_Binary_Tree* get_max(Balanced_Binary_Tree* a)
{
    Balanced_Binary_Tree *t;
    while((*a).right!=NULL){
        t=a;
        a=(*a).right;
    }
    return t;
}
//找到最右节点
void delete_node(int a){
    if(exist(a)!=NULL)
    {
        Balanced_Binary_Tree *t=exist(a);
        if((*t).left==NULL&&(*t).right==NULL)
        {
            if((*(*t).father).infor>(*t).infor){
                (*(*t).father).left = NULL;
            }
            else (*(*t).father).right = NULL;
        }
        //删除的节点无子节点
        else if((*t).left==NULL||(*t).right==NULL)
        {
            
            if((*t).left == NULL)
            {
                if((*(*t).father).infor>(*t).infor){
                    (*(*t).father).left = (*t).right;
                }
                else (*(*t).father).right = (*t).right;
                (*(*t).right).father = (*t).father;
            }
            else{
                if((*(*t).father).infor>(*t).infor){
                    (*(*t).father).left = (*t).left;
                }
                else (*(*t).father).right = (*t).left;
                (*(*t).left).father = (*t).father;
            }
        }
        //删除的节点有一个子节点
        else{
            if((*(*t).father).infor>(*t).infor){
                    (*(*t).father).left = (*t).right;
                    (*(*t).left).father = get_min((*t).right);
                    Balanced_Binary_Tree *a = get_min((*t).right);
                    (*a).left = (*t).left;
                    (*(*t).right).father = (*t).father;
                }
            else {
                (*(*t).father).right = (*t).right;
                (*(*t).left).father = get_min((*t).right);
                Balanced_Binary_Tree *a = get_min((*t).right);
                (*a).left = (*t).left;
                (*(*t).right).father = (*t).father;
            }
        }
        //删除的节点有两个子节点
        Balanced_Binary_Tree *delete_node = t;
        while(t!=Start){
            t->Set_Balance_Index();
            if(abs(t->balance_index)>=2)
                break;
            t = t->father;
        }
        if(t!=Start){
            rotate(t);
        }
        (*delete_node).left =NULL;
        (*delete_node).right =NULL;
        (*delete_node).father=NULL;
        delete delete_node;
        //delete t;
    }
}
//删除数据，如果数据存在，就删除
void print_void(int k){
    while(k--)cout<<"  ";
}
//打印k个制表符
void print_tree(Balanced_Binary_Tree* t){
    Balanced_Binary_Tree* temp = t;
    vector<Balanced_Binary_Tree*> list;
    list.push_back(temp);
    int k = get_height(t);
    while(k--){
        int print_length = pow((double)2,(double)k);
        int length = list.size();
        vector<Balanced_Binary_Tree*>::iterator iter;
        iter = list.begin();
        int number_son = list.size();
        print_void(print_length);
        for(int j=0;j<number_son;j++){
            if((*iter)->infor == -1)
                cout<<"*";
            else 
                (*iter)->print();
            if((*iter)->left == NULL)    {
                t = new Balanced_Binary_Tree();
                list.push_back(t);
                iter = list.begin()+j;
            }
            else {
                list.push_back((*iter)->left);
                iter = list.begin()+j;
            }
            if((*iter)->right == NULL)    {
                t = new Balanced_Binary_Tree();
                list.push_back(t);
                iter = list.begin()+j;
            }
            else {
                list.push_back((*iter)->right);
                iter = list.begin()+j;
            }
            iter++;
            print_void(print_length*2);
        }
        list.erase(list.begin(),list.begin()+number_son);
        cout<<endl;
    }
}

void Balanced_Binary_Tree_Test()
{
    
    int test[LENGTH] = {1,3,5,4,2};
    for(int a=0;a<LENGTH;a++){
        insert_node(test[a]);
    }
    

    //TEST PART
    //int a;
    //while(cin>>a)insert_node(a);
    //TEST PART
    char c;
    int i;
    cout<<"AVL Tree!"<<endl;
    cout<<"d——delete a node;    "<<endl;
    cout<<"g——get the node's information;    "<<endl;
    cout<<"i——insert a node;    "<<endl;
    cout<<"l——get max length of the sub_tree;"<<endl;
    cout<<"c——clear the screen;"<<endl;
    cout<<"else——quit the test;"<<endl;
    while(cin>>c>>i){
        cout<<"AVL Tree!"<<endl;
        cout<<c<<" "<<i<<endl;
        cout<<"d——delete a node;    "<<endl;
        cout<<"g——get the node's information;    "<<endl;
        cout<<"i——insert a node;    "<<endl;
        cout<<"l——get max length of the sub_tree;"<<endl;
        cout<<"c——clear the screen;"<<endl;
        cout<<"else——quit the test;"<<endl;
        switch(c){
        case 'c':{
                system("cls");
                break;
                     }
        case 'g':
            {
                Balanced_Binary_Tree *t = new Balanced_Binary_Tree();
                t = exist(i);
                if(t==NULL){
                    cout<<"The node "<<i<<" do not exist!"<<endl;
                        }
                print_tree(Start->right);
                break;
            }
        case 'd':
            {
                Balanced_Binary_Tree *t = new Balanced_Binary_Tree();
                t = exist(i);
                if(t==NULL){
                    cout<<"The node "<<i<<" do not exist!"<<endl;
                }
                else{
                    delete_node((*t).infor);
                }
                print_tree(Start->right);
                break;
            }
        case 'i':
            {
                Balanced_Binary_Tree *t = new Balanced_Binary_Tree();
                t = exist(i);
                if(t==NULL){
                    cout<<"The node "<<i<<" do not exist!"<<endl;
                    insert_node(i);
                }
                else cout<<"The node "<<i<<" already exist!"<<endl;
                print_tree(Start->right);
                break;
            }
        case 'l':
            {
                Balanced_Binary_Tree *t = new Balanced_Binary_Tree();
                t = exist(i);
                if(t==NULL){
                    cout<<"The node "<<i<<" do not exist!"<<endl;
                }
                else{
                    int l = max_distance(t);
                    print_tree(Start->right);
                    cout<<"max distance of sub tree "<<i<<" is " <<l<<endl;
                }
                break;
            }
        default:break;
        }
    }
}


int main(void)
{
    Balanced_Binary_Tree_Test();
    return 0; 
}

 

使用print（）函数打印这个树，通过广度优先遍历实现。

运行效果：

AVL Tree!
i 3
d——delete a node;
g——get the node's information;
i——insert a node;
l——get max length of the sub_tree;
c——clear the screen;
else——quit the test;
The node 3 already exist!
        3
    1        5
  *    2    4    *
i -4
AVL Tree!
i -4
d——delete a node;
g——get the node's information;
i——insert a node;
l——get max length of the sub_tree;
c——clear the screen;
else——quit the test;
The node -4 do not exist!
        3
    1        5
  -4    2    4    *
i -6
AVL Tree!
i -6
d——delete a node;
g——get the node's information;
i——insert a node;
l——get max length of the sub_tree;
c——clear the screen;
else——quit the test;
The node -6 do not exist!
                3
        1                5
    -4        2        4        *
  -6    *    *    *    *    *    *    *