分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow

也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！

二叉搜尋樹的定義

二叉搜尋樹，也稱有序二叉樹,排序二叉樹，是指一棵空樹或者具有下列性質的二叉樹：

1. 若任意節點的左子樹不空，則左子樹上所有結點的值均小於它的根結點的值；

2. 若任意節點的右子樹不空，則右子樹上所有結點的值均大於它的根結點的值；

3. 任意節點的左、右子樹也分別為二叉查詢樹。

4. 沒有鍵值相等的節點。

二叉搜尋樹的刪除：

具體實現過程解析：

二叉搜尋樹的結構實現：

//二叉搜尋樹結構template<class K, class V>struct BSTreeNode{ BSTreeNode* _left; BSTreeNode* _right; K _key; V _value; BSTreeNode(const K& key, const V& value)  :_left(NULL
 
)  ,_right(NULL)  ,_key(key)  ,_value(value) {}};

查詢實現有迭代和遞迴兩種

迭代法：

        //在二叉搜尋樹中查詢節點 Node* Find(const K& key) {  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; }

遞迴法：

                //遞迴查詢法  Node* _Find_R(Node* root, const K& key)  {   if (root == NULL)   {    return NULL;   }   if (root->_key > key)   {    return _Find_R(root->_left, key);   }   else if (root->_key < key)   {    return _Find_R(root->_right, key);   }   else   {    return root;   }  }

        //在二叉搜尋樹中刪除節點 bool Remove(const K& key) {  //沒有節點  if (_root == NULL)  {   return false;  }  //只有一個節點  if (_root->_left == NULL&&_root->_right == NULL)  {   if (_root->_key == key)   {    delete _root;    _root = NULL;    return true;   }   return false;  }  Node* parent = NULL;  Node* cur = _root;  //遍歷查詢要刪除節點的位置  while (cur)  {   Node* del = NULL;   if (cur->_key > key)   {    parent = cur;    cur = cur->_left;   }   else if (cur->_key < key)   {    parent = cur;    cur = cur->_right;   }   else   {    //要刪除節點的左子樹為空，分3種情況    if (cur->_left == NULL)    {     //注意判斷父節點是否為空，若為空，則要刪除的節點為根節點,如：只有根節點5和其右節點9     if (parent == NULL)     {      _root = cur->_right;      delete cur;      cur = NULL;      return true;     }     if (parent->_key > cur->_key)     {      del = cur;      parent->_left = cur->_right;      delete del;      return true;     }     else if (parent->_key < key)     {      del = cur;      parent->_right = cur->_right;      delete del;      return true;     }    }    //要刪除節點的右子樹為空，同樣分3種情況    else if (cur->_right == NULL)    {     //注意判斷父節點是否為空，若為空，則要刪除的節點為根節點,如：只有根節點5和其左節點3     if (parent == NULL)     {      _root = cur->_left;      delete cur;      cur = NULL;      return true;     }     if (parent->_key > cur->_key)     {      del = cur;      parent->_left = cur->_left;      delete del;      return true;     }     else if (parent->_key < cur->_key)     {      del = cur;      parent->_right = cur->_left;      delete del;      return true;     }    }    //左右子樹都不為空    else    {     Node* del = cur;     Node* parent = NULL;     Node* RightFirst = cur->_right;     //右邊第一個節點的左子樹為空     if (RightFirst->_left == NULL)     {      swap(RightFirst->_key, cur->_key);      swap(RightFirst->_value, cur->_value);      del = RightFirst;      cur->_right = RightFirst->_right;      delete del;      return true;     }     //右邊第一個節點的左子樹不為空     while (RightFirst->_left)     {      parent = RightFirst;      RightFirst = RightFirst->_left;     }        swap(RightFirst->_key, cur->_key);        swap(RightFirst->_value, cur->_value);        del = RightFirst;        parent->_left = RightFirst->_right;        delete del;           return true;    }   }  }  return false; }

