搜索二叉树的基本操作

来源：互联网发布：数据质量监控系统编辑：程序博客网时间：2024/06/14 04:35

这里写图片描述
搜索二叉树的非递归基本操作

为什么要找右孩子的最左节点因为右孩子的最左节点一定比要删除的节点的右孩子上的任意一个节点都要小替换删除之后搜索为茶树还是搜索二叉树#include<iostream>#include<stdlib.h>using namespace std;template<class K>struct BinarySearchTreeNode{         BinarySearchTreeNode<K > *_left;         BinarySearchTreeNode<K > *_right;         K _key;        BinarySearchTreeNode( const K &x)               :_left( NULL)               , _right( NULL)               , _key( x)        {        }};template<class K>class BinarySearchTree{         typedef BinarySearchTreeNode <K> Node;public:        BinarySearchTree()               :_root( NULL)        {        }    bool BinarySearchInsert( const K & key)        {                if (_root == NULL )               {                       _root = new Node (key);                        return true ;               }                else               {                        Node *cur = _root;                        Node *parent = NULL ;                        while (cur)                       {                               if (cur->_key > key )                              {                                      parent = cur;                                      cur = cur->_left;                              }                               else if (cur->_key < key)                              {                                      parent = cur;                                      cur = cur->_right;                              }                               else                              {                                       return false ;                              }                       }                        if (key >parent->_key)                       {                              parent->_right = new Node (key);                               return true ;                       }                        else if (key < parent->_key)                       {                              parent->_left = new Node (key);                               return true ;                       }               }        }         const Node * Find(const K&key )        {                if (_root == NULL )               {                        return NULL ;               }                else               {                        Node*cur = _root;                        while (cur)                       {                               if (cur->_key > key )                              {                                      cur = cur->_left;                              }                               else if (cur->_key < key)                              {                                      cur = cur->_right;                              }                               else                              {                                       return cur;                              }                       }                        return NULL ;               }        }         bool Remove(const K& key)        {                if (_root == NULL )               {                        return false ;               }                else               {                        Node*del = NULL ;                        Node*cur = _root;                        Node*parent = NULL ;                        while (cur)                       {                               if (cur->_key > key )                              {                                      parent = cur;                                      cur = cur->_left;                              }                               else if (cur->_key < key)                              {                                      parent = cur;                                      cur = cur->_right;                              }                               else                              {                                       if (cur->_left == NULL )                                      {                                              if (parent->_left == cur)                                             {                                                     del = cur;                                                     parent->_left = cur->_right;                                             }                                              else                                             {                                                     del = cur;                                                     parent->_right = cur->_right;                                             }                                      }                                       else if (cur->_right == NULL)                                      {                                              if (parent->_left == cur)                                             {                                                     del = cur;                                                     parent->_left = cur->_left;                                             }                                              else                                             {                                                     del = cur;                                                     parent->_right = cur->_left;                                             }                                      }                                       else//要删除的节点左右都不为空，使用替换法                                      {                                              Node *parent = cur;                                              Node*subRight = cur->_right;//选择找右孩子的最左节点                                              while (subRight->_left)                                             {                                                     parent = subRight;                                                     subRight = subRight->_left;                                             }                                              cur->_key = subRight->_key;                                              if (parent->_left == subRight)                                             {                                                     del = cur;                                                     parent->_left = subRight->_left;                                             }                                              else                                             {                                                     del = cur;                                                     parent->_right = subRight->_left;                                             }                                      }                              }                               delete del;                              del = NULL;                               return true ;                       }                        return false ;               }        }         void InOrder()        {               _InOrder(_root);        }protected:         void _InOrder(Node *root)        {                if (root == NULL)               {                        return;               }               _InOrder( root->_left);               cout << root->_key << " " ;               _InOrder( root->_right);        }         Node*_root;};int main(){         BinarySearchTree<int >bs;        bs.BinarySearchInsert(5);        bs.BinarySearchInsert(3);        bs.BinarySearchInsert(4);        bs.BinarySearchInsert(1);        bs.BinarySearchInsert(7);        bs.BinarySearchInsert(8);        bs.BinarySearchInsert(2);        bs.BinarySearchInsert(6);        bs.BinarySearchInsert(0);        bs.BinarySearchInsert(9);        bs.InOrder();        cout << endl;        bs.Remove(5);        bs.Remove(3);        bs.Remove(4);        bs.Remove(1);        bs.InOrder();        system( "pause");         return 0;}

