二叉查找树

最新推荐文章于 2021-08-01 23:21:48 发布

喜欢吃肉的饭

最新推荐文章于 2021-08-01 23:21:48 发布

阅读量107

点赞数 1

分类专栏：数据结构&算法

本文链接：https://blog.csdn.net/wodemale/article/details/89356430

版权

数据结构&算法专栏收录该内容

29 篇文章 1 订阅

订阅专栏

查找树是一种数据结构，支持多种动态集合操作，既可以用作字典也可以用作优先队列。在二叉树上执行的基本操作的时间与树成正比。
对于一个含有n个结点的完全二叉树，这些操作的最坏运行时间是O(lgn).
一颗随机构造的二叉查找树的期望高度为O(lgn)，从而这种树上的基本动态操作的平均时间为O(lgn)

二叉查找树
是按二叉树结构来组织的，这种树可以用链表结构表示，每一个节点都是一个对象。
二叉查找树的关键字，按照左孩子的数值，小于等于父节点的数值，右孩子的数值大于等于父节点的数值。
可以用一个递归的算法，输出树的所有元素按顺序排列，使用中序遍历算法。相应的还有前序和后续遍历算法。
遍历一颗含有n个结点的二叉查找树所需时间为O(n)

查询二叉查找树
查找是按照二叉查找树的结构特点，大于查找右边，小于查找左边，相等则输出。算法运行的时间为O(h)，h为树高。这是递归的方式进行的操作。
也可以使用while来代替递归，该方法大多数情况下运行得更加快。

最大关键字和最小关键字
查找最小关键字，直接沿着节点的left指针查找下去，。直到遇见NIL为止。同理最大关键字沿着right指针一直查找。

前驱后继
后继，如果是中序遍历，则是大于关键字中最小的那一个。
对于一个高度为h的二叉树，动态集合操作查找，求最大值最小值，查找前驱后继操作的运行时间均为O(h)。

插入和删除操作
二叉查找树是一种动态查找表，可以进行动态地插入和删除。前面的定义中我们假定二叉查找树不含有相同元素。
由定义可知二叉查找树的中序序列为一个递增序列
常见的二叉查找树操作有求最小元素findMin()，求最大元素findMax()，判断查找树是否非空isEmpty()，判断是否包含给定元素contains()，输出所有元素printTree()，置空查找树makeEmpty()，向查找树中插入给定元素x，insert(x)，在查找树中删除给定元素x，remove(x)。
下面先讨论最重要的插入和删除操作，接着给出完整的C风格实现。
1、基本结构定义

 class Student  
{  
    public:  
        int key;  
        string major;  
        Student(int k=int(),string s="") : key(k), major(s){}  
        void operator=(const Student& rhs);  
};  
typedef Student ElementType;  
typedef int KeyType;  
  
typedef struct BSTNode  
{  
    ElementType data;  
    struct BSTNode* lchild;  
    struct BSTNode* rchild;  
}BSTNode, *BST;  
详细信息请看后面完整程序

2、插入
(1) 不允许插入相同关键字，若二叉查找树中存在该关键字，则不插入
(2) 我们可以先检索二叉树，看查找树中是否含有该关键字，若不存在，再做一次扫描将结点插入到适当位置。使用这种方式，为插入一个该关键字，做了两次扫描。
(3) 注意到，插入的结点总是作为某一叶子节点的子结点，我们可以在第一次扫描过程中就确定待插入的位置，即把查找是否存在该关键字和查找可能的插入点在一次扫描中完成，提高插入效率。
(4) 查找递归实现

