启迪思维：二叉树

很多初级点的程序员会认为树结构无用论，也有初级程序员仅仅以为只有面试才会用到，还有自认为实际工作用不到(我身边工作好几年程序员懂树结构也没有几个)，其实归根到底还是不清楚树的实际用途，下面分享我参加培训时候一个小尴尬。

 

因为项目数据量很大(有很多表数据量都上亿的)，对写sql能力要求很高，项目组会经常组织些数据库方面的培训，前段时间又参加公司一个SQL原理分析的一个培训，在培训中讲师问“为什么SQL走索引查询速度很快呢？”，我直接大声说“索引底层数据结构是B树，查询的时候用二分查找”，结果整个大房间就我一个人声音，所有同事都看过来，场面有点尴尬。

 

上一篇文章分析树基本概念、名词解释、树三种遍历方式，今天继续来看二叉树各种名词概率，看这些名词概念，肯定是各种不爽，大概浏览下知道怎么回事就ok。

 

一：概念，下面这些内容摘自维基百科

在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。

二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有个结点；深度为k的二叉树至多有个结点；对任何一棵二叉树T，如果其终端结点数为，度为2的结点数为，则。

树和二叉树的三个主要差别：

树的结点个数至少为1，而二叉树的结点个数可以为0；

树中结点的最大度数没有限制，而二叉树结点的最大度数为2；

树的结点无左、右之分，而二叉树的结点有左、右之分。

完全二叉树和满二叉树

满二叉树：一棵深度为k，且有个节点成为满二叉树

完全二叉树：深度为k，有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中序号为1至n的节点对应时，称之为完全二叉树

 

二：示例图

 

三：动画图

四：代码分析

 1、是否为空

/**
 * 若树为空，则返回true;否则返回false
 */
bool IsEmpty() {
    return root == 0;
}

2、计算树的深度

/**
 * 以传入节点为基础计算树的深度
 */
int GetTreeDept(const TNode<T> *t) {
    int i, j;
    if (t == 0) {
        return 0;
    } else {
        //递归计算左子树的深度
        i = this->GetTreeDept(t->lchild);
        //递归计算右子树的深度
        j = this->GetTreeDept(t->rchild);
    }

    //t的深度为其左右子树中深度中的大者加1
    return i > j ? i + 1 : j + 1;
}

3、清空树的节点

/**
 *清空树的所有节点
 */
void Clear() {
    Clear(root);
}

/**
 *根据节点递归清空树
 */
void Clear(TNode<T>* t) {
    //判断指针是否为空
    if (t) {
        //获取资源立即放入管理对象(参考Effective C++里边条款13)
        //tr1::shared_ptr(引用计数智慧指针)管理对象比auto_ptr更强大
        std::auto_ptr<TNode<T> > new_ptr(t);

        //递归清空右子树
        Clear(new_ptr->rchild);

        //递归清空左子树
        Clear(new_ptr->lchild);
    }

    //清空树的根节点
    t = 0;
}

4、获取树最大节点和最小节点

/**
 *获取树的最大节点
 */
TNode<T>* GetMax(TNode<T>* t) const {
    //判断数节点是否为空
    if (t) {
        //根据二叉树特性，最大值一定在右子树；
        //循环右子树，直到叶子节点
        while (t->rchild) {
            //指向下一个节点
            t = t->rchild;
        }
    }
    //返回找到最大节点
    return t;
}
/**
 *获取树的最小节点
 */
TNode<T>* GetMin(TNode<T>* t) const {
    //判断数节点是否为空
    if (t) {
        //根据二叉树特性，最大值一定在左子树；
        //循环左子树，直到叶子节点
        while (t->lchild) {
            //指向下一个节点
            t = t->lchild;
        }
    }
    //返回找到最小节点
    return t;
}
/**
 *根据模式类型查找树的最大值或者最小值
 */
TNode<T>* GetNode(Mode mode) const {
    //t指向根节点
    TNode<T>* t = root;
    //判断数节点是否为空
    if (t) {
        if (mode == Min) {
            //根据二叉树特性，最大值一定在左子树；
            //循环左子树，直到叶子节点
            while (t->lchild) {
                //指向左子树下一个节点
                t = t->lchild;
            }
        } else if (mode == Max) {
            //根据二叉树特性，最大值一定在右子树；
            //循环右子树，直到叶子节点
            while (t->rchild) {
                //指向右子树下一个节点
                t = t->rchild;
            }
        }
    }
    //返回找到节点
    return t;
}

5、获取传入节点父节点

/**
 *获取传入的节点从传入树p中找到它的父节点
 */
