1.概念：

二叉查找树也叫二叉搜索树，是一棵空树或者是具有一下性质的一颗二叉树

a.每个节点都有一个作为搜索依据的关键码（key），而且所有的关键码的取值都互不相同。

b.每个左子树（如果存在）所有节点的关键码都小于根节点的关键码。

c.每个右子树（如果存在）所有节点的关键码都大于根节点的关键码。

d.每个左子树和右子树也均为二叉搜索树。

需要说明的是，关键码事实上是节点所保存元素中的某个域的值，它能够唯一的表示这个结点，因此，如果对一颗二叉搜索树进行中序遍历，就可以按照从小到大的顺序将各个结点的关键排列起来，因此二叉搜索树也被称为二叉排序树。

2.二叉搜索树相关的算法：

a.搜索算法：

在二叉搜索树上进行搜索，过程是从一个根节点开始，沿着某一个分支逐层向下进行比较判别的过程，这个过程可以是一个递归的过程，也可以是一个迭代的过程。因为通常使用递归的方法来定义二叉树类，因此搜索算法通常也使用递归的思想来编写。主要过程如下：

假设想要在二叉搜索树中搜索关键码为x的元素，搜索过程从根节点开始，如果根结点为nullptr(空指针),则直接返回搜索失败，否则用给定的值x与根结点的关键码相比较，如果给定的值等于根结点的关键码中的值，则返回搜索成功的信息，并提交搜索到的结点地址。如果给定值小于根结点的关键码，则继续递归搜索根结点的左子树，窦泽，进行递归搜索根结点的右子树。

b.插入算法：

向二叉搜索树中插入一个元素，必须先检查这个元素在已有的树中是否已经存在。所以 在进行插入之前，可以先使用搜索算法在树中检查准备要插入的元素是否存在。如果返回搜索成功的信息，说明在这棵二叉搜索树中已有这个元素，就不再进行插入操作。否则，说明在树中没有要插入的这个元素。再把新元素添加到搜索操作停止的地方。在将要插入的元素与搜索操作返回的地址的关键码相比较。如果小于，则插入为左子树，否则成为右子树。

在插入过程中需要注意，每次的结点的插入，都要从根结点出发先搜索插入的位置，然后把新结点作为叶结点插入，这样不需要移动结点，只需要修改某个已有树中结点的空指针即可。

c.二叉搜索树的删除

在二叉搜索树中删除一个结点时，必须将因删除结点而断开的二叉链表重新连接起来，同时又要确保二叉搜索树的性质不丢失。此外，为了保证在删除结点后树的搜索性能不至于降低，还需要防止重新连接后输的高度不能增加。因此，删除算法需要分为几种情况进行讨论。

(1).如果想要删除叶结点，只需将父结点指向它的指针进行清零操作即可，在释放掉这个结点即可。

(2).如果被删除的结点右子树为空，则可以用它的左子女结点代替它的位置，再释放掉这个结点；若被删除结点左子树为空，则可以用它的右子女结点代替它的位置，再释放掉这个结点即可。

(3)如果被删除结点的左右子树都不为空，则可以在它的右子树下寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除的结点中，再来处理这个结点的删除问题。

同样的，这也是一个递归处理的过程。之后进行递归删除即可。

相关实现程序如下

二叉搜索树的头文件：

/
//  BST.h
//  BinarySearchTree
//
//  Created by 大幕 on 2017/3/2.
//  Copyright © 2017年 Damu. All rights reserved.
//

//  构建一颗二叉查找树并进行使用
//  特点，每一个元素有一个键值，左子树比根节点小，右子树比根节点大,且左右子树都是二叉查找树


#ifndef BST_h
#define BST_h

#include <iostream>

enum Boolean { FALSE, TRUE };      //定义自己的布尔类型

//使用C++的模板类来设计二叉查找树

template <class Type>
class Element
{
public:
    Type key;
    //可以很容易的添加更多的数据
};

template<class Type> class BST;     //声明类

template <class Type>
class BstNode      //二叉查找树的结点类
{
    friend class BST<Type>;     //定义为友元类，方便操作BstNode的私有成员
public:
    Element<Type> data;
    BstNode * LeftChild;
    BstNode * RightChild;
    void display(int i);
};

