第6章 树和二叉树 要点提炼

6.2 二叉树

6.2.1 二叉树的定义

二叉树是一种特殊的树型结构，它的特点是每个结点至多只有两棵子树，并且二叉树的子树有左右之分，其次序不能任意颠倒

6.2.2 二叉树的性质

性质1——在二叉树的第i层上至多有$2^{i-1}$个结点
性质2——深度为k的二叉树至多有$2^{k}-1$个结点，（k $\geq$ 1）
性质3——对任何一棵二叉树T，如果其终端结点数为$n_{0}$，度为2的结点数为$n_{2}$，则$n_{0}$ = $n_{2}$ +１

1. 分支数Ｂ与总结点数ｎ之间的关系：n = B + 1
2. 分支数都是有度为1和度为2的结点发射出来的，因此：B = $n_{1}$ + $n_{2}$

性质4——具有n个节点的完全二叉树的深度为$\lfloor log_{2}n\rfloor$+1
补充说明：一棵深度为k且有$2^{k}-1$个结点的二叉称为满二叉树。对满二叉树的结点进行连续编号，约定编号从根结点起，自上而下，自左至右。由此引出完全二叉树的定义：深度为k的，有n个结点的二叉树，当且仅当其每一个结点都与深度为k的满二叉树中编号从1至n的结点一一对应。
性质5——如果对一棵有n个结点的完全二叉树的结点按层序编号，则对任意一结点i有：

1. 若i = 1，则结点为根结点，无双亲。如果i > 1，则其双亲PARENT(i)是结点$\lfloor i/2\rfloor$
2. 若2i > n，则结点无左孩子，否则其左孩子是结点2i
3. 若2i + 1 > n，则结点无右孩子，否则其又孩子为结点2i+1

6.2.3二叉树的顺序存储表示

1. 顺序存储结构：用数组来存储所有的结点。缺点：只使用与完全二叉树，否则中间会有很多空余的区域
2. 链式存储结构：一个结点包含3个域，数据域和左右指针域。在包含n个结点的二叉链表中有n+1个空指针域，可以用来构成线索链表

6.3 遍历二叉树和线索二叉树

6.3.1 遍历二叉树

以下3中遍历有包含递归和非递归
1. 先序遍历
2. 中序遍历
3. 后序遍历
网上已经很多版本了，为了让自己记住，我还是手打一遍代码。以下代码都来自一位大神，原文链接在这里，戳我或者http://blog.csdn.net/hackbuteer1/article/details/6583988

//c++内置数据结构stack,queue，方便后面的代码使用
#include <stack>
#include <queue>
#include <iostream>
using namespace std;

//二叉树数据结构定义
typedef struct BiTree{
    int data;
    struct BiTree* lchild;
    struct BiTree* rchild;
}BiTree, *pBiTree;

//层序遍历中要用到的表示访问结点的函数
int visit(pBiTree node)
{
    if(node)
    {
        cout << node->data << " ";
        return 1;
    }
    else
    {
        return 0;
    }
}

/*二叉树前序遍历非递归
**思路：先访问当前结点，然后将右孩子压栈，再将左孩子压栈，进入下一次循环。
**      这样下一次弹栈就会得到上次的左孩子，实现了“中左右”的顺序
*/
void PreOrderTraverse(pBiTree root)
{
    if(!root)
        return;

    stack<pBiTree> s;
    s.push(root);

    while(!s.empty())
    {
        pBiTree cur = s.top();
        visit(cur);
        s.pop();
        if(cur->rchild)
            s.push(cur->rchild);
        if(cur->lchild)
            s.push(cur->lchild);
    }
}

/*二叉树中序遍历非递归
**思路：由于每次都要从左孩子开始访问，因此对每个结点都要向其左子树的方向
**      压栈到底，然后在一层层地自下而上弹栈回来，这个过程也遵循“左中右”
**      的顺序
*/
void InOrderTraverse(pBiTree root)
{
    if(!root)
        return;

    stack<pBiTree> s;
    pBiTree cur = root;

    while(cur != NULL || !s.empty())
    {
        while(cur != NULL)
        {
            s.push(cur);
            cur = cur->lchild;
        }
        if(!s.empty())
        {
            cur = s.top();
            s.pop();
            visit(cur);
            cur = cur->rchild
        }
    }
}

/*二叉树后序遍历非递归
**思路：后序遍历相对复杂，这里写出的方法比前面两种多出一个临时结点，用来
**      记录上次访问过的右子树。它也需要从根结点开始一路向左走到底，然后
**      是该层的右子树，然后一层层向上弹栈，只不过顺序是“左右中”。
*/
void PostOrderTraverse(pBiTree root)
{
    if(!root)
        return;

    stack<pBiTree> s;
    pBiTree cur = root;
    pBiTree last = NULL;

    while(cur != NULL || !s.empty())
    {
        while(cur != NULL)
        {
            s.push(cur);
            cur = cur->lchild;
        }
        cur = s.top()//检查当前结点
        //如果该结点的右子树为空或上次已经访问过，则访问其本身，否则访问其右结点
        if(cur->rchild == NULL || cur->rchild == last)
        {
            visit(cur);
            s.pop();
            last = cur;
            cur = NULL;
        }
        else
        {
            cur = cur->rchild;
        }
    }
}

/*二叉树层序遍历非递归
**思路：利用队列的功能，将队首的结点的左右孩子结点放到先后队尾，同时访问队首结点。
*/
void LevelOrderTraverse(pBiTree root)
{
    queue<pBiTree> Q;
    pBiTree cur = root;

    if(visit(cur) == 1)
        Q.push(cur);
    while(!Q.empty())
    {
        cur = Q.front();
        Q.pop();
        if(visit(cur->lchild) == 1)
            Q.push(cur->lchild);
        if(visit(cur->rchild) == 1)
            Q.push(cur->rchild);
    }
}