TNode<T>* GetParentNode(TNode<T> *p, const T &value,TNode<T> *returnValue) {
    //p节点存在并且传入的值不是根节点值
    if (p && p->data == value) {
        return 0;
    }

    //用二分查找定位值value所在节点
    TNode<T> *t = this->SearchTree(p, value);

    //判断t和p都不为空
    if (t && p) {
        //如果value的节点等于p节点左孩子或者右孩子，p就是value的节点父亲
        if (p->lchild == t || p->rchild == t) {
            //赋值p节点给返回值变量
            returnValue = p;
        } else if (value > p->data) {//如果value只大于p节点值，则递归右孩子
            //直到找到value的父节点复制给返回值变量
            returnValue = GetParentNode(p->rchild, value,returnValue);
        } else {////如果value只小于p节点值，则递归左孩子
            //直到找到value的父节点复制给返回值变量
            returnValue = GetParentNode(p->lchild, value,returnValue);
        }
    }

    return returnValue;

}

/**
 *获取传入的节点的父节点
 */
TNode<T>* GetParentNode(const T &value,TNode<T> *returnValue) {
    return this->GetParentNode(root, value,returnValue);
}

6、二分查找

代码分析：

/**
 * 在以T为根节点的树中搜索值为value的节点
 */
TNode<T>* SearchTree(TNode<T>* &t, const T &value) {
    //判断t节点是否为空
    while (t) {
        //如果节点值等于value，则表明已经找到目标节点
        if (t->data == value) {
            return t;
        } else if (value > t->data) {//如果value大于t节点值，则递归查询右子树
            return SearchTree(t->rchild, value);
        } else {//如果value小于t节点值，则递归查询左子树
            return SearchTree(t->lchild, value);
        }
    }
    return t;
}

 动画演示：

7、插入节点

代码分析：

/**
 *插入一个节点到目标树中
 */
void Insert(const T &value, TNode<T>* &t) {
    //如果目标树为空，则新new一个根节点
    if (t == 0) {
        //新创建一个节点，并把value设置为节点值
        t = new TNode<T>(value);
    } else if (value < t->data) {//如果value值小于t节点值
        //递归左子树插入函数，直到找到节点插入
        this->Insert(value, t->lchild);
    } else if (value > t->data) {//如果value值大于t节点值
        //递归右子树插入函数，直到找到节点插入
        this->Insert(value, t->rchild);
    }
}
/**
 *插入一个节点到根节点为root的树中
 */
void Insert(const T &value) {
    this->Insert(value, root);
}

动画演示

8、删除节点

代码分析：

/**
 *根据节点值删除节点信息
 */
void Delete(const T &value) {
    Delete(value, root);
}
/**
 *根据节点值删除以传入t为根节点树节点信息
 */
void Delete(const T &value, TNode<T>* &t) {
    //判断是否t为空null
    if (t) {
        //通过二分查找定位value所在的节点
        TNode<T> *p = this->SearchTree(t, value);
        //中间变量，用于待删除节点左右子树都不为空的情况下
        TNode<T> *q = p;
        if (p) {
            //如果p节点的左右孩子都不为空，则根据二叉树定义
            //必须在子右子树中找到最新节点作为新节点
            //当左右子树都为空情况下，右子树最小节点就是树(中序遍历)节点的后继节点
            if (p->lchild != 0 && p->rchild != 0) {
                //获取右子树中最小的节点
                q = this->GetMin(p->rchild);
            }
            //获取资源立即放入管理对象(参考Effective C++里边条款13)
            //tr1::shared_ptr(引用计数智慧指针)管理对象比auto_ptr更强大
            //如果p节点的左右子树都不为空，则释放p节点子右子树的最小节点
            //改变p节点的值即可
            auto_ptr<TNode<T> > new_ptr(q);

            TNode<T> *parent = 0;
            TNode<T> *returnValue;
            //删除叶子节点(节点左右孩子都为空)
            if (p->lchild == 0 && p->rchild == 0) {
                //如果p节点和传入的根节点相等
                if (t == p) {
                    //直接设置t为空
                    t = 0;
                } else {
                    //获取p节点的父节点
                    parent = this->GetParentNode(t, p->data,returnValue);

                    //如果父节点的左孩子等于p节点
                    if (parent->lchild == p) {
                        //设置父节点的左孩子等于空
                        parent->lchild = 0;
                    } else {//如果父节点的右孩子等于p节点
                        //设置父节点的右孩子等于空
                        parent->rchild = 0;
                    }
                }

            } else if (p->rchild == 0) {//删除节点p右孩子为空，左孩子有节点
                //如果p节点和传入的根节点相等
                if (t == p) {
                    //直接设置t节点等于左孩子
                    t = t->lchild;
                } else {
                    //获取p节点的父节点
                    parent = this->GetParentNode(t, p->data,returnValue);
                    //如果父节点的左孩子等于p节点
                    if (parent->lchild == p) {
                        //设置父节点左孩子等于p节点左孩子
                        parent->lchild = p->lchild;
                    } else {//如果父节点的右孩子等于p节点
                        //设置父节点右孩子等于p节点左孩子
                        parent->rchild = p->lchild;
                    }
                }

            } else if (p->lchild == 0) {//删除节点p左孩子为空，右孩子有节点
                //如果p节点和传入的根节点相等
                if (t == p) {
                    //直接设置t节点等于右孩子
                    t = t->rchild;
                } else {
                    //获取p节点的父节点
                    parent = this->GetParentNode(t, p->data,returnValue);
                    //如果父节点的右孩子等于p节点
                    if (parent->rchild == p) {
                        //设置父节点右孩子等于p节点右孩子
                        parent->rchild = p->rchild;
                    } else {//如果父节点的左孩子等于p节点
                        //设置父节点右孩子等于p节点右孩子
                        parent->lchild = p->rchild;
                    }
                }
            } else {//删除节点p左右都有孩子
                //获取q节点的父节点
                parent = this->GetParentNode(t,q->data,returnValue);
                //设置p节点值等于q节点值
                p->data = q->data;
                //如果q的父节点等于p
                if (parent == p) {
                    //设置q节点的父节点右孩子为q节点右孩子
                    parent->rchild = q->rchild;
                } else {//
                    //设置q节点的父节点左孩子为q节点右孩子
                    parent->lchild = q->rchild;
                }

            }
        }
    }
}

