二叉搜索树的建立 插入 删除

最新推荐文章于 2022-12-29 07:30:00 发布
最新推荐文章于 2022-12-29 07:30:00 发布
阅读量3.5w 收藏 1
点赞数
分类专栏： # 数据结构 文章标签： 大连理工大学软件学院 数据结构 于红 二叉搜索树 上机作业
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L1558198727/article/details/78639129
版权 
#include <iostream>
#include <windows.h>
#include"Queue.h"
//#include"Stack.h"
using namespace std;
template<class T>
class BinarySearchTree;
template<class T>
class BinarySearchTreeNode
{
   friend class BinarySearchTree<T>;
  private:
      T element; //数据成员
      BinarySearchTreeNode<T> *leftChild;
      BinarySearchTreeNode<T> *rightChild;
  public:
    BinarySearchTreeNode();
    BinarySearchTreeNode(const T &ele);
    BinarySearchTreeNode(const T &ele,BinarySearchTreeNode<T>*l,BinarySearchTreeNode<T>*r);
    BinarySearchTreeNode<T>* getLeftChild()const;
    BinarySearchTreeNode<T>* getRightChild()const;
    void setLeftChild(BinarySearchTreeNode<T>*l);
    void setRightChild(BinarySearchTreeNode<T>*r);
    void visit();
    T getValue() const;
    void setValue(const T & val);
    bool isLeaf()const;
};
template<class T>
BinarySearchTreeNode<T>::BinarySearchTreeNode()
{
  element=0;
  leftChild=rightChild=0;
}
template<class T>
BinarySearchTreeNode<T>::BinarySearchTreeNode(const T &ele)
{
   element=ele;
   leftChild=rightChild=0;
}
template<class T>
BinarySearchTreeNode<T>::BinarySearchTreeNode(const T &ele,BinarySearchTreeNode<T>*l,BinarySearchTreeNode<T>*r)
{
   element=ele;
   leftChild=l;
   rightChild=r;
};
template<class T>
BinarySearchTreeNode<T>*BinarySearchTreeNode<T>::getLeftChild()const
{
    return this->leftChild;
}
template<class T>
BinarySearchTreeNode<T>* BinarySearchTreeNode<T>::getRightChild()const
{
    return this->rightChild;
}

template<class T>
void BinarySearchTreeNode<T>::setLeftChild(BinarySearchTreeNode<T>*l)
{
    this->leftChild=l;
}
template<class T>
void BinarySearchTreeNode<T>::setRightChild(BinarySearchTreeNode<T>*r)
{
    this->rightChild=r;
}
template<class T>
T BinarySearchTreeNode<T>::getValue() const
{
    return this->element;
}
template<class T>
void BinarySearchTreeNode<T>::setValue(const T & val)
{
    this->element=val;
}
template<class T>
bool BinarySearchTreeNode<T>::isLeaf()const
{
    if(this->leftChild==0 && this->rightChild==0)
    {
        return true;
    }
    else
    {
        return false;
    }
}
template<class T>
void BinarySearchTreeNode<T>::visit()
{
    cout<<this->element<<" ";
}

