二叉树的学习（四种遍历方法，搜索，插入，删除等）

对于任意一棵二叉树,如果其叶结点数为N0,而度数为2的结点总数为N2,则N0=N2+1;
证明过程如下：
假设二叉树的0度,1度,2度结点为n0,n1,n2,总节点数为T（显然，叶节点数就是n0）
则有按照结点求和的
T = n0 + n1 + n2 （1）
按照边求和得：
T = n1 + 2 * n2 + 1 （2）
所以 （2） - （1）可得
n2 + 1 - n0 = 0
所以n0 = n2 + 1。

环境：VS015

#include "stdafx.h"
#include <iostream>
#include <stack>
#include <queue>
using namespace std;

/***************************************
对于任意一棵二叉树,如果其叶结点数为N0,而度数为2的结点总数为N2,则N0=N2+1;
证明过程如下：
假设二叉树的0度,1度,2度结点为n0,n1,n2,总节点数为T（显然，叶节点数就是n0）
则有按照结点求和的
T = n0 + n1 + n2 （1）
按照边求和得：
T = n1 + 2 * n2 + 1 （2）
所以 （2） - （1）可得
n2 + 1 - n0 = 0
所以n0 = n2 + 1
***************************************/
//根每一棵子树是根的儿子（child），根叫做子树的父亲（parent），没有儿子的节点叫做树叶（leaf），
//具有相同的父亲的节点叫做兄弟（sibling）
/******************************
The defination of tree 树的定义
结构体
******************************/
typedef struct TreeNode BinTree;
struct TreeNode
{
    int ex;
    //the address of the first child.
    TreeNode *Left; 
    //the address of the next sibling
    TreeNode *Right;
};

/******************************
功能：（递归）前序遍历二叉树(先根，再右左边，再右边)
输入：二叉树根节点
输出：输出节点数据
******************************/
void preOrderTraversal(TreeNode *BootNode)
{
    if (BootNode)
    {
        cout << BootNode->ex;
        preOrderTraversal(BootNode->Left);
        preOrderTraversal(BootNode->Right);
    }
}
/******************************
功能：（递归）中序遍历二叉树(先左边，再根，再右边)
输入：二叉树根节点
输出：输出节点数据
******************************/
void inOrderTraversal(TreeNode *BootNode)
{
    if (BootNode)
    {
        inOrderTraversal(BootNode->Left);
        cout << BootNode->ex;
        inOrderTraversal(BootNode->Right);
    }
}
/******************************
功能：（递归）后序遍历二叉树(先左边，再右边，再根)
输入：二叉树根节点
输出：输出节点数据
******************************/
void  postOrderTraversal(TreeNode *BootNode)
{
    if (BootNode)
    {
        postOrderTraversal(BootNode->Left);
        cout << BootNode->ex;
        postOrderTraversal(BootNode->Right);
    }
}

/******************************
功能：堆栈实现中序遍历
输入：二叉树根节点
输出：输出节点数据
******************************/
void inOrderTraversal_stack(TreeNode *BootNode)
{
    TreeNode *Tree;//创建新根
    Tree = BootNode;
    Tree = new TreeNode;
    stack<TreeNode> S;//创建堆栈
    while (Tree || !S.empty())
    {
        while(Tree)
        {
            S.push(*Tree);//入栈
            inOrderTraversal_stack(Tree->Left);//左边走到尽头
        }
        if (!S.empty())
        {
            *Tree = S.top();//取栈顶元素
            S.pop();//出栈
            cout << Tree->ex;//输出
            Tree = Tree->Right;//找这个节点（左边节点已经找完了的）的右边节点的子节点
        }
    }
}

/******************************
功能：层序遍历（一层一层的输出）
输入：二叉树根节点
输出：输出节点数据
******************************/
void  levelOrderTraversal(TreeNode *BootNode)
{
    if (!BootNode) return;
    queue<TreeNode> Q;
    TreeNode* Tree = NULL;
    Q.push(*BootNode);
    while (!Q.empty())
    {
        *Tree = Q.front();
        cout << Tree->ex<<endl;
        Q.pop();
        if(Tree->Left) Q.push(*(Tree->Left));
        if (Tree->Right) Q.push(*(Tree->Right));
    }
}

/******************************
功能：二叉搜索树（尾递归）
输入：搜索值，二叉树根节点
输出：返回节点
******************************/
TreeNode*  findPosition1(int x,TreeNode *BootNode)
{
    if (!BootNode) return NULL;
    if (x > BootNode->ex) return findPosition1(x, BootNode->Right);
    else if (x < BootNode->ex) return findPosition1(x, BootNode->Left);
    else return BootNode;

}

/******************************
功能：二叉搜索树（迭代函数）
输入：搜索值，二叉树根节点
输出：返回节点
******************************/
TreeNode*  findPosition2(int x, TreeNode *BootNode)
{

    while (BootNode) {
        if (x > BootNode->ex)
            BootNode = BootNode->Right;
        else if (x < BootNode->ex)
            BootNode = BootNode->Left;
        else return BootNode;
    }
    return NULL;

}

/******************************
功能：查找二叉树最小元素（递归）
输入：搜索值，二叉树根节点
输出：返回节点
******************************/
TreeNode*  findMin(TreeNode *BootNode)
{
    if (!BootNode) return NULL;
    if (!BootNode->Left) return BootNode;
    else  return findMin(BootNode->Left);

}


/******************************
功能：查找二叉树最大元素（递归）
输入：搜索值，二叉树根节点
输出：返回节点
******************************/
TreeNode*  findMax(TreeNode *BootNode)
{
    if (!BootNode) 
        return NULL;
    if (!BootNode->Right) 
        return BootNode;
    else  
        return findMax(BootNode->Right);

}

/******************************
功能：二叉搜索树的插入（递归）
输入：搜索值，二叉树根节点
输出：返回节点
******************************/
TreeNode*  insert(int x,TreeNode *BootNode)
{
    if (!BootNode)
    {
        BootNode = new TreeNode;
        BootNode->ex = x;
        BootNode->Left = BootNode->Right = NULL;
    }
    else
    {
        if (BootNode->ex < x)
        {
            BootNode->Right=insert(x, BootNode->Right);
        }
        else
            BootNode->Left=insert(x, BootNode->Left);
    }
    return BootNode;
}

/******************************
功能：二叉搜索树的s删除（递归）
输入：要删除的值，二叉树根节点
输出：返回节点
******************************/
TreeNode*  deleteN(int x, TreeNode *BootNode)
{
    TreeNode *temp;
    temp = new TreeNode;
    if (!BootNode) cout << "NULL Value";
    else if (x < BootNode->ex)
        BootNode->Left = deleteN(x, BootNode->Left);
    else
    {
        if (BootNode->Left && BootNode->Right)
        {
            temp = findPosition1(x, BootNode->Right);
            BootNode->ex = temp->ex;
            BootNode->ex = temp->ex;
            BootNode->Right = deleteN(BootNode->ex, BootNode->Right);
        }
        else
        {
            temp = BootNode;
            if (!BootNode->Left)
                BootNode =  BootNode->Right;
            else if(BootNode->Right)
                BootNode = BootNode->Left;
            delete(temp);
        }
    }
    return BootNode;
}