动画演示

9、获取目标节点后继节点(中序遍历) 

/**
 *在传入p的树中找出节点值为value的后继节点方法
 */
TNode<T>* TreeSuccessor(TNode<T> *p,const T &value,TNode<T> *returnValue){
    //如果t节点非空
    if(p){
        //传入p树和节点值value找到对应的节点
        TNode<T> *t = this->SearchTree(p, value);
        //如果节点右子树不为空
        if(t->rchild != 0){
            //直接获取右子树中最小节点，即是节点的后继节点
            returnValue = this->GetMin(t->rchild);
        }else{
            //获取目标节点父节点
            TNode<T> *parent = this->GetParentNode(t->data,returnValue);

            //如果父节点不为空并且t节点等于父节点的右节点，这一个文字不太好描述，请参照图
            while(parent && t == parent->rchild){
                //父节点赋值给t节点
                t = parent;
                //获取父节点的父节点(目标节点爷爷)
                parent = this->GetParentNode(parent->data,returnValue);
            }
            //找到后继节点赋值给返回变量
            returnValue = parent;
        }
    }

    return returnValue;
}
/**
 *在以root为根节点中找出节点值为value的后继节点方法
 */
TNode<T>* TreeSuccessor(const T &value,TNode<T> *returnValue){
    return TreeSuccessor(root,value,returnValue);
}

 如下图：

  

10、先序、中序、后序递归和非的递归遍历，更详细的请参考上一篇文章，为什么在这里有展示一遍，我坚信在复杂的东西，多动手写几次都能很好的理解

/**
 *前序非递归(利用栈)遍历二叉树
 *前序遍历的规则：根左右
 *非递归遍历树会经常当做面试题，考察面试者的编程能力
 *防止下次被鄙视，应该深入理解并且动手在纸写出来
 */
void PreOrderTraverse() {
    //申明一个栈对象
    stack<TNode<T>*> s;
    //t首先指向根节点
    TNode<T> *t = root;
    //压入一个空指针，作为判断条件
    s.push(0);

    //如果t所值节点非空
    while (t != 0) {
        //直接访问根节点
        std::cout << (&t->data) << " ";

        //右孩子指针为非空
        if (t->rchild != 0) {
            //入栈右孩子指针
            s.push(t->rchild);
        }

        //左孩子指针为非空
        if (t->lchild != 0) {
            //直接指向其左孩子
            t = t->lchild;
        } else {//左孩子指针为空
            //获取栈顶元素(右孩子指针)
            t = s.top();
            //清楚栈顶元素
            s.pop();
        }

    }
}

/**
 *中序非递归(利用栈)遍历二叉树
 *前序遍历的规则：左根右
 */