template<class T>
class BinarySearchTree
{
   private:
       BinarySearchTreeNode<T> *root;
   public:
     BinarySearchTree();
     ~BinarySearchTree();
     BinarySearchTreeNode<T> *getRoot()const;
     bool isEmpty()const;
     bool isLeaf(BinarySearchTreeNode<T> *rt);
     void breadthFirstOrder();//广度优先遍历以root为根节点的子树
     bool Find(T value);//搜索树的查找
     bool Insert(T value);//搜索树的插入
     bool Delete(T value);//搜索树的删除
     bool comDelete(T value);//搜索树的删除
};
template<class T>
BinarySearchTree<T>::BinarySearchTree()
{
    root=0;
}
template<class T>
BinarySearchTree<T>::~BinarySearchTree()
{
    ;
}
template<class T>
bool BinarySearchTree<T>::isEmpty()const
{
    if(root==0)
    {
        return true;
    }
    else
    {
        return false;
    }
}
template<class T>
BinarySearchTreeNode<T> *BinarySearchTree<T>::getRoot()const
{
    return root;
}
template<class T>
bool BinarySearchTree<T>::Find(T value)//搜索树的查找
{
       BinarySearchTreeNode<T> *p=root;
       while(p)
       {
           if(p->element==value)
           {
               return true;
           }
           else if(p->element>value)
           {
             p=p->leftChild;
           }
           else
           {
               p=p->rightChild;
           }
       }
}
template<class T>
bool BinarySearchTree<T>::Insert(T value)//搜索树的插入
{
    BinarySearchTreeNode<T> *p=root;
    BinarySearchTreeNode<T> *pre=0;
    if(root==0)
    {
        p=new BinarySearchTreeNode<T>;
        p->element=value;
        root=p;
        return true;
    }
    else
    {
       while(p)
       {
           if(p->element==value)
           {
               cout<<value<<" "<<"节点已经在树中"<<endl;
               return false;
           }
           else if(p->element>value)
           {
             pre=p;
             p=p->leftChild;
           }
           else
           {
               pre=p;
               p=p->rightChild;
           }
       }
       if(value>pre->element)
       {
           p=new BinarySearchTreeNode<T>;
           p->element=value;
           pre->rightChild=p;
       }
       else
       {
           p=new BinarySearchTreeNode<T>;
           p->element=value;
           pre->leftChild=p;
       }
    return true;
  }
}
template<class T>
bool BinarySearchTree<T>::Delete(T value)//搜索树的删除
{
    BinarySearchTreeNode<T> *p=root;
    BinarySearchTreeNode<T> *pre=0;
    while(p)
    {
        if(p->element==value)
        {
           break;
        }
        else if(p->element>value)
        {
            pre=p;
            p=p->leftChild;
        }
        else
        {
            pre=p;
            p=p->rightChild;
        }
    }
    if(p==NULL)
    {
        cout<<"该节点不在树中，删除失败"<<endl;
        return false;
    }
    if(isLeaf(p))
    {
       if(p==root)
       {
           root->leftChild=0;
           root->rightChild=0;
           delete root;
           root=0;
       }
       else
       {
         if(p->element>pre->element)
           pre->rightChild=0;
         else
           pre->leftChild=0;
            delete p;
       }
     }
     else if(p->leftChild && !p->rightChild)
     {
         if(p==root)
         {
             root=p->leftChild;
         }
        else if(p->element<pre->element)
          pre->leftChild=p->leftChild;
        else
          pre->rightChild=p->leftChild;
        delete p;
     }
     else if(p->rightChild && !p->leftChild)
     {
          if(p==root)
         {
             root=p->rightChild;
         }
        else if(p->element<pre->element)
          pre->leftChild=p->rightChild;
        else
          pre->rightChild=p->rightChild;
        delete p;
     }
     else
     {
         pre=p;
         BinarySearchTreeNode<T> *pp;
         p=p->leftChild;
         while(p->rightChild)
         {
             pp=p;
             p=p->rightChild;
         }
         pre->element=p->element;
          if(isLeaf(p))
          {
           if(p->element>pp->element)
            pp->rightChild=0;
          else
            pp->leftChild=0;
            delete p;
          }
         else if(p->leftChild)
         {
           if(p->element<pp->element)
            pp->leftChild=p->leftChild;
           else
           pp->rightChild=p->leftChild;
          delete p;
        }
     }
}
template<class T>
bool BinarySearchTree<T>::comDelete(T value)
{
    BinarySearchTreeNode<T> *p=root;
    BinarySearchTreeNode<T> *pre=0;
    while(p)
    {
        if(p->element==value)
        {
           break;
        }
        else if(p->element>value)
        {
            pre=p;
            p=p->leftChild;
        }
        else
        {
            pre=p;
            p=p->rightChild;
        }
    }
    if(p->leftChild && p->rightChild)
    {
        BinarySearchTreeNode<T> *pp;
            pp=p->leftChild;
          while(pp->rightChild)
            pp=pp->rightChild;
          pp->rightChild=p->rightChild;
          p->rightChild=0;
         if(p!=root)
         {
             if(p->element < pre->element)
            {
            cout<<"111"<<endl;
            pre->leftChild=p->leftChild;
           }
        else
          {
            cout<<"111"<<endl;
            pre->rightChild=p->leftChild;
          }
        }
        else
        {
            root=p->leftChild;
        }
          delete p;
    }
    else
    {
        Delete(p->element);
    }
}
template<class T>
bool BinarySearchTree<T>::isLeaf(BinarySearchTreeNode<T> *rt)
{
    if(!rt->leftChild && !rt->rightChild)
        return true;
    else
        return false;
}
template<class T>
void BinarySearchTree<T>::breadthFirstOrder()//广度优先遍历以root为根节点的子树
{
    Queue<BinarySearchTreeNode<T>* > que;
    BinarySearchTreeNode<T> *p=root;
    if(p)
    que.EnQueue(p);
    while(!que.IsEmpty())
    {
        que.DeQueue(p);
        p->visit();
        if(p->leftChild)
            que.EnQueue(p->leftChild);
        if(p->rightChild)
            que.EnQueue(p->rightChild);
    }
    cout<<endl;
}
int main()
{
    BinarySearchTree<int> a;
    a.breadthFirstOrder();
    for(int i=0;i<10;i++)
    {
        a.Insert(i);
    }
    for(int i=-10;i<0;i++)
    {
        a.Insert(i);
    }
    a.breadthFirstOrder();
    for(int i=0;i<10;i++)
    a.Delete(i);
    //a.comDelete(0);
    a.breadthFirstOrder();
    for(int i=-10;i<-1;i++)
    a.Delete(i);
    a.breadthFirstOrder();
    a.Delete(2);
    a.breadthFirstOrder();
    system("pause");
    return 0;
}


