[BinaryTree] 二叉搜索树（二叉查找树、二叉排序树）

二叉查找树（BinarySearch Tree，也叫二叉搜索树，或称二叉排序树BinarySort Tree）或者是一棵空树，或者是具有下列性质的二叉树：

（1）若它的左子树不为空，则左子树上所有结点的值均小于它的根结点的值；

（2）若它的右子树不为空，则右子树上所有结点的值均大于它的根结点的值；

（3）它的左、右子树也分别为二叉查找树。

下面是它的几个重要函数：

插入结点：

【思路1】递归

终止条件（1,2）：

1.若插入到一个空树中，则新建结点为根结点，左右孩子置为空，返回true

2.若等于根结点的值，返回false

3.若当前值小于根结点的值，递归左子树，否则递归右子树

 template<class T>
 bool BinarySearchTree<T>::InsertNode(BinaryTreeNode<T> * &root, T newpointer)
 {
     if (root == NULL)
     {
         root = new BinaryTreeNode<T>;
         root->element = newpointer;
         root->LeftChild = root->RightChild = NULL;
         return true;
     }
     if (newpointer == root->element)
         return false;
     if (newpointer < root->element)
         return InsertNode(root->LeftChild, newpointer);
     else
         return InsertNode(root->RightChild, newpointer);
 }

【思路2】非递归

1.若二叉树为空，则首先单独生成根结点

2.执行查找算法，找出被插结点的父亲结点

3.判断被插结点是其父亲结点的左、右儿子，并将被插结点作为叶子结点插入

注：新插入的结点总是叶子结点

 template<class T>
 bool BinarySearchTree<T>::InsertNode(BinaryTreeNode<T> * &root, T newpointer)
 {
     if (root == NULL)
     {
         root = new BinaryTreeNode<T>;
         root->element = newpointer;
         root->LeftChild = root->RightChild = NULL;
         return true;
     }
     BinaryTreeNode<T> *pointer = root;
     while(pointer != NULL)
     {
         if (newpointer == pointer->element)
             return false;
         else if (newpointer < pointer->element)
         {
             if(pointer->LeftChild == NULL)
             {
                 BinaryTreeNode<T>* l = new BinaryTreeNode<T>(newpointer);
                 l->LeftChild = l->RightChild = NULL;
                 pointer->LeftChild = l;
                 return true;
             }
             pointer = pointer->LeftChild;
         }
         else
         {
             if(pointer->RightChild == NULL)
             {
                 BinaryTreeNode<T>* r = new BinaryTreeNode<T>(newpointer);
                 r->LeftChild = r->RightChild = NULL;
                 pointer->RightChild = r;
                 return true;
             }
             pointer = pointer->RightChild;
         }
     }
 }

删除结点：

【思路】删除二叉搜索树中结点要根据删除的位置分情况讨论

1.删除叶子结点

操作：直接删除，更改它的父亲结点的相应指针场为空。

2.删除结点只有左儿子或只有右儿子

操作：将该结点的子树直接接到该结点位置

3.删除结点有两个子结点

（1）合并删除

（2）通过复制进行删除

选取替身（左子树中最大的结点或右子树中最小的结点）替换到删除结点的位置

 template<class T>
 void BinarySearchTree<T>::deleteBinarySearchTree(BinaryTreeNode<T>* root, T x)
 {
     bool find = false;
     int flag = ;//标志要删除的结点是前驱结点pre的左孩子还是右孩子
     BinaryTreeNode<T> *pre = NULL;
     while (root && !find)
     {
         if (x == root->element)
         {
             find = true;
         }
         else if (x < root->element)
         {
             pre = root;
             root = root->LeftChild;
             flag = -;
         }
         else
         {
             pre = root;
             root = root->RightChild;
             flag = ;
         }
     }
     if (root == NULL)
     {
         cout << "未找到要删除元素" << endl;
         return;
     }
     //此时root为要删除结点

     //要删除结点是叶子结点
     if (root->isLeaf())
     {
         if (flag == )
         {
             delete root;
             root = NULL;
         }
         else if (flag == -)
         {
             pre->LeftChild = NULL;
             delete root;
             root = NULL;
         }
         else
         {
             pre->RightChild = NULL;
             delete root;
             root = NULL;
         }
     }

     //要删除结点具有左右子结点
     else if (root->LeftChild && root->RightChild)
     {
         //复制删除，选取左子树中最大的结点替换
         BinaryTreeNode<T> *t = root;
         BinaryTreeNode<T> *s = root->LeftChild;
         while (s->RightChild)
         {
             t = s;
             s = s->RightChild;
         }
         root->element = s->element;

         //此时S只有左孩子，需要连接到它的前驱结点t上
         if (root == t)//while循环未执行
         {
             t->LeftChild = s->LeftChild;
         }
         else//while循环已执行
         {
             t->RightChild = s->LeftChild;
         }
         delete s;
         s = NULL;
     }

     else//要删除结点为单支子树根结点
     {
         if (flag == )//root为根结点
         {
             if (root->LeftChild)
             {
                 pre = root;
                 root = root->LeftChild;
                 delete pre;
                 pre = NULL;
             }
             else
             {
                 pre = root;
                 root = root->RightChild;
                 delete pre;
                 pre = NULL;
             }
         }
         else if (flag == -)//root为pre的左子树
         {
             if (root->LeftChild)//要删除结点只存在左子树
             {
                 pre->LeftChild = root->LeftChild;
                 delete root;
                 root = NULL;
             }
             else//要删除结点只存在右子树
             {
                 pre->LeftChild = root->RightChild;
                 delete root;
                 root = NULL;
             }
         }
         else//root为pre的右子树
         {
             if (root->LeftChild)//要删除结点只存在左子树
             {
                 pre->RightChild = root->LeftChild;
                 delete root;
                 root = NULL;
             }
             else//要删除结点只存在右子树
             {
                 pre->RightChild = root->RightChild;
                 delete root;
                 root = NULL;
             }
         }
     }
 }

查找结点：

【思路】分割式查找法：

1.若根结点的关键码等于查找的关键码，成功。

2.否则，若小于根结点的关键码，查其左子树；大于根结点的关键码，查其右子树。

二叉搜索树的高效率在于继续检索时只需查找两棵子树之一。

 template<class T>
 BinaryTreeNode<T>* BinarySearchTree<T>::Search(BinaryTreeNode<T>* root, T x)
 {
     BinaryTreeNode<T>* current = root;
     while((NULL != current) && (x != current->element))
     {
         if(x < current->element)
             current = Search(root->LeftChild,x);
         else
             current = Search(root->RightChild,x);
     }
     return current;
 }