数据结构 查找 上机实验代码 上海大学

验收过的代码，放心食用。实现方法不是最优，因为懒得改。大佬轻喷。

BST

#ifndef BST_H
#define BST_H

#include <bits/stdc++.h>
using namespace std;

class BSTnode{
public:
    int data;
    BSTnode *ls,*rs;
    BSTnode(){}
    BSTnode(int ndata,BSTnode *l=nullptr,BSTnode *r=nullptr):data(ndata),ls(l),rs(r){}
};

class BSCTnode{
public:
    int data,cnt;
    BSCTnode *ls,*rs;
    BSCTnode(){}
    BSCTnode(int ndata,BSCTnode *l=nullptr,BSCTnode *r=nullptr):data(ndata),cnt(1),ls(l),rs(r){}
};

class BST{
public:
    BST():root(nullptr){}
    virtual ~BST();
    void traverse();
    bool find(int elem);
    bool insert(int elem);
    bool del(int elem);
    void findelems(int elem);
private:
    void __del(BSTnode* cur,BSTnode* prev);
    void TraverseMid(BSTnode* now);
    void clear(BSTnode* now);
    void __findelems(int elem,BSTnode* now);
    BSTnode* FindCurrent(int elem,BSTnode* now);
    BSTnode* FindPrev(int elem,BSTnode* now,BSTnode* prev=nullptr);
    BSTnode *root;
};

class BSCT{
public:
    BSCT():root(nullptr){}
    int find(int elem);
    void traverse();
private:
    void __traverse(BSCTnode* now);
    BSCTnode* root;
};

class BIT{
public:
    BIT():root(nullptr){}
    BSTnode* CreatByPrev(vector<int> prev,vector<int> mid,int prel,int prer,int midl,int midr);
    bool isBST();
    void traverse();
private:
    void TraverseByMid(BSTnode* now);
    void __isBST(BSTnode* now,vector<int>& v);
    BSTnode* root;
};

void BST::findelems(int elem){
    __findelems(elem,root);
    cout<<endl;
}

void BSCT::traverse(){
    if(root==nullptr){
        cout<<"empty tree!"<<endl;
        return ;
    }
    __traverse(root);
    cout<<endl;
}

void BSCT::__traverse(BSCTnode* now){
    if(now->ls!=nullptr) __traverse(now->ls);
    cout<<now->data<<"("<<now->cnt<<") ";
    if(now->rs!=nullptr) __traverse(now->rs);
}

int BSCT::find(int elem){
    if(root==nullptr) {
        root = new BSCTnode(elem);
        return 0;
    }
    BSCTnode *now=root,*pre=nullptr;
    while(now){
        if(now->data==elem)
            return ++now->cnt;
        else if(now->data>elem)
            pre = now , now = now->ls;
        else
            pre = now , now = now->rs;
    }
    if(pre->data>elem)
        pre->ls = new BSCTnode(elem);
    else
        pre->rs = new BSCTnode(elem);
    return 0;
}

void BST::__findelems(int elem,BSTnode* now){
    if(now==nullptr) return ;
    if(now->data>elem){
        __findelems(elem,now->rs);
        cout<<now->data<<" ";
        __findelems(elem,now->ls);
    }
    else if(now->data<elem){
        __findelems(elem,now->rs);
    }
    else{
        __findelems(elem,now->rs);
        cout<<now->data<<" ";
    }
}

bool BIT::isBST(){
    if(root==nullptr) return true;
    vector<int> v;
    v.clear();
    __isBST(root,v);
    for(int i=1;i<v.size();i++){
        if(v[i-1]>=v[i]) return false;
    }
    return true;
}

void BIT::__isBST(BSTnode* now,vector<int>& v){
    if(now->ls) __isBST(now->ls,v);
    v.push_back(now->data);
    if(now->rs) __isBST(now->rs,v);
}

void BIT::TraverseByMid(BSTnode* now){
    if(now->ls!=nullptr) TraverseByMid(now->ls);
    cout<<now->data<<" ";
    if(now->rs!=nullptr) TraverseByMid(now->rs);
}

void BIT::traverse(){
    if(root==nullptr) return ;
    TraverseByMid(root);
    cout<<endl;
}