技术的边界
关注
专栏目录
线索二叉树创建及删除
Blankj
07-22 6883
题目描述线索二叉树概念 1．定义 　n个结点的二叉链表中含有n+1个空指针域。利用二叉链表中的空指针域，存放指向结点在某种遍历次序下的前趋和后继结点的指针（这种附加的指针称为”线索”）。这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种。
二叉搜索树的插入、删除、查找的递归实现
Lycorisradiata__的博客
05-18 920
二叉搜索树的递归实现首先，二叉搜索树是也是一颗二叉树。它的特点是左结点（左子树的根结点）的值比根结点小，右结点的值比根结点的值大。比如说，下图所示的二叉搜索树：所以我们定义二叉搜索树的结构如下：#pragma once #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; ...
线索二叉树的插入与删除
canvasa的博客
11-18 2372
#pragma once namespace Y{ template <class T> class TreeNode { T m_data; TreeNode<T> * m_left; TreeNode<T> * m_right; public: TreeNode(const T & val = T()) : m_d...
数据结构—二叉搜索树的创建、结点的插入和删除
u012258911的博客
08-29 1811
代码如下： 头文件StudyBST.h #define TRUE 1 #define ERROR 0 #define OK 1 #define REEOR 1 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int Status; 源文件StudyBST.cpp //二叉查找树
线索二叉树的建立、删除、插入、恢复线索
06-29
线索二叉树的建立 删除 插入 恢复线索
二叉排序树创建-查找-删除
11-09
二叉排序树创建-查找-删除，算法数据结构基础篇章，可供创建二叉排序树后对其进行插入-查找-删除等操作。
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
采用二叉链式结构做存储结构的二叉排序树建立和查找算法
12-07
二叉排序树，又称二叉查找树或二叉搜索树，是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种性质使得...
如何用 java 实现【二叉搜索树】
最新发布
超烦豆先森
12-29 1053
关于数据结构 二叉搜索树的 java 实现
二叉搜索树/二叉排序树/二叉查找树
further_的博客
09-01 2149
怕
二叉排序树的建立、插入、查找和删除
08-04
代码里有二叉排序树插入操作递归算法，二叉排序树插入操作非递归算法，二叉排序树删除操作，创建二叉排序树，二叉排序树查找递归算法，二叉排序树查找非递归算法
二叉查找树 查找修改（void） 插入（&）和创建（*）
小青青的技术之家
03-26 351
//二叉查找树 #include struct node{ int data; node* lchild; node* rchild; }Node;//定义了一个结构名为node的结构体，并且用这个结构体定义了一个结点 //插入，如果查找成的话说明结点已经存在，反过来如果查找失败，那么说明查找是失败的地方一点是结点需要插入的地方 void insert(node* &root,int a
二叉搜索树的建立， 查找， 删除操作...
CNnumen
07-11 9631
#include #include using namespace std; typedef struct _NODE { int value; struct _NODE *left; struct _NODE *right; _NODE(int value) : value(value), left(NULL), right(NULL) {}; }NODE, *PTRNODE; void insert(PTRNODE &root, in
二叉查找树的创建和遍历
cpfor
06-24 358
#include <iostream> #include <cstdio>using namespace std;typedef int keytype; typedef int infotype;typedef struct { keytype key; //关键字项 infotype otherinfo;
二叉搜索树的创建，删除，查找
zhao_miao的博客
09-02 6978
二叉搜索树的概念   二叉搜索树又称二叉排序树，它或者是一颗空树，或者是具有以下性质的二叉树 若它的左子树不为空，则左子树上的所有结点的值都小于根结点的值。 若它的右子树不为空，则右子树上的所有结点的值都大于根节点的值。 它的左右子树也分别为二叉搜索树。 二叉搜索树的操作   查找关键字data：①.若根节点为空，即二叉搜索树为空。返回0。 ②.若data&amp;amp;amp;gt;根节点的da...
【数据结构】二叉搜索树（BST树）的定义、构建、插入、删除及查找操作
PinkBananA_的博客
06-30 2705
一、概念 二叉搜索树(BST树)：又叫二叉排序树，二叉查找树。它或者是一棵空树；或者是具有以下性质的二叉树： 1.每个结点都有一个数据域，且所有节点的数据域互不相同； 2.若它的左子树不为空，则左子树上的所有结点的值都小于根节点的值； 3.若它的右子树不为空，则右子树上的所有节点的值都大于根节点的值； 4.左子树和右子树都是二搜索树。 对二叉搜索树...
二叉查找树的建立，遍历，插入与删除
yiqzq的博客
06-23 452
#include &amp;lt;bits/stdc++.h&amp;gt; using namespace std; int a[1005]; typedef struct node { int data; struct node *lchild, *rchild; node() { data = 0; lchild = rchild = NULL; ...
算法导论程序29--二叉搜索树的插入和删除（Python）
勇气与行动
05-27 1280
删除比较麻烦： 1.如果z没有孩子结点，那么只是简单地将它删除，并修改它的父结点。用NIL作为孩子来替换z。 2.如果z只有一个孩子，那么将这个孩子提升到树中z的位置上，并修改z的父结点，用z的孩子来替换z。 3.如果z有两个孩子，那么找z的后继y（一定在z的右子树中）并让y占据树中z的位置，z的原来右子树部分成为y的新右子树，并且z的左子树成为y的新左子树。如果y位于z的右子树中，但不是z
C++实现二叉排序树：插入、删除与查找
这篇文档主要涵盖了二叉排序树（Binary Search Tree，BST）的基本操作，包括建立、插入、删除和查找，这些都是数据结构课程设计的重要部分。二叉排序树是一种特殊类型的数据结构，它的每个节点都满足以下条件：左...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值