二叉搜索树

参考：https://blog.csdn.net/yanxiaolx/article/details/51986428

二叉搜索树，也称有序二叉树,排序二叉树，是指一棵空树或者具有下列性质的二叉树：

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 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;  
    }  
}  

堆不是平衡二叉树。
首先，我们应该有这样的一个约定： 二叉平衡树（AVL）肯定是一颗二叉排序树，又称平衡二叉排序树
因为只有这样，二叉平衡树才有存在的意义。我们引入二叉平衡树，就是 为了解决二叉排序树的查找效率问题 。
这样的话，堆肯定就不是一颗平衡二叉树了， 二叉排序树：或是一颗空树，或者是结点的左子树上的结点关键字都比该结点关键字值小 ，该结点的右子树上的结点关键字之都比该结点的关键字值大，并且是递归定义的。
堆：对于一个数组中的关键字，如果按照完全二叉树的结点来造树，则 完全二叉树中的非终端结点关键字值不大于（不小于）其左右孩子的值。
所以综上所述可知，堆不是一颗二叉平衡树。