/* 
  description:在以t为根结点的二叉查找树中，查找关键字为key的结点 
  若查找成功，指针p指向该结点，返回true, 
  否则指向查找路径上的最后一个结点并返回false 
  指针f指向根结点t的父节点  
*/  
bool searchBST_recursion(BST t, KeyType key, BSTNode* f, BSTNode*& p)  
{  
    if(t == NULL)//查找失败   
    {  
        p = f;  
        return false;  
    }  
    else if(key == t->data.key)//查找成功   
    {  
        p = t;  
        return true;  
    }  
    else if(key < t->data.key)  
        return searchBST_recursion(t->lchild,key,t,p);//左子树中继续查找   
    else   
        return searchBST_recursion(t->rchild,key,t,p);//右子树中继续查找   
}  
(6)  插入给定元素

void insertBST(BST& t,ElementType elem)  
{  
    BSTNode * p = NULL;  
    if(!searchBST(t, elem.key, NULL, p))//查找失败，不含该关键字，可以插入   
    {  
        BSTNode * s = new BSTNode;  
        s->data = elem;//可能需要重载=   
        s->lchild = NULL;  
        s->rchild = NULL;  
          
        if(p == NULL)//查找树为空   
        {  
            t = s;//置s为根结点   
        }  
        else if(elem.key < p->data.key)  
        {  
            p->lchild = s;   //*s为p左结点   
        }  
        else  
        {  
            p->rchild = s;   //*s为p右结点   
        }  
    }  
}

3、删除
在二叉查找树中删除一个给定的结点p有三种情况
(1) 结点p无左右子树，则直接删除该结点，修改父节点相应指针
(2) 结点p有左子树（右子树），则把p的左子树（右子树）接到p的父节点上
(3) 左右子树同时存在，则有三种处理方式
a. 找到结点p的中序直接前驱结点s，把结点s的数据转移到结点p，然后删除结点s，由于结点s为p的左子树中最右的结点，因而s无右子树，删除结点s可以归结到情况(2)。严蔚敏数据结构P230-231就是该处理方式。
b. 找到结点p的中序直接后继结点s，把结点s的数据转移到结点p，然后删除结点s，由于结点s为p的右子树总最左的结点，因而s无左子树，删除结点s可以归结到情况(2)。算法导论第2版P156-157该是该处理方式。
c. 找到p的中序直接前驱s，将p的左子树接到父节点上，将p的右子树接到s的右子树上，然后删除结点p。

使用处理方式a的代码如下：
//从二叉查找树中删除指针p所指向的结点 ,p非空,删除前驱方式

void removeNode1(BSTNode *& p)  
{  
    BSTNode *q = NULL;  
    if(!p->rchild)//*p的右子树为空   
    {  
        q = p;  
        p = p->lchild;  
        delete q;  
    }  
    else if(!p->lchild)//*p的左子树为空   
    {  
        q = p;  
        p = p->rchild;  
        delete q;  
    }  
    else//左右子树均不空   
    {  
        BSTNode *s = NULL;  
        s = p->lchild;       //左子树根结点  
        while(s->rchild) //寻找结点*p的中序前驱结点，                      
        {                   //也就是以p->lchild为根结点的子树中最右的结点   
            q = s;          //*s指向*p的中序前驱   
            s = s->rchild;   //*q指向*s的父节点   
        }  
        p->data = s->data;    //*s结点中的数据转移到*p结点，然后删除*s  
        if(q != p)          //p->lchild右子树非空   
        {  
            q->rchild = s->lchild;//把*s的左子树接到*q的右子树上   
        else                //p->lchild右子树为空 ,此时q ==p   
        {  
            q->lchild = s->lchild;//把*s的左子树接到*q的左子树上   
        }  
        delete s;           //删除结点*s   
    }  
}  

用处理方式b的代码如下：
//从二叉查找树中删除指针p所指向的结点 ,p非空,删除后继方式   
void removeNode2(BSTNode *& p)  
{  
    BSTNode *q = NULL;  
    if(!p->rchild)//*p的右子树为空   
    {  
        q = p;  
        p = p->lchild;  
        delete q;  
    }  
    else if(!p->lchild)//*p的左子树为空   
    {  
        q = p;  
        p = p->rchild;  
        delete q;  
    }  
    else//左右子树均不空   
    {  
        BSTNode *s = NULL;  
        q = p;  
        s = p->rchild;       //右子树根结点  
        while(s->lchild) //寻找结点*p的中序后继结点，                      
        {                   //也就是以p->rchild为根结点的子树中最左的结点   
            s = s->lchild;   //*q指向*s的父节点   
        }  
//删除关键字为key的元素结点 -递归   
void removeBST_recursion(BST& t, KeyType key)  
{  
    if(t)  
    {  
        if(key < t->data.key)  
        {  
            removeBST_recursion(t->lchild,key);  
        }  
        else if(t->data.key < key)  
        {  
            removeBST_recursion(t->rchild,key);  
        }  
        else//找到关键字为key的元素   
        {  
//          removeNode1(t);//删除结点*t   
//          removeNode2(t);  
            removeNode3(t);  
        }  
    }  
}  
        if(q != p)          //p->rchild左子树非空   
            q->lchild = s->rchild;//把*s的右子树接到*q的左子树上   
        }  
        else                //p->rchild左子树为空 ,此时q ==p   
        {  
            q->rchild = s->rchild;//把*s的右子树接到*q的右子树上   
        }  
        delete s;           //删除结点*s   
    }  
}  