void InOrderTraverse() {
    //申明一个栈对象
    stack<TNode<T>*> s;
    //t首先指向根节点
    TNode<T>* t = root;

    //节点不为空或者栈对象不为空，都进入循环
    while (t != 0 || !s.empty()) {
        //如果t节点非空
        if (t) {
            //入栈t节点
            s.push(t);
            //t节点指向其左孩子
            t = t->lchild;
        } else {
            //获取栈顶元素(左孩子指针)
            t = s.top();
            //清楚栈顶元素
            s.pop();
            //直接访问t节点
            std::cout << (&t->data) << " ";
            //t节点指向其右孩子
            t = t->rchild;
        }
    }
}
/**
 *后序非递归(利用栈)遍历二叉树
 *前序遍历的规则：左右根
 */
void PostOrderTraverse() {
    //申明一个栈对象
    stack<TNode<T>*> s;
    //t首先指向根节点
    TNode<T>* t = root;
    //申请中间变量，用做判断标识
    TNode<T>* r;
    //节点不为空或者栈对象不为空，都进入循环
    while (t != 0 || !s.empty()) {
        //如果t节点非空
        if (t) {
            //入栈t节点
            s.push(t);
            //t节点指向其左孩子
            t = t->lchild;
        } else {
            //获取栈顶元素(左孩子指针)
            t = s.top();
            //判断t的右子树是否存在并且没有访问过
            if (t->rchild && t->rchild != r) {
                //t节点指向其右孩子
                t = t->rchild;
                //入栈t节点
                s.push(t);
                //t节点指向其左孩子
                t = t->lchild;
            } else {
                //获取栈顶元素(左孩子指针)
                t = s.top();
                //清楚栈顶元素
                s.pop();
                //直接访问t节点
                std::cout << (&t->data) << " ";
                //设置已经访问过的节点，防止多次访问(右孩子指针)
                r = t;
                t = 0;
            }
        }
    }
}
/**
 * 根据模式递归遍历二叉树
 * 下面代码相对比较简单，只要记住遍历树的规则并且弄一点递归，都可以写出来
 * 如果在面试中实在写不出来非递归方式，可以写一个递归版本，也许可以争取一个好的工作
 */
void OrderTraverse(const TNode<T>* t, Style mode) {
    if (t) {
        //先序遍历二叉树:根左右
        if (mode == Pre) {
            //直接访问t节点
            std::cout << (&t->data) << " ";
            //递归遍历左子树
            this->OrderTraverse(t->lchild, mode);
            //递归遍历右子树
            this->OrderTraverse(t->rchild, mode);
        }
        //中序遍历二叉树:左根右
        if (mode == In) {
            //递归遍历左子树
            this->OrderTraverse(t->lchild, mode);
            //直接访问t节点
            std::cout << (&t->data) << " ";
            //递归遍历右子树
            this->OrderTraverse(t->rchild, mode);
        }
        //后序遍历二叉树:左右根
        if (mode == Post) {
            //递归遍历左子树
            this->OrderTraverse(t->lchild, mode);
            //递归遍历右子树
            this->OrderTraverse(t->rchild, mode);
            //直接访问t节点
            std::cout << (&t->data) << " ";
        }
    }
}

11、按层级遍历树

/**
 *按层级从左到右遍历树
 */
void LevelOrderTraverse(){
    //声明一个队列队形
    queue<TNode<T>* > q;
    //声明变量a,t;并把root赋值给t
    TNode<T> *a,*t = root;
    //若t节点非空
    if(t){
        //t节点入队列
        q.push(t);
        //如果队列不为空
        while(!q.empty()){
            //获取队列头结点
            a = q.front();
            //数据队形出队列
            q.pop();
            //直接访问队列头结点值
            std::cout<<a->data<<" ";
            //若a节点左子树不为空
            if(a->lchild){
                //左子树入队列q
                q.push(a->lchild);
            }
            //若a节点右子树不为空
            if(a->rchild){
                //右子树入队列q
                q.push(a->rchild);
            }
        }
    }
}

12、运行结果，由于在虚拟机中打中文，实在太痛苦，弄一点英文装下B 

测试代码如下：

