数据结构-查找二叉树

查找二叉树：始终满足任一节点的左儿子小于该节点，右儿子大于该节点，

由于其特性，查找二叉树的中序遍历始终为从小到大；

需要注意的是二叉查找树的删除，有2种策略，在删除节点不多时可以采用懒惰删除，即标记该节点删除而非真正的delete，第二种是当删除节点只有一个儿子或则为叶子节点即没有儿子时，可直接删除并将儿子移至该节点，而当删除节点有左右儿子时将其右子树最小的节点移动至该节点，当然这里并非真正的移动而是将目标节点的值赋给他，并删除目标节点，这里选用右子树最小的节点可以保证不破坏查找二叉树的特性，

另外需要掌握的是由中序前序推出后序或则由中序后序推前序

/***********************************************
     >  Filename: BST.cpp
     >  Author:   Pyt
     >  Create:   2017-08-04 11:11:03
************************************************/

#include <iostream>
#include <queue>
#include <utility>
using namespace std;

template<typename T>
class BST{
public:
    BST();
    ~BST();
    BST(const BST &t);
    BST& operator=(const BST &t);

    void insert(const T &val);
    void remove(const T &val);
    void clear();
    bool empty() const;
    bool contains(const T &val) const;
    
    void inorder();
    void levelorder() const;

    T findMin() const;
    T findMax() const;

private:
    struct Node{
        T val;
        Node *left;
        Node *right;
        Node(T x, Node *l = NULL, Node *r = NULL) : val(x), left(l), right(r){}
    };
    Node *root;
    
    void insert(const T &val, Node *&t);
    void remove(const T &val, Node *&t);
    void clear(Node *&t);
    bool contains(const T &val, Node *&t) const;

    void inorder(Node *&t) const;
    Node* copy_tree(Node *t);

    Node* findMin(Node *t) const;
    Node* findMax(Node *t) const;
};
/**构造函数****/
template<typename T>
BST<T>::BST()
 : root(NULL)
{

}
/***析构*****/
template<typename T>
BST<T>::~BST()
{
    clear();
}
/***拷贝赋值****/
template<typename T>
BST<T>::BST(const BST &t)
{
    root = copy_tree(t.root);
}
/****赋值重载****/
template<typename T>
BST<T>& BST<T>::operator=(const BST &t)
{
    if(this != &t)
    {
        clear();
        root = copy_tree(t.root);
    }
    return *this;
}
/**插入***/
template<typename T>
void BST<T>::insert(const T &val)
{
    insert(val, root);
}
/***删除*****/
template<typename T>
void BST<T>::remove(const T &val)
{
    remove(val, root);
}
/****清空查找树****/
template<typename T>
void BST<T>::clear()
{
    clear(root);
}
/***判断树是否为空***/
template<typename T>
bool BST<T>::empty() const
{
    return root==NULL;
}
/****判断是否包含某元素****/
template<typename T>
bool BST<T>::contains(const T &val) const
{
    return contains(val, root);
}
/***中序遍历****/
template<typename T>
void BST<T>::inorder()
{
    inorder(root);
}
/***层序遍历****/
template<typename T>
void BST<T>::levelorder() const
{
    int curlevel = 0;
    queue<pair<Node*, int>> q;
    if(root)
      q.push(make_pair(root, 0));
    while(!q.empty())
    {
        pair<Node*, int> tmp = q.front();
        q.pop();
        if(tmp.second > curlevel)
        {
            cout << endl;
            curlevel = tmp.second;
        }
        cout << tmp.first->val << " ";
        if(tmp.first->left)
          q.push(make_pair(tmp.first->left, curlevel+1));
        if(tmp.first->right)
          q.push(make_pair(tmp.first->right, curlevel+1));
    }
    cout << endl;
}
/***获取最小元值****/
template<typename T>
T BST<T>::findMin() const
{
    if(root)
        return findMin(root)->val;
}
/****获取最大元值****/
template<typename T>
T BST<T>::findMax() const
{
    if(root)
        return findMax(root)->val;
}
/***寻找插入私有函数****/
template<typename T>
void BST<T>::insert(const T &val, Node *&t)
{

    if(t == NULL)
      t = new Node(val);
    if(val < t->val)
      insert(val, t->left);
    else if(val > t->val)
      insert(val, t->right);
}
/****寻找删除私有函数****/
template<typename T>
void BST<T>::remove(const T &val, Node *&t)
{
    if(t == NULL)
      return ;
    if(val < t->val)
      remove(val, t->left);
    else if(val > t->val)
      remove(val, t->right);
    else
    {
        if(t->left && t->right)
        {
            t->val = findMin(t->right)->val;
            remove(val, t->right);
        }
        else{
            Node *obj = t;
            t = t->left ? t->left : t->right;
            delete obj;
        }
    }
}
/****清空树私有函数*****/
template<typename T>
void BST<T>::clear(Node *&t)
{
    if(t)
    {
        clear(t->left);
        clear(t->right);
        delete t;
    }
    t = NULL;
}
/***查找是否包含元素私有函数****/
template<typename T>
bool BST<T>::contains(const T &val, Node *&t) const
{
    if(t == NULL)
      return false;
    else if(val < t->val)
      return contains(val, t->left);
    else if(val > t->val)
      return contains(val, t->right);
    else 
      return true;
}
/***中序遍历私有函数****/
template<typename T>
void BST<T>::inorder(Node *&t) const
{
    if(t)
    {
        inorder(t->left);
        cout << t->val << " ";
        inorder(t->right);
    }
}
/****深拷贝树私有函数*****/
template<typename T>
typename BST<T>::Node* BST<T>::copy_tree(Node *t)
{
    if(t == NULL)
      return NULL;
    else
      return new Node(t->val, copy_tree(t->left), copy_tree(t->right));
}
/**找到最小节点私有函数***/
template<typename T>
typename BST<T>::Node* BST<T>::findMin(Node *t) const
{
    if(t->left == NULL)
      return t;
    else
      return findMin(t->left);
}
/***找到最大节点私有函数****/
template<typename T>
typename BST<T>::Node* BST<T>::findMax(Node *t) const
{
    if(t->right == NULL)
      return t;
    else
      return findMax(t->right);
}

int main()
{
    BST<int> a;
    a.insert(8), a.insert(6), a.insert(5), a.insert(7), a.insert(3), a.insert(9), a.insert(7);
    a.levelorder();
    a.remove(6);
    a.levelorder();
    BST<int> b(a);
    b.levelorder();
    BST<int> c;
    c = a;
    c.levelorder();
    c.inorder();
    cout << endl;
    cout << a.findMax() << " " << a.findMin() << endl;
    c.clear();
    cout << c.empty() << endl;
}