使用处理方式c的代码如下：
//从二叉查找树中删除指针p所指向的结点 ,p非空,直接删除p的方式   
void removeNode3(BSTNode *& p)  
{  
    BSTNode *q = NULL;  
    if(!p->rchild)//*p的右子树为空   
    {  
        q = p;  
        p = p->lchild;  
        delete q;  
    }  
    {  
        q = p;  
        p = p->rchild;  
        delete q;  
    }  
    else//左右子树均不空   
    {  
        BSTNode *s = NULL;  
        q = p;  
        s = p->lchild;       //左子树根结点  
        while(s->rchild) //寻找结点*p的中序前驱结点，                      
        {                   //也就是以*s为根结点的子树中最右的结点   
            s = s->rchild;      
        }  
        s->rchild = p->rchild;//*p的右子树接到*s的右子树上   
        p = p->lchild;           //*p的左子树接到父节点上   
        delete q;           //删除结点*q   
    }  
}  
在二叉查找树中删除含有给定关键字的元素结点的递归函数如下：
//删除关键字为key的元素结点 -递归   
void removeBST_recursion(BST& t, KeyType key)  
{  
    if(t)  
    {  
        if(key < t->data.key)  
        {  
            removeBST_recursion(t->lchild,key);  
        }  
        else if(t->data.key < key)  
        {  
            removeBST_recursion(t->rchild,key);  
        }  
        else//找到关键字为key的元素   
        {  
//          removeNode1(t);//删除结点*t   
//          removeNode2(t);  
            removeNode3(t);  
        }  
    }  
}

注：
(1)由于该函数是递归的，且用到了指针引用，我们在前面的删除给定结点p的函数中，修改p就相当于修改了父节点，这是和C中不同的地方，在C中要达到这种效果，可以使用指向指针的指针变量。
(2)只给出了该函数的递归实现，没有给出非递归实现，是为了避免把代码弄乱。要实现非递归，可以修改前面的删除结点p的函数，添加一个指向结点p的父节点的指针引用f。同时要修改查找是否存在关键字为key的非递归查找函数，使其在得到p的同时，可以得到其父节点。这样我们在实现非递归时，只需扫描一遍，即调用查找函数，如果有该关键字，我们就可以得到指向该结点的指针p和指向结点p的父节点f，然后调用删除给定结点p的函数即可。
4、完整测试程序

#include <cstdlib>  
#include <iostream>  
#include <string>  
  
using namespace std;  
  