template <class Type>
class BST
{
public:
    BST(BstNode<Type> *init = 0)
    {
        root = init;
    }
    Boolean Insert(const Element<Type>& x);     //插入结点操作
    Boolean Remove(BstNode<Type> * ptr, const Element<Type>& x);     //删除以ptr为根结点，关键码为x的结点
    Boolean Remove(const Element<Type>& x);     //配合上一个函数实现删除操作
    BstNode<Type>* Search(const Element<Type>& x);     //使用递归的方法进行查找
    BstNode<Type>* Search(BstNode<Type> *, const Element<Type> &);     //重载函数进行查找
    BstNode<Type>* IterSearch(const Element<Type>&);   //使用迭代进行查找
    void display()
    {
        std::cout << '\n';
        if (root)
            root->display(1);
        else
            std::cout << "这是一颗空树\n";
    }
private:
    BstNode<Type> *root;

};

template <class Type>
void BstNode<Type>::display(int i)
{
    //用来显示当前节点的数据以及它所有的左子树和右子树的数据，利用递归的方法
    std::cout << "Position: " << i << ": data.key = " << data.key << '\n'; //先显示位置，再显示数据
    if (LeftChild)
        LeftChild->display(2 * i);      //递归左子树
    if (RightChild)
        RightChild->display(2 * i + 1);   //递归右子树
}

template <class Type>
Boolean BST<Type>::Insert(const Element<Type> &x)
{
    BstNode<Type> *p = root;
    BstNode<Type> *q = 0;       //q指向p的父节点
    //insert之前需要先进行查找，找到合适的位置进行插入
    while (p)
    {
        q = p;      //在每次改变之前使用q将p进行保留下来
        if (x.key == p->data.key)
            return FALSE;       //发生重复，插入失败
        if (x.key < p->data.key)
            p = p->LeftChild;
        else
            p = p->RightChild;
    }
    //循环结束后，找到了位置q
    p = new BstNode<Type>;
    p->LeftChild = nullptr;
    p->RightChild = nullptr;
    p->data = x;
    if (!root)
        root = p;
    else if (x.key < q->data.key)
        q->LeftChild = p;
    else
        q->RightChild = p;
    return TRUE;        //表示插入成功
}

//删除以ptr为根结点，关键码为x的结点
template<class Type>
Boolean BST<Type>::Remove(BstNode<Type> * ptr, const Element<Type>& x)
{
    BstNode<Type> *temp = nullptr;
    ptr = root;
    if (ptr != nullptr)
    {
        if (x.key < ptr->data.key)
            Remove(ptr->LeftChild, x);       //在左子树中执行删除
        else if (x.key > ptr->data.key)
            Remove(ptr->RightChild, x);      //在右子树中执行删除
        else if (ptr->LeftChild != nullptr && ptr->RightChild != nullptr)
        {
            //ptr指到了关键码为x的结点，而且这个结点有两个子女
            temp = ptr->RightChild;     //找到右子树搜寻中序下的第一个结点
            while (temp->LeftChild != nullptr)
                temp = temp->LeftChild;
            ptr->data.key = temp->data.key;     //使用temp中数据代替此时ptr结点中的数据
            Remove(ptr->RightChild, ptr->data);  //递归删除右子树中的temp结点
        }
        else
        {
            //ptr也指到了关键码为x的结点，但是它只有1个或0个子女
            temp = ptr;
            if (ptr->LeftChild == nullptr)
                ptr = ptr->RightChild;
            else
                ptr = ptr->LeftChild;
            delete temp;
            return TRUE;

        }

    }
    return FALSE;
}

//删除函数
template <class Type>
Boolean BST<Type>::Remove(const Element<Type> &x)
{
    return Remove(root, x);
}


//搜索函数
template <class Type>
BstNode<Type> *BST<Type>::Search(const Element<Type> &x)
{
    return Search(root, x);
}

template<class Type>
BstNode<Type> * BST<Type>::Search(BstNode<Type> *b, const Element<Type>& x)
{
    //从节点b开始找数值为x的结点
    if (!b)
        return 0;
    if (x.key == b->data.key)
        return b;
    if (x.key < b->data.key)
        return Search(b->LeftChild, x);
    return Search(b->RightChild, x);
}

//迭代的查找方法
template<class Type>
BstNode<Type>* BST<Type>::IterSearch(const Element<Type> &x)
{
    for (BstNode<Type> *t = root; t;)
    {
        if (x.key == t->data.key)
            return t;
        if (x.key < t->data.key)
            t = t->LeftChild;
        else
            t = t->RightChild;
    }
    return 0;
}

#endif /* BST_h */