搜索二叉树递归的基本操作

搜索二叉树递归的基本操作#include <iostream>#include <stdlib.h>using namespace std;template <class K>struct BinarySearchTreeNode{         BinarySearchTreeNode <K > *_left;         BinarySearchTreeNode <K > *_right;         K _key;        BinarySearchTreeNode( const K & x)               :_left( NULL )               , _right( NULL )               , _key( x )        {        }};template <class T>class BinarySearchTree{         typedef BinarySearchTreeNode < T> Node ;public :        BinarySearchTree()               :_root( NULL )        {        }         bool BinarySearchInsertR(const T& key )        {                return _InsertR(_root, key );        }         Node *Find(const T& key )        {                return _Find(_root, key );        }         bool Remove(const T& key )        {                return _Remove(_root, key );        }         void InOrder()        {               _InOrder(_root);               cout << endl;        }protected :         void _InOrder(Node * root)        {                if (root == NULL)               {                        return ;               }               _InOrder( root ->_left);               cout << root ->_key << " " ;               _InOrder( root ->_right);        }         bool _InsertR(Node *& root, const T & key)        {                if (root == NULL)               {                        root = new Node( key );                        return true ;               }                if (root ->_key > key)               {                        return _InsertR(root ->_left, key);               }                else if ( root->_key < key )               {                        return _InsertR(root ->_right, key);               }                else               {                        return false ;               }        }         Node * _Find(Node * root, const T & key)        {                if (root == NULL)               {                        return NULL ;               }                if (root ->_key < key)               {                        return _Find(root ->_right, key);               }                else if ( root->_key> key )               {                        return _Find(root ->_left, key);               }                else               {                        return root ;               }        }         bool _Remove(Node *& root, const T & key)        {                if (root == NULL)               {                        return false ;               }                if (root ->_key < key)               {                        return _Remove(root ->_right, key);               }                else if ( root->_key> key )               {                        return _Remove(root ->_left, key);               }                else //找到了可以删除               {                        Node *del = NULL ;                        if (root ->_left == NULL)                       {                              del = root ;                               root = root ->_right;                               return true ;                       }                        else if ( root->_right == NULL )                       {                              del = root ;                               root = root ->_left;                       }                        else //左右子树都不为空,找到右子树的最左节点                       {                               Node *left = root ->_right;                               while (left->_left)                              {                                      left = left->_left;                              }                               root ->_key = left->_key;                              _Remove( root ->_right, left->_key);                           return true ;                       }               }        }         Node *_root;};int main(){         BinarySearchTree <int >bs;        bs.BinarySearchInsertR(5);        bs.BinarySearchInsertR(3);        bs.BinarySearchInsertR(4);        bs.BinarySearchInsertR(1);        bs.BinarySearchInsertR(7);        bs.BinarySearchInsertR(8);        bs.BinarySearchInsertR(2);        bs.BinarySearchInsertR(6);        bs.BinarySearchInsertR(0);        bs.BinarySearchInsertR(9);        bs.Remove(5);        bs.Remove(3);        bs.Remove(4);        bs.Remove(1);        bs.Remove(7);        bs.Remove(8);        bs.Remove(2);        bs.Remove(6);        bs.Remove(0);        bs.Remove(9);        bs.InOrder();        cout << bs.Find(2);        system( "pause" );         return 0;}

阅读全文

1 0