BSTnode* BIT::CreatByPrev(vector<int> prev,vector<int> mid,int prel,int prer,int midl,int midr){
    if(midl>midr) return nullptr;
    BSTnode* now = new BSTnode(prev[prel]);
    int index;
    if(root==nullptr) root = now;
    for(index=midl;index<=midr;index++)
        if(prev[prel]==mid[index])
            break;
    now->ls = CreatByPrev(prev,mid,prel+1,prel+index-midl,midl,index-1);
    now->rs = CreatByPrev(prev,mid,prel+index-midl+1,prer,index+1,midr);
    return now;
}

void BST::__del(BSTnode* cur,BSTnode* prev){
    if(cur->ls==nullptr&&cur->rs==nullptr&&prev!=nullptr){  //叶子节点
        if(prev->ls==cur) prev->ls=nullptr;
        else prev->rs=nullptr;
        delete cur;
        return ;
    }
    if(cur->ls==nullptr&&cur->rs==nullptr&&prev==nullptr){  //特判根节点
        delete root;
        root=nullptr;
        return ;
    }
    if(cur->ls!=nullptr){   //找直接前驱
        BSTnode *p=cur->ls , *pp = cur;
        while(p->rs!=nullptr)
            pp = p , p = p->rs;
        cur->data = p->data;
        __del(p,pp);
    }
    else{                   //不存在直接前驱时，找直接后驱
        BSTnode *p=cur->rs , *pp = cur;
        while(p->ls!=nullptr)
            pp = p , p = p->ls;
        cur->data = p->data;
        __del(p,pp);
    }
}

bool BST::del(int elem){
    /*
        parameter：删除元素的值
        先找到父节点 （注意特判根节点）
        调用工具函数 __del删除结点

        __del函数：
        判断当前节点是否是叶子节点，如果是则直接删掉
        注意特判根节点

        如果不是根节点，则找直接前驱或直接后继替代该节点的位置
        然后递归删除该直接前驱或后继

        return：是否删除成功
    */
    if(root==nullptr) return false;
    BSTnode *prev = FindPrev(elem,root) , *cur=nullptr;
    if(root->data==elem){
        __del(root,nullptr);
        return true;
    }
    if(prev->ls!=nullptr&&prev->ls->data==elem){
        cur = prev->ls;
        __del(cur,prev);
        return true;
    }
    if(prev->rs!=nullptr&&prev->rs->data==elem){
        cur = prev->rs;
        __del(cur,prev);
        return true;
    }
    return false;
}

void BST::TraverseMid(BSTnode* now){
    if(now->ls) TraverseMid(now->ls);
    cout<<now->data<<" ";
    if(now->rs) TraverseMid(now->rs);
}

void BST::traverse(){
    if(root==nullptr) return ;
    TraverseMid(root);
    cout<<endl;
}

BST::~BST(){
    if(root==nullptr) return ;
    clear(root);
}

void BST::clear(BSTnode* now){
    if(now->ls!=nullptr) clear(now->ls);
    if(now->rs!=nullptr) clear(now->rs);
    delete now;
}

BSTnode* BST::FindPrev(int elem,BSTnode* now,BSTnode* prev){
    if(now==nullptr||now->data==elem) return prev;
    if(now->data>elem) return FindPrev(elem,now->ls,now);
    else return FindPrev(elem,now->rs,now);
}

bool BST::insert(int elem){
    if(root==nullptr){
        root = new BSTnode(elem);
        return true;
    }
    BSTnode* prev = FindPrev(elem,root);
    if(prev==nullptr&&root->data==elem){            //elem is root
        return false;
    }
    else if(prev->data>elem&&prev->ls==nullptr){    //elem exist
        prev->ls = new BSTnode(elem);
        return true;
    }
    else if(prev->data>elem&&prev->ls->data==elem){ //elem does not exist
        return false;
    }
    else if(prev->data<elem&&prev->rs==nullptr){
        prev->rs = new BSTnode(elem);
        return true;
    }
    else{
        return false;
    }
}

bool BST::find(int elem){
    return FindCurrent(elem,root)!=nullptr;
}

BSTnode* BST::FindCurrent(int elem,BSTnode* now){
    if(now==nullptr) return nullptr;
    if(now->data==elem) return now;
    if(now->data>elem) return FindCurrent(elem,now->ls);
    else return FindCurrent(elem,now->rs);
}