void test() {
    Insert(5);
    Insert(3);
    Insert(4);
    Insert(6);
    Insert(2);
    Insert(1);
    Insert(10);
    Insert(9);
    Insert(8);
    Insert(11);
    Insert(12);
    std::cout << "create tree success" << std::endl;

    std::cout << "create tree after is null ? ";
    std::cout << boolalpha << this->IsEmpty();

    std::cout << std::endl;
    std::cout << "calculated depth of the tree begins" << std::endl;
    std::cout << "tree is dept = " << this->GetTreeDept(this->GetRoot());
    std::cout << std::endl;
    std::cout << "calculated depth of the tree end" << std::endl;

    std::cout << std::endl;
    std::cout << "recursion--------------------begin" << std::endl;
    std::cout << "pre order traverse:";
    OrderTraverse(GetRoot(), Pre);
    std::cout << endl;

    std::cout << "in order traverse:";
    OrderTraverse(GetRoot(), In);
    std::cout << endl;

    std::cout << "post order traverse:";
    OrderTraverse(GetRoot(), Post);
    std::cout << endl;
    std::cout << "recursion--------------------end" << std::endl;

    std::cout << "get parent node--------------begin" << std::endl;
    TNode<T> *returnValue;
    TNode<T> *node = GetParentNode(5,returnValue);
    if (node) {
        std::cout << "node=" << node->data;
    }
    std::cout << "get parent node--------------end" << std::endl;
    std::cout << "delete-----------------------begin" << std::endl;
    Delete(5);
    std::cout << "delete-----------------------end" << std::endl;

    std::cout << "recursion--------------------begin" << std::endl;
    std::cout << "in order traverse:";
    OrderTraverse(GetRoot(), In);
    std::cout << endl;
    std::cout << "recursion--------------------end" << std::endl;
    std::cout<<"tree max:"<<GetMax(GetRoot())->data<<std::endl;
    std::cout<<"tree min:"<<GetMin(GetRoot())->data<<std::endl;
}

结果如下图

11、完整代码

TNode.h

/*
 * TLNode.h
 *
 *  Created on: 2013-7-6
 *      Author: sunysen
 */

#ifndef TLNODE_H_
#define TLNODE_H_
template <class T>
class TNode{
public:
    T data;
    TNode *rchild,*lchild;
    TNode(T value):data(value),rchild(0),lchild(0){}
};

#endif /* TLNODE_H_ */

 BSTree.h

/*
 * LinkTree.h
 *  Created on: 2013-7-6
 *      Author: sunysen
 */

#ifndef BSTREE_H_
#define BSTREE_H_
#include "core/common/Common.h"
#include "core/node/TNode.h"
//获取树最大最小值模式
enum Mode {
    Max, Min
};
//树的三种遍历方式
enum ORDER_MODE {
    Pre, In, Post
};
template<class T>
class BSTree {
private:
    TNode<T> *root;//树的根节点
public:
    /**
     * 构造函数初始化树根节点
     */
    BSTree() :
            root(0) {
    }
    /**
     *析构行数释放所有构造的资源
     */
    ~BSTree(){
        Clear();
    }
    /**
     * 若树为空，则返回true;否则返回false
     */
    bool IsEmpty() {
        return root == 0;
    }

    /**
     * 以传入节点为基础计算树的深度
     */
    int GetTreeDept(const TNode<T> *t) {
        int i, j;
        if (t == 0) {
            return 0;
        } else {
            //递归计算左子树的深度
            i = this->GetTreeDept(t->lchild);
            //递归计算右子树的深度
            j = this->GetTreeDept(t->rchild);
        }

        //t的深度为其左右子树中深度中的大者加1
        return i > j ? i + 1 : j + 1;
    }
    /**
     *清空树的所有节点
     */
    void Clear() {
        Clear(root);
    }

    /**
     *根据节点递归清空树
     */
    void Clear(TNode<T>* t) {
        //判断指针是否为空
        if (t) {
            //获取资源立即放入管理对象(参考Effective C++里边条款13)
            //tr1::shared_ptr(引用计数智慧指针)管理对象比auto_ptr更强大
            std::auto_ptr<TNode<T> > new_ptr(t);

            //递归清空右子树
            Clear(new_ptr->rchild);

            //递归清空左子树
            Clear(new_ptr->lchild);
        }

        //清空树的根节点
        t = 0;
    }

