数据结构树之二叉树

二叉树的定义：

　　是一颗空树或者具有以下性质

　　1.结点最多只有两个孩子，且有左右之分。不能交换左右孩子

　　2.结点点的左子树和右子树也是二叉树。

例图

　　　　　　　　

二叉树的基本形态：

二叉树中的术语：

　　1).结点度：节点所拥有的字数的个数成为该节点的度，在二叉树中度的取值只能是0,1,2.

　　2).叶节点：度为0的节点成为叶结点或终端结点。

　　3).左孩子、右孩子、双亲：树中一个结点的子树的根结点称为这个结点的孩子。这个结点称为它孩子结点的双亲。具有同一个双亲的孩子结点互称为兄弟。

　　4).路径、路径长度：如果一棵树的一串结点n1,n2,…,nk有如下关系：结点ni是ni+1的父结点（1≤i<k）,就把n1,n2,…,nk称为一条由n1至nk的路径。这条路径的长度是k-1。

　　5).结点的层数：规定树的根结点的层数为1，其余结点的层数等于它的双亲结点的层数加1。

　　6).树的深度：树中所有结点的最大层数称为树的深度。

　　7).满二叉树。 在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子结点都在同一层上，这样的一棵二叉树称作满二叉树。

　　8).完全二叉树。一棵深度为k的有n个结点的二叉树，对树中的结点按从上至下、从左到右的顺序进行编号，如果编号为i（1≤i≤n）的结点与满二叉树中编号为 i的结点在二叉树中的位置相同，则这棵二叉树称为完全二叉树。完全二叉树的特点是：叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左 部。

二叉树的性质：

　　1).非空二叉树叶子结点数等于度为2的结点数加1，即N0=N2+1.（其中N0和N2分别是叶结点和度为2结点的个数）。

　　2).非空二叉树第K层上最多有 2^(k - 1)个结点(K>= 1).

　　3).高度为H的节点，最多有2^H - 1个节点(H >= 1).

二叉树的基本操作：

　　/*以下为二叉树的常用操作(如有错误之处还望之处)

　　采用二叉链表的存储结构*/

typedef struct BiTNode    //二叉树的节点
{
    DataType m_Value;
    BiTNode *m_pLeft;
    BiTNode *m_pRight;
}BiTNode;

　　//创建二叉树（先序）

//创建二叉树（先序）
void createBiTree(BiTNode * &pCurrent)
{
    cout << "先序输入节点：";
    DataType value;
    cin >> value ;
    if(value == '#')
        pCurrent = NULL;
    else
    {
        pCurrent = (BiTNode *)malloc(sizeof(BiTNode));
        pCurrent->m_Value = value;
        createBiTree(pCurrent->m_pLeft);
        createBiTree(pCurrent->m_pRight);
    }
}

　　//递归实现前序遍历二叉树

void preOrderVisitUseRecur(const BiTNode * pCurrent)
{
    if(pCurrent)
    {
        cout << pCurrent->m_Value << " ";
        preOrderVisitUseRecur(pCurrent->m_pLeft);
        preOrderVisitUseRecur(pCurrent->m_pRight);
    }
}

　　//用栈，不用递归实现前序排列

void preOrderVisitUseStack(const BiTNode * pCurrent)
{
    stack<const BiTNode *> pNodeStack;
    const BiTNode *p = pCurrent;
    while(p||!pNodeStack.empty())
    {
        if(p)                                        //如果该节点不是NULL
        {
            cout << pCurrent->m_Value << " ";        //访问节点的值
            pNodeStack.push(p);                        //将节点压栈
            p = p->m_pLeft;
        }
        else
        {
            //如果该节点是NULL
            p = pNodeStack.top();    //获取栈顶元素
            pNodeStack.pop();        //删除栈顶元素
            p = p->m_pRight;        //访问右节点
        }

    }
}

　　//递归实现中序遍历

void inOrderVisitUseRecur(const BiTNode * pCurrent)
{
    if(pCurrent)
    {
        inOrderVisitUseRecur(pCurrent->m_pLeft);
        cout << pCurrent->m_Value << " ";
        inOrderVisitUseRecur(pCurrent->m_pRight);
    }
}

　　//用栈实现中序遍历

void inOrderVisitUseStack(const BiTNode * pCurrent)
{
    stack<const BiTNode *> pNodeStack;
    const BiTNode * p = pCurrent;
    while(p||!pNodeStack.empty())
    {
        if(p)                        //如果该节点不是NULL
        {
            pNodeStack.push(p);        //将节点压栈
            p = p->m_pLeft;
        }
        else
        {
            //如果该节点是NULL
            p = pNodeStack.top();                    //获取栈顶元素
            pNodeStack.pop();                        //删除栈顶元素
            cout << pCurrent->m_Value << " ";        //访问节点的值
            p = p->m_pRight;                        //访问右节点
        }
    }
}