#endif /* BST_H */

AVL

#ifndef AVL_H
#define AVL_H

#include <bits/stdc++.h>
using namespace std;

class node{
public:
    int data,h,lsize,size;
    node *ls,*rs;
    node(){}
    node(int nelem,node* l=nullptr,node* r=nullptr):data(nelem),size(1),lsize(1),h(1),ls(nullptr),rs(nullptr){}
};

class AVL{
public:
    AVL():root(nullptr){}
    AVL(vector<int> &v);
    void traverse();
    void insert(int elem);
    bool find(int elem);
    void del(int elem);
    void findelems(int elem);
    int kth(int x);
private:
    int __kth(int x,node* rt);
    void __findelems(int elem,node* rt);
    node* __del(int elem,node* rt);
    node* __insert(int elem,node* rt);
    bool __find(int elem,node* rt);
    int get_balance(node* rt) {return rt==nullptr?0:get_h(rt->ls)-get_h(rt->rs);}
    int get_h(node *rt) {return rt==nullptr?0:rt->h;}
    int get_lsize(node *rt) {return rt==nullptr?0:rt->lsize;};
    int get_size(node *rt) {return rt==nullptr?0:rt->size;};
    void pushup(node *rt);
    void __traverse(node* now);
    node* ll_rotate(node *rt);
    node* rr_rotate(node *rt);
    node* lr_rotate(node *rt);
    node* rl_rotate(node *rt);
    node* root;
};

int AVL::kth(int x){
    if(root==nullptr) {
        cout<<"empty tree!"<<endl;
        return -1;
    }
    if(x<0||x>root->size){
        cout<<"illegal input"<<endl;
        return -1;
    }
    return __kth(x,root);
}

int AVL::__kth(int x,node* rt){
    if(rt->lsize==x) return rt->data;
    else if(rt->lsize>x) return __kth(x,rt->ls);
    else return __kth(x-rt->lsize,rt->rs);
}

void AVL::pushup(node *rt){
    rt->h = max(get_h(rt->ls),get_h(rt->rs))+1;
    rt->size = get_size(rt->ls)+get_size(rt->rs)+1;
    rt->lsize = get_size(rt->ls)+1;
}

void AVL::findelems(int elem){
    if(root==nullptr) {
        cout<<"empty tree!"<<endl;
        return ;
    }
    __findelems(elem,root);
}

void AVL::__findelems(int elem,node* rt){
    if(rt==nullptr) return ;
    if(rt->data>elem){
        __findelems(elem,rt->ls);
        cout<<rt->data<<" ";
        __findelems(elem,rt->rs);
    }
    if(rt->data<=elem){
        __findelems(elem,rt->rs);
    }
}

AVL::AVL(vector<int> &v){
    root=nullptr;
    for(vector<int>::iterator it=v.begin();it!=v.end();it++)
        insert(*it);
}

void AVL::del(int elem){
    if(root==nullptr) return ;
    root = __del(elem,root);
}

node* AVL::__del(int elem,node* rt){
    if(rt==nullptr) return nullptr;
    if(rt->data>elem) rt->ls = __del(elem,rt->ls);
    else if(rt->data<elem) rt->rs = __del(elem,rt->rs);
    else {
        if(rt->ls!=nullptr){
            node* p=rt->ls;
            while(p->rs)
                p = p->rs;
            rt->data = p->data;
            rt->ls = __del(rt->data,rt->ls);
        }else if(rt->ls==nullptr && rt->rs!=nullptr){
            node* p=rt->rs;
            while(p->ls)
                p = p->ls;
            rt->data = p->data;
            rt->rs = __del(rt->data,rt->rs);
        }else{
            delete rt;
            return nullptr;
        }
    }
    pushup(rt);
    int delta = get_balance(rt);
    int delta_ls = get_balance(rt->ls);
    int delta_rs = get_balance(rt->rs);
    if(delta>1 && delta_ls>0)
        return ll_rotate(rt);
    if(delta>1 && delta_ls<0)
        return lr_rotate(rt);
    if(delta<-1 && delta_rs>0)
        return rl_rotate(rt);
    if(delta<-1 && delta_rs<0)
        return rr_rotate(rt);
    return rt;
}

bool AVL::find(int elem){
    if(root==nullptr) return false;
    return __find(elem,root);
}