    /**
     *获取树的最大节点
     */
    TNode<T>* GetMax(TNode<T>* t) const {
        //判断数节点是否为空
        if (t) {
            //根据二叉树特性，最大值一定在右子树；
            //循环右子树，直到叶子节点
            while (t->rchild) {
                //指向下一个节点
                t = t->rchild;
            }
        }
        //返回找到最大节点
        return t;
    }
    /**
     *获取树的最小节点
     */
    TNode<T>* GetMin(TNode<T>* t) const {
        //判断数节点是否为空
        if (t) {
            //根据二叉树特性，最大值一定在左子树；
            //循环左子树，直到叶子节点
            while (t->lchild) {
                //指向下一个节点
                t = t->lchild;
            }
        }
        //返回找到最小节点
        return t;
    }
    /**
     *根据模式类型查找树的最大值或者最小值
     */
    TNode<T>* GetNode(Mode mode) const {
        //t指向根节点
        TNode<T>* t = root;
        //判断数节点是否为空
        if (t) {
            if (mode == Min) {
                //根据二叉树特性，最大值一定在左子树；
                //循环左子树，直到叶子节点
                while (t->lchild) {
                    //指向左子树下一个节点
                    t = t->lchild;
                }
            } else if (mode == Max) {
                //根据二叉树特性，最大值一定在右子树；
                //循环右子树，直到叶子节点
                while (t->rchild) {
                    //指向右子树下一个节点
                    t = t->rchild;
                }
            }
        }
        //返回找到节点
        return t;
    }
    /**
     *获取传入的节点从传入树p中找到它的父节点
     */
    TNode<T>* GetParentNode(TNode<T> *p, const T &value,TNode<T> *returnValue) {
        //p节点存在并且传入的值不是根节点值
        if (p && p->data == value) {
            return 0;
        }

        //用二分查找定位值value所在节点
        TNode<T> *t = this->SearchTree(p, value);

        //判断t和p都不为空
        if (t && p) {
            //如果value的节点等于p节点左孩子或者右孩子，p就是value的节点父亲
            if (p->lchild == t || p->rchild == t) {
                //赋值p节点给返回值变量
                returnValue = p;
            } else if (value > p->data) {//如果value只大于p节点值，则递归右孩子
                //直到找到value的父节点复制给返回值变量
                returnValue = GetParentNode(p->rchild, value,returnValue);
            } else {////如果value只小于p节点值，则递归左孩子
                //直到找到value的父节点复制给返回值变量
                returnValue = GetParentNode(p->lchild, value,returnValue);
            }
        }

        return returnValue;

    }

    /**
     *获取传入的节点的父节点
     */
    TNode<T>* GetParentNode(const T &value,TNode<T> *returnValue) {
        return this->GetParentNode(root, value,returnValue);
    }

    /**
     * 在以T为根节点的树中搜索值为value的节点
     */
    TNode<T>* SearchTree(TNode<T>* &t, const T &value) {
        //判断t节点是否为空
        while (t) {
            //如果节点值等于value，则表明已经找到目标节点
            if (t->data == value) {
                return t;
            } else if (value > t->data) {//如果value大于t节点值，则递归查询右子树
                return SearchTree(t->rchild, value);
            } else {//如果value小于t节点值，则递归查询左子树
                return SearchTree(t->lchild, value);
            }
        }
        return t;
    }

    /**
     *插入一个节点到目标树中
     */
    void Insert(const T &value, TNode<T>* &t) {
        //如果目标树为空，则新new一个根节点
        if (t == 0) {
            //新创建一个节点，并把value设置为节点值
            t = new TNode<T>(value);
        } else if (value < t->data) {//如果value值小于t节点值
            //递归左子树插入函数，直到找到节点插入
            this->Insert(value, t->lchild);
        } else if (value > t->data) {//如果value值大于t节点值
            //递归右子树插入函数，直到找到节点插入
            this->Insert(value, t->rchild);
        }
    }
    /**
     *插入一个节点到根节点为root的树中
     */
    void Insert(const T &value) {
        this->Insert(value, root);
    }