class Student  
{  
    public:  
        int key;  
        string major;  
        //other data  
        Student(int k=int(),string s="") : key(k), major(s){}  
        //重载赋值运算符   
        void operator=(const Student& rhs)  
        {  
            if(this != &rhs)  
            {  
                key = rhs.key;  
                major = rhs.major;  
            }  
        }     
};  
//重载<<,便于输出自定义类对象   
ostream& operator<<(ostream &out, const Student& s)  
{  
    out<<"("<<s.key<<","<<s.major<<")";  
}  
  
typedef Student ElementType;  
typedef int KeyType;  
  
typedef struct BSTNode  
{  
    ElementType data;  
    struct BSTNode* lchild;  
    struct BSTNode* rchild;  
}BSTNode, *BST;  
  
      
/* 
  description:在以t为根结点的二叉查找树中，查找关键字为key的结点 
  若查找成功，指针p指向该结点，返回true, 
  否则指向查找路径上的最后一个结点并返回false 
  指针f指向根结点t的父节点  
*/  
//bool searchBST_recursion(BST t, KeyType key, BSTNode* f, BSTNode*& p)  
//{  
//  if(t == NULL)//查找失败   
//  {  
//      p = f;  
//      return false;  
//  }  
//  else if(key == t->data.key)//查找成功   
//  {  
//      p = t;  
//      return true;  
//  }  
//  else if(key < t->data.key)  
//      return searchBST_recursion(t->lchild,key,t,p);//左子树中继续查找   
//  else   
//      return searchBST_recursion(t->rchild,key,t,p);//右子树中继续查找   
//}  
  
//非递归查找   
bool searchBST(BST t, KeyType key, BSTNode* f, BSTNode* &p)  
{  
    while(t && key != t->data.key)  
    {  
        f = t;  
        if(key < t->data.key)  
        {  
            t = t->lchild;  
        }  
        else  
        {  
            t = t->rchild;  
        }             
    }  
    if(t)//查找成功   
    {  
        p = t;  
        return true;  
    }  
    else  
    {  
        p = f;  
        return false;  
    }  
}  
  
//插入给定元素   
void insertBST(BST& t,ElementType elem)  
{  
    BSTNode * p = NULL;  
  
    if(!searchBST(t, elem.key, NULL, p))//查找失败，不含该关键字，可以插入   
    {  
        BSTNode * s = new BSTNode;  
        s->data = elem;//可能需要重载=   
        s->lchild = NULL;  
        s->rchild = NULL;  
          
        if(p == NULL)//查找树为空   
        {  
            t = s;//置s为根结点   
        }  
        else if(elem.key < p->data.key)  
        {  
            p->lchild = s;   //*s为p左结点   
        }  
        else  
        {  
            p->rchild = s;   //*s为p右结点   
        }  
    }  
}  
  
//从二叉查找树中删除指针p所指向的结点 ,p非空,删除前驱方式   
void removeNode1(BSTNode *& p)  
{  
    BSTNode *q = NULL;  
    if(!p->rchild)//*p的右子树为空   
    {  
        q = p;  
        p = p->lchild;  
        delete q;  
    }  
    else if(!p->lchild)//*p的左子树为空   
    {  
        q = p;  
        p = p->rchild;  
        delete q;  
    }  
    else//左右子树均不空   
    {  
        BSTNode *s = NULL;  
        q = p;  
        s = p->lchild;       //左子树根结点  
        while(s->rchild) //寻找结点*p的中序前驱结点，                      
        {                   //也就是以p->lchild为根结点的子树中最右的结点   
            q = s;          //*s指向*p的中序前驱   
            s = s->rchild;   //*q指向*s的父节点   
        }  
        p->data = s->data;    //*s结点中的数据转移到*p结点，然后删除*s  
        if(q != p)          //p->lchild右子树非空   
        {  
            q->rchild = s->lchild;//把*s的左子树接到*q的右子树上   
        }  
        else                //p->lchild右子树为空 ,此时q ==p   
        {  
            q->lchild = s->lchild;//把*s的左子树接到*q的左子树上   
        }  
        delete s;           //删除结点*s   
    }  
}  
  