　　//递归实现后序遍历

void afterOrderVisitUseRecur(const BiTNode * pCurrent)
{
    if(pCurrent)
    {
        afterOrderVisitUseRecur(pCurrent->m_pLeft);
        afterOrderVisitUseRecur(pCurrent->m_pRight);
        cout << pCurrent->m_Value << " ";
    }
}

　　//用栈实现后序遍历

void afterOrderVisitUseStack(const BiTNode * pCurrent)
{
    stack<const BiTNode *> pNodeStack1;
    stack<const BiTNode *> pNodeStack2;
    const BiTNode * p =pCurrent;
    while(p||!pNodeStack1.empty())
    {
        if(p)                        //如果该节点不是NULL
        {
            pNodeStack1.push(p);        //将节点压栈
            pNodeStack2.push(p);        //将节点压栈
            p = p->m_pRight;
        }
        else
        {
            //如果该节点是NULL
            p = pNodeStack1.top();    //获取栈顶元素
            pNodeStack1.pop();        //删除栈顶元素
            p = p->m_pLeft;            //访问左节点
        }
    }
    p = NULL;
    while(!pNodeStack2.empty())
    {
        p = pNodeStack2.top();    //获取栈顶元素
        pNodeStack2.pop();        //删除栈顶元素
        cout << pCurrent->m_Value << " ";
    }
}

　　//按层次进行遍历（有点小问题）

/*
void levelOrderVisit(const BiTNode *pCurrent)
{
    deque<const BiTNode *> pNodedeue;
    const BiTNode * p = NULL;
    if(pCurrent)
    {
        pNodedeue.push_back(pCurrent);    //第一次将节点放到队列
    }
    while(!pNodedeue.empty()||p)
    {
        p = *pNodedeue.begin();        //返回队列首元素，但不删除
        pNodedeue.pop_front();        //删除队首元素
        if(p)
        {
            cout << p->m_Value;
            if(p->m_pLeft)
                pNodedeue.push_back(p);        //左孩子不空则进入队列
            if(p->m_pRight)
                pNodedeue.push_back(p);        //右孩子不空则进入队列
        }
    }
}
*/

　　//计算树的深度

int getTreeDepth(const BiTNode * pCurrent)
{
    int leftDepth = 0,rightDepth = 0;
    if(!pCurrent)
    {
        //空的话返回0
        return 0;
    }
    else
    {
        leftDepth =  getTreeDepth(pCurrent->m_pLeft);    //获得左子树的高度
        rightDepth =  getTreeDepth(pCurrent->m_pRight);    //获得右子树的高度
        return (leftDepth>rightDepth?leftDepth:rightDepth) + 1;
    }
}

　　//计算树节点的个数

int coutTreeNodeNums(const BiTNode *pCurrent)
{
    int leftNums,rightNums;
    if(!pCurrent)
    {
        return 0;
    }
    else
    {
        leftNums  =  coutTreeNodeNums(pCurrent->m_pLeft);
        rightNums =  coutTreeNodeNums(pCurrent->m_pRight);
    }
    return leftNums + rightNums + 1;
}

　　//以下是各操作的实例

int main()
 {
     BiTNode * root = NULL;
     cout << "start to create a tree:" << endl;
     createBiTree(root);
     cout << "visit a tree use 递归先序:" << endl;
     preOrderVisitUseRecur(root);
     cout << endl;
     cout << "visit a tree use 栈先序:" << endl;
     preOrderVisitUseStack(root);
     cout << endl;
     cout << "visit a tree use 递归中序:" << endl;
     inOrderVisitUseRecur(root);
     cout << endl;
     cout << "visit a tree use 栈中序:" << endl;
     inOrderVisitUseStack(root);
     cout << endl;
     cout << "visit a tree use 递归后序:" << endl;
     afterOrderVisitUseRecur(root);
     cout << endl;
     cout << "visit a tree use 栈后序:" << endl;
     afterOrderVisitUseStack(root);
     cout << endl;
     //cout << "层次遍历：" << endl;
     //levelOrderVisit(root);
     cout << "树中节点的个数：" << coutTreeNodeNums(root)  << endl;
     cout << "树的深度为：" 　　<< getTreeDepth(root) << endl;
     return 0;
}