    /**
     *根据节点值删除节点信息
     */
    void Delete(const T &value) {
        Delete(value, root);
    }
    /**
     *根据节点值删除以传入t为根节点树节点信息
     */
    void Delete(const T &value, TNode<T>* &t) {
        //判断是否t为空null
        if (t) {
            //通过二分查找定位value所在的节点
            TNode<T> *p = this->SearchTree(t, value);
            //中间变量，用于待删除节点左右子树都不为空的情况下
            TNode<T> *q = p;
            if (p) {
                //如果p节点的左右孩子都不为空，则根据二叉树定义
                //必须在子右子树中找到最新节点作为新节点
                if (p->lchild != 0 && p->rchild != 0) {
                    //获取右子树中最小的节点
                    q = this->GetMin(p->rchild);
                }
                //获取资源立即放入管理对象(参考Effective C++里边条款13)
                //tr1::shared_ptr(引用计数智慧指针)管理对象比auto_ptr更强大
                //如果p节点的左右子树都不为空，则释放p节点子右子树的最小节点
                //改变p节点的值，即可删除节点
                auto_ptr<TNode<T> > new_ptr(q);

                TNode<T> *parent = 0;
                TNode<T> *returnValue;
                //删除叶子节点(节点左右孩子都为空)
                if (p->lchild == 0 && p->rchild == 0) {
                    //如果p节点和传入的根节点相等
                    if (t == p) {
                        //直接设置t为空
                        t = 0;
                    } else {
                        //获取p节点的父节点
                        parent = this->GetParentNode(t, p->data,returnValue);

                        //如果父节点的左孩子等于p节点
                        if (parent->lchild == p) {
                            //设置父节点的左孩子等于空
                            parent->lchild = 0;
                        } else {//如果父节点的右孩子等于p节点
                            //设置父节点的右孩子等于空
                            parent->rchild = 0;
                        }
                    }

                } else if (p->rchild == 0) {//删除节点p右孩子为空，左孩子有节点
                    //如果p节点和传入的根节点相等
                    if (t == p) {
                        //直接设置t节点等于左孩子
                        t = t->lchild;
                    } else {
                        //获取p节点的父节点
                        parent = this->GetParentNode(t, p->data,returnValue);
                        //如果父节点的左孩子等于p节点
                        if (parent->lchild == p) {
                            //设置父节点左孩子等于p节点左孩子
                            parent->lchild = p->lchild;
                        } else {//如果父节点的右孩子等于p节点
                            //设置父节点右孩子等于p节点左孩子
                            parent->rchild = p->lchild;
                        }
                    }

                } else if (p->lchild == 0) {//删除节点p左孩子为空，右孩子有节点
                    //如果p节点和传入的根节点相等
                    if (t == p) {
                        //直接设置t节点等于右孩子
                        t = t->rchild;
                    } else {
                        //获取p节点的父节点
                        parent = this->GetParentNode(t, p->data,returnValue);
                        //如果父节点的右孩子等于p节点
                        if (parent->rchild == p) {
                            //设置父节点右孩子等于p节点右孩子
                            parent->rchild = p->rchild;
                        } else {//如果父节点的左孩子等于p节点
                            //设置父节点右孩子等于p节点右孩子
                            parent->lchild = p->rchild;
                        }
                    }
                } else {//删除节点p左右都有孩子
                    //获取q节点的父节点
                    parent = this->GetParentNode(t,q->data,returnValue);
                    //设置p节点值等于q节点值
                    p->data = q->data;
                    //如果q的父节点等于p
                    if (parent == p) {
                        //设置q节点的父节点右孩子为q节点右孩子
                        parent->rchild = q->rchild;
                    } else {//
                        //设置q节点的父节点左孩子为q节点右孩子
                        parent->lchild = q->rchild;
                    }

                }
            }
        }
    }

    /**
     *前序非递归(利用栈)遍历二叉树
     *前序遍历的规则：根左右
     *非递归遍历树会经常当做面试题，考察面试者的编程能力
     *防止下次被鄙视，应该深入理解并且动手在纸写出来
     */
    void PreOrderTraverse() {
        //申明一个栈对象
        stack<TNode<T>*> s;
        //t首先指向根节点
        TNode<T> *t = root;
        //压入一个空指针，作为判断条件
        s.push(0);

        //如果t所值节点非空
        while (t != 0) {
            //直接访问根节点
            std::cout << (&t->data) << " ";

            //右孩子指针为非空
            if (t->rchild != 0) {
                //入栈右孩子指针
                s.push(t->rchild);
            }

            //左孩子指针为非空
            if (t->lchild != 0) {
                //直接指向其左孩子
                t = t->lchild;
            } else {//左孩子指针为空
                //获取栈顶元素(右孩子指针)
                t = s.top();
                //清楚栈顶元素
                s.pop();
            }

        }
    }