//从二叉查找树中删除指针p所指向的结点 ,p非空,删除后继方式   
void removeNode2(BSTNode *& p)  
{  
    BSTNode *q = NULL;  
    if(!p->rchild)//*p的右子树为空   
    {  
        q = p;  
        p = p->lchild;  
        delete q;  
    }  
    else if(!p->lchild)//*p的左子树为空   
    {  
        q = p;  
        p = p->rchild;  
        delete q;  
    }  
    else//左右子树均不空   
    {  
        BSTNode *s = NULL;  
        q = p;  
        s = p->rchild;       //右子树根结点  
        while(s->lchild) //寻找结点*p的中序后继结点，                      
        {                   //也就是以p->rchild为根结点的子树中最左的结点   
            q = s;          //*s指向*p的中序后继   
            s = s->lchild;   //*q指向*s的父节点   
        }  
        p->data = s->data;    //*s结点中的数据转移到*p结点，然后删除*s  
        if(q != p)          //p->rchild左子树非空   
        {  
            q->lchild = s->rchild;//把*s的右子树接到*q的左子树上   
        }  
        else                //p->rchild左子树为空 ,此时q ==p   
        {  
            q->rchild = s->rchild;//把*s的右子树接到*q的右子树上   
        }  
        delete s;           //删除结点*s   
    }  
}  
  
//从二叉查找树中删除指针p所指向的结点 ,p非空,直接删除p的方式   
void removeNode3(BSTNode *& p)  
{  
    BSTNode *q = NULL;  
    if(!p->rchild)//*p的右子树为空   
    {  
        q = p;  
        p = p->lchild;  
        delete q;  
    }  
    else if(!p->lchild)//*p的左子树为空   
    {  
        q = p;  
        p = p->rchild;  
        delete q;  
    }  
    else//左右子树均不空   
    {  
        BSTNode *s = NULL;  
        q = p;  
        s = p->lchild;       //左子树根结点  
        while(s->rchild) //寻找结点*p的中序前驱结点，                      
        {                   //也就是以*s为根结点的子树中最右的结点   
            s = s->rchild;      
        }  
        s->rchild = p->rchild;//*p的右子树接到*s的右子树上   
        p = p->lchild;           //*p的左子树接到父节点上   
        delete q;           //删除结点*q   
    }  
}  
  
//删除关键字为key的元素结点 -递归   
void removeBST_recursion(BST& t, KeyType key)  
{  
    if(t)  
    {  
        if(key < t->data.key)  
        {  
            removeBST_recursion(t->lchild,key);  
        }  
        else if(t->data.key < key)  
        {  
            removeBST_recursion(t->rchild,key);  
        }  
        else//找到关键字为key的元素   
        {  
//          removeNode1(t);//删除结点*t   
//          removeNode2(t);  
            removeNode3(t);  
        }  
    }  
}  
  
  
//输出二叉查找树，中序递归   
void printTree(const BST & t)  
{  
    if(t)  
    {  
        printTree(t->lchild);  
        cout<<t->data<<" ";  
        printTree(t->rchild);  
    }  
}  
  
int main(int argc, char *argv[])  
{  
    const int N = 10;  
    BST root = NULL;  
      
    for(int i=1; i<=N; i++)  
    {  
        Student s(i,"cs");//关键字为1-10   
        insertBST(root,s);  
    }  
    cout<<"after insert: "<<endl;  
    printTree(root);  
    cout<<endl<<endl;  
      
    for(int i=1;i<=N;i+=2)  
    {  
        removeBST_recursion(root,i);//删除关键字为1-3-5-7-9的结点   
    }  
    cout<<"after delete: "<<endl;  
    printTree(root);  
    cout<<endl<<endl;  
      
    system("PAUSE");  
    return EXIT_SUCCESS;  
}

时间久远侵权联系我！