整型二叉查找树的C++实现

最新推荐文章于 2022-06-08 16:22:53 发布

原创最新推荐文章于 2022-06-08 16:22:53 发布 · 347 阅读

0 ·

CC 4.0 BY-SA版权

c++ 同时被 2 个专栏收录

13 篇文章

订阅专栏

算法学习

6 篇文章

订阅专栏

本文详细介绍了C++中二叉树数据结构的实现，包括基本概念、节点定义、查找、插入、删除等操作，并通过实例展示了如何在实际应用中使用这些操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include <iostream>
#include <vector>
#include <stdlib.h>

using namespace std;

class node
{
      public:
      node* parent,*right,*left;
      int data;
      node(int k):data(k),parent(0),right(0),left(0){}
};

class tree
{
      node* root;
      public:
      tree():root(0){}
      ~tree();
      //查找元素
      node* search(int k);
      //获取树到根节点
      node* getroot(){return root;}
      //查找最小值
      node* min(node* nd);
      //查找最大值
      node* max(node* nd);
      //找节点nd的前驱
      node* predecessor(node* nd);
      //找节点nd的后继
      node* successor(node* nd);
      //将k插入树中
      void insert(int k);
      //将节点nd删除
      void drop(node* nd);
      //中序遍历
      void in_order_show(node* nd);
      //中序遍历存储
      void in_order_store(node* nd,vector<node*>& store);
};

node* tree::search(int k)
{
      bool tag=false;
      node* nd=root;
      while(nd!=0)
      {
            if(nd->data==k)
           return nd;
            else if(nd->data>k)
            nd=nd->left;
            else
            nd=nd->right;
      }
      return nd;
}

node* tree::max(node* nd)
{
      if(nd==0)
      return 0;
      while(nd->right!=0)
      nd=nd->right;
      return nd;
}

node* tree::min(node* nd)
{
      if(nd==0)
      return 0;
      while(nd->left!=0)
      nd=nd->left;
      return nd;
}

node* tree::predecessor(node* nd)
{
      if(nd->left!=0)
      return max(nd->left);
      node * temp=nd->parent;
      while(temp!=0 && nd==temp->right)
      {
            nd=temp;
            temp=temp->parent;
      }
      return temp;
}

node* tree::successor(node* nd)
{
      if(nd->right!=0)
      return min(nd->right);
      node * temp=nd->parent;
      while(temp!=0 && nd==temp->left)
      {
            nd=temp;
            temp=temp->parent;
      }
      return temp;
}

void tree::insert(int k)
{
      node* nd=new node(k);
      node* temp0=root;
      node* temp1=0;
      while(temp0!=0)
      {
            temp1=temp0;
            if(temp0->data>=k)
            temp0=temp0->left;
            else
            temp0=temp0->right;
      }
      if(temp1==0)
      root=nd;
      else
      {
            nd->parent=temp1;
            if(temp1->data>=k)
            {
                  temp1->left=nd;
            }else
            {
                  temp1->right=nd;
            }
      }
}

void tree::drop(node* nd)
{
      if(nd->left!=0)
      {
             node* pre=predecessor(nd);
             nd->data=pre->data;
             node * temp=0;
             if(pre->left!=0)
             {
                   temp=pre->left;
                   temp->parent=pre->parent;
             }
             if(pre==pre->parent->left)
             pre->parent->left=temp;
             else
               pre->parent->right=temp;
             delete pre;
             return;
      }
      if(nd->right!=0)
      {
            node* su=successor(nd);
            nd->data=su->data;
             node * temp=0;
             if(su->right!=0)
             {
                   temp=su->right;
                   temp->parent=su->parent;
             }
            if(su==su->parent->left)
             su->parent->left=temp;
             else
            su->parent->right=temp;
            delete su;
            return;
      }
      if(nd==nd->parent->left)
      nd->parent->left=0;
      else
      nd->parent->right=0;
      delete nd;
}

void tree::in_order_show(node* nd)
{
      if(nd!=0)
      {
            in_order_show(nd->left);
            cout<<nd->data<<endl;
            in_order_show(nd->right);
      }
}

void tree::in_order_store(node* nd,vector<node*>& store)
{
      if(nd!=0)
      {
            in_order_store(nd->left,store);
           store.push_back(nd);
            in_order_store(nd->right,store);
      }
}

tree::~tree()
{
      vector<node*> store;
      in_order_store(getroot(),store);
      for(int i=0;i<store.size();++i)
      {
            delete store[i];
      }
}

int main()
{
      tree t;
      for(int i=10;i>0;--i)
      {
            t.insert(rand()%100);
      }
      t.in_order_show(t.getroot());
      cout<<"root:"<<t.getroot()->data<<endl;
      t.drop(t.getroot());
      t.drop(t.min(t.getroot()));
      t.in_order_show(t.getroot());
      cout<<"root:"<<t.getroot()->data<<endl;
      cout<<"max:"<<t.max(t.getroot())->data<<endl;
      cout<<"min:"<<t.min(t.getroot())->data<<endl;
      cout<<"search_max:"<<t.search(t.max(t.getroot())->data)->data<<endl;
    return 0;
}