    /**
     *中序非递归(利用栈)遍历二叉树
     *前序遍历的规则：左根右
     */
    void InOrderTraverse() {
        //申明一个栈对象
        stack<TNode<T>*> s;
        //t首先指向根节点
        TNode<T>* t = root;

        //节点不为空或者栈对象不为空，都进入循环
        while (t != 0 || !s.empty()) {
            //如果t节点非空
            if (t) {
                //入栈t节点
                s.push(t);
                //t节点指向其左孩子
                t = t->lchild;
            } else {
                //获取栈顶元素(左孩子指针)
                t = s.top();
                //清楚栈顶元素
                s.pop();
                //直接访问t节点
                std::cout << (&t->data) << " ";
                //t节点指向其右孩子
                t = t->rchild;
            }
        }
    }
    /**
     *后序非递归(利用栈)遍历二叉树
     *前序遍历的规则：左右根
     */
    void PostOrderTraverse() {
        //申明一个栈对象
        stack<TNode<T>*> s;
        //t首先指向根节点
        TNode<T>* t = root;
        //申请中间变量，用做判断标识
        TNode<T>* r;
        //节点不为空或者栈对象不为空，都进入循环
        while (t != 0 || !s.empty()) {
            //如果t节点非空
            if (t) {
                //入栈t节点
                s.push(t);
                //t节点指向其左孩子
                t = t->lchild;
            } else {
                //获取栈顶元素(左孩子指针)
                t = s.top();
                //判断t的右子树是否存在并且没有访问过
                if (t->rchild && t->rchild != r) {
                    //t节点指向其右孩子
                    t = t->rchild;
                    //入栈t节点
                    s.push(t);
                    //t节点指向其左孩子
                    t = t->lchild;
                } else {
                    //获取栈顶元素(左孩子指针)
                    t = s.top();
                    //清楚栈顶元素
                    s.pop();
                    //直接访问t节点
                    std::cout << (&t->data) << " ";
                    //设置已经访问过的节点，防止多次访问(右孩子指针)
                    r = t;
                    t = 0;
                }
            }
        }
    }
    /**
     * 根据模式递归遍历二叉树
     * 下面代码相对比较简单，只要记住遍历树的规则并且弄一点递归，都可以写出来
     * 如果在面试中实在写不出来非递归方式，可以写一个递归版本，也许可以争取一个好的工作
     */
    void OrderTraverse(const TNode<T>* t, Style mode) {
        if (t) {
            //先序遍历二叉树:根左右
            if (mode == Pre) {
                //直接访问t节点
                std::cout << (&t->data) << " ";
                //递归遍历左子树
                this->OrderTraverse(t->lchild, mode);
                //递归遍历右子树
                this->OrderTraverse(t->rchild, mode);
            }
            //中序遍历二叉树:左根右
            if (mode == In) {
                //递归遍历左子树
                this->OrderTraverse(t->lchild, mode);
                //直接访问t节点
                std::cout << (&t->data) << " ";
                //递归遍历右子树
                this->OrderTraverse(t->rchild, mode);
            }
            //后序遍历二叉树:左右根
            if (mode == Post) {
                //递归遍历左子树
                this->OrderTraverse(t->lchild, mode);
                //递归遍历右子树
                this->OrderTraverse(t->rchild, mode);
                //直接访问t节点
                std::cout << (&t->data) << " ";
            }
        }
    }


    TNode<T>* GetRoot() {
        return root;
    }

    void test() {
        Insert(5);
        Insert(3);
        Insert(4);
        Insert(6);
        Insert(2);
        Insert(1);
        Insert(10);
        Insert(9);
        Insert(8);
        Insert(11);
        Insert(12);
        std::cout << "create tree success" << std::endl;

        std::cout << "create tree after is null ? ";
        std::cout << boolalpha << this->IsEmpty();

        std::cout << std::endl;
        std::cout << "calculated depth of the tree begins" << std::endl;
        std::cout << "tree is dept = " << this->GetTreeDept(this->GetRoot());
        std::cout << std::endl;
        std::cout << "calculated depth of the tree end" << std::endl;

        std::cout << std::endl;
        std::cout << "recursion--------------------begin" << std::endl;
        std::cout << "pre order traverse:";
        OrderTraverse(GetRoot(), Pre);
        std::cout << endl;

        std::cout << "in order traverse:";
        OrderTraverse(GetRoot(), In);
        std::cout << endl;

        std::cout << "post order traverse:";
        OrderTraverse(GetRoot(), Post);
        std::cout << endl;
        std::cout << "recursion--------------------end" << std::endl;

        std::cout << "get parent node--------------begin" << std::endl;
        TNode<T> *returnValue;
        TNode<T> *node = GetParentNode(5,returnValue);
        if (node) {
            std::cout << "node=" << node->data;
        }
        std::cout << "get parent node--------------end" << std::endl;
        std::cout << "delete-----------------------begin" << std::endl;
        Delete(5);
        std::cout << "delete-----------------------end" << std::endl;

        std::cout << "recursion--------------------begin" << std::endl;
        std::cout << "in order traverse:";
        OrderTraverse(GetRoot(), In);
        std::cout << endl;
        std::cout << "recursion--------------------end" << std::endl;
        std::cout<<"tree max:"<<GetMax(GetRoot())->data<<std::endl;
        std::cout<<"tree min:"<<GetMin(GetRoot())->data<<std::endl;
    }

};

#endif /* BSTREE_H_ */

五：环境

1、运行环境：Ubuntu 10.04 LTS+VMware8.0.4+gcc4.4.3；

2、开发工具：Eclipse+make

六：题记

1、上面的代码难免有bug，如果你发现代码写的有问题，请你帮忙指出，让我们一起进步，让代码变的更漂亮和更健壮；

2、我自己能手动写上面代码，离不开郝斌、高一凡、侯捷、严蔚敏等老师的书籍和视频指导，在这里感谢他们；

3、鼓励自己能坚持把更多数据结构方面的知识写出来，让自己掌握更深刻，也顺便冒充下"小牛"；

 4、所有动画都在网上找的，感谢制作做动画的朋友，这样好的动画比图片更便于大家理解复杂的内容；

 

欢迎继续阅读“启迪思维：数据结构和算法”系列