bool AVL::__find(int elem,node* rt){
    if(rt==nullptr) return false;
    if(rt->data==elem) return true;
    if(rt->data>elem) return __find(elem,rt->ls);
    if(rt->data<elem) return __find(elem,rt->rs);
    return false;
}

void AVL::insert(int elem){
    if(root==nullptr){
        root = new node(elem);
        return ;
    }
    root = __insert(elem,root);
}

node* AVL::__insert(int elem,node* rt){
    if(rt==nullptr)
        return new node(elem);
    if(rt->data>elem) 
        rt->ls = __insert(elem,rt->ls);
    else if(rt->data<elem) 
        rt->rs = __insert(elem,rt->rs);
    else 
        return new node(elem);
    pushup(rt);
    int delta = get_balance(rt);
    int delta_ls = get_balance(rt->ls);
    int delta_rs = get_balance(rt->rs);
    if(delta>1 && delta_ls>0)
        return ll_rotate(rt);
    if(delta>1 && delta_rs<0)
        return lr_rotate(rt);
    if(delta<-1 && delta_rs>0)
        return rl_rotate(rt);
    if(delta<-1 && delta_rs<0)
        return rr_rotate(rt);
    return rt;
}

node* AVL::lr_rotate(node *rt){
    rt->ls = rr_rotate(rt->ls);
    return ll_rotate(rt->rs);
}

node* AVL::rl_rotate(node *rt){
    rt->rs = ll_rotate(rt->rs);
    return rr_rotate(rt);
}

node* AVL::rr_rotate(node *rt){
    node *tmp = rt->rs;
    rt->rs = tmp->ls;
    tmp->ls = rt;
    pushup(rt);
    pushup(tmp);
    return tmp;
}

node* AVL::ll_rotate(node *rt){
    node *tmp = rt->ls;
    rt->ls = tmp->rs;
    tmp->rs = rt;
    pushup(rt);
    pushup(tmp);
    return tmp;
}

void AVL::traverse(){
    if(root==nullptr){
        cout<<"empty tree!"<<endl;
        return ;
    }
    __traverse(root);
    cout<<endl;
}

void AVL::__traverse(node *now){
    if(now->ls!=nullptr) __traverse(now->ls);
    cout<<now->data<<" ";
    if(now->rs!=nullptr) __traverse(now->rs);
}

#endif /* AVL_H */

主函数

#include <bits/stdc++.h>
#include "BST.h"
#include "AVL.h"
using namespace std;

void test01(){
    /*binary search lower_bound*/
    int a[12] = {1,1,2,2,3,3,4,4,5,5,7,7};
    cout<<my_lower_bound(a,12,5)<<endl;
}

void test02(){
    /*BST*/
    // 8
    BST tree;
    int m,x;
    cin>>m;
    for(int i=0;i<m;i++){
        int data;
        cin>>data;
        tree.insert(data);
        tree.traverse();
    }
    cout<<"findelems: "<<endl;
    cin>>x;
    tree.findelems(x);
    cout<<"del: "<<endl;
    for(int i=0;i<m;i++){
        int data;
        cin>>data;
        tree.del(data);
        tree.traverse();
    }
}

void test03(){
    /*is BST*/
    // 7
    vector<int> pre = {5,3,1,4,7,9,6};
    vector<int> mid = {1,3,4,5,9,7,6};
    BIT tree;
    tree.CreatByPrev(pre,mid,0,pre.size()-1,0,mid.size()-1);
    cout<<tree.isBST()<<endl;
    tree.traverse();
}

/*
vector<int> pre = {5,3,1,4,7,6,9};
vector<int> mid = {1,3,4,5,6,7,9};
*/

void test04(){
    // 10
    BSCT tree;
    int m;
    cin>>m;
    while(m--){
        int elem;
        cin>>elem;
        cout<<"result query: "<<tree.find(elem)<<endl<<"total elem: ";
        tree.traverse();
    }
}

void test05(){
    // 9
    vector<int> v={10,5,1,7,15,12,20};
    AVL tree(v);
    tree.traverse();
    for(int i=1;i<=8;i++)
        cout<<tree.kth(i)<<endl;
    //tree.findelems(10);
}

int main(){
    test04();
    //system("PAUSE");
    return 0;
}