刪除遞迴法：

                bool _Remove_R(Node*& root, const K& key)  {   //沒有節點   if (root == NULL)   {    return false;   }   //只有一個節點   if (root->_left == NULL&&root->_right == NULL)   {    if (root->_key == key)    {     delete root;     root = NULL;     return true;    }    else    {     return false;    }   }   //刪除二叉搜尋樹節點的遞迴寫法   if (root->_key > key)   {    _Remove_R(root->_left, key);   }   else if (root->_key < key)   {    _Remove_R(root->_right, key);   }   else   {    Node* del = NULL;        if (root->_left == NULL)    {     del = root;     root = root->_right;     delete del;     del = NULL;     return true;    }    else if (root->_right == NULL)    {     del = root;     root = root->_left;     delete del;     del = NULL;     return true;    }    else    {     Node* RightFirst = root->_right;     while (RightFirst->_left)     {      RightFirst = RightFirst->_left;     }     swap(root->_key, RightFirst->_key);     swap(root->_value, RightFirst->_value);     _Remove_R(root->_right, key);     return true;    }   }  }

插入非遞迴：

        //在二叉搜尋樹中插入節點 bool Insert(const K& key, const V& value) {  if (_root == NULL)  {   _root = new Node(key, value);  }  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 (parent->_key > key)  {   parent->_left = new Node(key, value);  }  else  {   parent->_right = new Node(key, value);  }  return true; }

插入遞迴：

                //遞迴插入法  bool _Insert_R(Node*& root, const K& key, const V& value)  {   if (root == NULL)   {    root = new Node(key, value);    return true;   }   if (root->_key > key)   {    return _Insert_R(root->_left, key, value);   }   else if(root->_key < key)   {    return _Insert_R(root->_right, key, value);   }   else   {    return false;   }  }

當二叉搜尋樹出現如下圖情形時，效率最低：

完整程式碼及測試實現如下:

#include<iostream>using namespace std;//二叉搜尋樹結構template<class K, class V>struct BSTreeNode{ BSTreeNode* _left; BSTreeNode* _right; K _key; V _value; BSTreeNode(const K& key, const V& value)  :_left(NULL)  ,_right(NULL)  ,_key(key)  ,_value(value) {}};template<class K,class V>class BSTree{ typedef BSTreeNode<K, V> Node;public: BSTree()  :_root(NULL) {}  //在二叉搜尋樹中插入節點 bool Insert(const K& key, const V& value) {  if (_root == NULL)  {   _root = new Node(key, value);  }  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 (parent->_key > key)  {   parent->_left = new Node(key, value);  }  else  {   parent->_right = new Node(key, value);  }  return true; } //在二叉搜尋樹中查詢節點 Node* Find(const K& key) {  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;  }  //只有一個節點  if (_root->_left == NULL&&_root->_right == NULL)  {   if (_root->_key == key)   {    delete _root;    _root = NULL;    return true;   }   return false;  }  Node* parent = NULL;  Node* cur = _root;  //遍歷查詢要刪除節點的位置  while (cur)  {   Node* del = NULL;   if (cur->_key > key)   {    parent = cur;    cur = cur->_left;   }   else if (cur->_key < key)   {    parent = cur;    cur = cur->_right;   }   else   {    //要刪除節點的左子樹為空，分3種情況    if (cur->_left == NULL)    {     //注意判斷父節點是否為空，若為空，則要刪除的節點為根節點,如：只有根節點5和其右節點9     if (parent == NULL)     {      _root = cur->_right;      delete cur;      cur = NULL;      return true;     }     if (parent->_key > cur->_key)     {      del = cur;      parent->_left = cur->_right;      delete del;      return true;     }     else if (parent->_key < key)     {      del = cur;      parent->_right = cur->_right;      delete del;      return true;     }    }    //要刪除節點的右子樹為空，同樣分3種情況    else if (cur->_right == NULL)    {     //注意判斷父節點是否為空，若為空，則要刪除的節點為根節點,如：只有根節點5和其左節點3     if (parent == NULL)     {      _root = cur->_left;      delete cur;      cur = NULL;      return true;     }     if (parent->_key > cur->_key)     {      del = cur;      parent->_left = cur->_left;      delete del;      return true;     }     else if (parent->_key < cur->_key)     {      del = cur;      parent->_right = cur->_left;      delete del;      return true;     }    }    //左右子樹都不為空    else    {     Node* del = cur;     Node* parent = NULL;     Node* RightFirst = cur->_right;     //右邊第一個節點的左子樹為空     if (RightFirst->_left == NULL)     {      swap(RightFirst->_key, cur->_key);      swap(RightFirst->_value, cur->_value);      del = RightFirst;      cur->_right = RightFirst->_right;      delete del;      return true;     }     //右邊第一個節點的左子樹不為空     while (RightFirst->_left)     {      parent = RightFirst;      RightFirst = RightFirst->_left;     }        swap(RightFirst->_key, cur->_key);        swap(RightFirst->_value, cur->_value);        del = RightFirst;        parent->_left = RightFirst->_right;        delete del;           return true;    }   }  }  return false; } bool Insert_R(const K& key, const V& value) {  return _Insert_R(_root, key, value); } Node* Find_R(const K& key) {  return _Find_R(_root, key); } bool Remove_R(const K& key) {  return _Remove_R(_root, key); } void InOrder() {  _InOrder(_root);  cout << endl; }protected:    bool _Remove_R(Node*& root, const K& key)  {   //沒有節點   if (root == NULL)   {    return false;   }   //只有一個節點   if (root->_left == NULL&&root->_right == NULL)   {    if (root->_key == key)    {     delete root;     root = NULL;     return true;    }    else    {     return false;    }   }   //刪除二叉搜尋樹節點的遞迴寫法   if (root->_key > key)   {    _Remove_R(root->_left, key);   }   else if (root->_key < key)   {    _Remove_R(root->_right, key);   }   else   {    Node* del = NULL;        if (root->_left == NULL)    {     del = root;     root = root->_right;     delete del;     del = NULL;     return true;    }    else if (root->_right == NULL)    {     del = root;     root = root->_left;     delete del;     del = NULL;     return true;    }    else    {     Node* RightFirst = root->_right;     while (RightFirst->_left)     {      RightFirst = RightFirst->_left;     }     swap(root->_key, RightFirst->_key);     swap(root->_value, RightFirst->_value);     _Remove_R(root->_right, key);     return true;    }   }  }  //遞迴查詢法  Node* _Find_R(Node* root, const K& key)  {   if (root == NULL)   {    return NULL;   }   if (root->_key > key)   {    return _Find_R(root->_left, key);   }   else if (root->_key < key)   {    return _Find_R(root->_right, key);   }   else   {    return root;   }  }     //遞迴插入法  bool _Insert_R(Node*& root, const K& key, const V& value)  {   if (root == NULL)   {    root = new Node(key, value);    return true;   }   if (root->_key > key)   {    return _Insert_R(root->_left, key, value);   }   else if(root->_key < key)   {    return _Insert_R(root->_right, key, value);   }   else   {    return false;   }  }  void _InOrder(Node* root)  {   if (root == NULL)   {    return;   }   _InOrder(root->_left);   cout << root->_key << " ";   _InOrder(root->_right);  }protected: Node* _root;};void Test(){ BSTree<int, int> s;  //測試插入 s.Insert_R(5, 1); s.Insert_R(4, 1); s.Insert_R(3, 1); s.Insert_R(6, 1); s.Insert_R(1, 1); s.Insert_R(2, 1); s.Insert_R(0, 1); s.Insert_R(9, 1); s.Insert_R(8, 1); s.Insert_R(7, 1); //二叉搜尋樹按中序輸出是有序的 s.InOrder(); //測試查詢 cout << s.Find_R(6)->_key << endl; //測試刪除 s.Remove(4); s.Remove(6); s.Remove(3); s.Remove(1); s.Remove(2);  //再次列印刪除後的結果 s.InOrder();}int main(){ Test(); system("pause"); return 0;}

0 1 2 3 4 5 6 7 8 9
6
0 5 7 8 9
請按任意鍵繼續. . .

給我老師的人工智慧教程打call！http://blog.csdn.net/jiangjunshow