树（二）——二叉树

目录

本章主要讲解内容为：

1. 树的非递归遍历算法，两种版本
2. 树的扩展前缀以及前缀中缀构建方法

源码

btree.cpp btree.h

基础知识

一、定义

二叉树的递归定义：二叉树是每个结点最多含有两棵子树的树结构。

二、性质

二叉树的递归定义标识着它具有很多递归性质。

二叉树的遍历、查找、构建、删除、复制和计数等全部可以用递归来实现，详见代码。

三、构建

二叉树的构建方法有：硬编码生成、扩展前缀、前缀结合中缀等。我实现了后两种方法。

四、遍历

二叉树的递归遍历非常简单，参见代码。

主要分析二叉树的非递归遍历，除了书上的版本外，我自己另写了一个版本，称为通用方法，参照了指令及状态机所设计。不同之处：书上的代码仅用一个栈，而通用方法使用两个栈——指令栈和数据栈。

非递归遍历

一、普通方法

（I）前序遍历

递归遍历方法如下（伪代码）：

1. pre_visit(node)
2. {
3. if(!node) return
4. print node.data
5. if(node.left) visit(node.left)
6. if(node.right) visit(node.right)
7. }

结合（根-左-右）遍历方式，思考递归方法下前序遍历的调用栈情况（步骤）：

1. 从根结点root开始，访问根结点root并打印，接着访问左孩子lchild1，调用栈层数+1，父调用暂停在第5行
2. 访问lchild1，接着访问lchild1的左孩子lchild2并打印，调用栈层数+1，父调用暂停在第5行
3. …
4. 访问到最左结点lchildn，调用栈层数=n，父调用暂停在第5行始，此时调用栈已经相对较深了
   此时的调用栈：
   n:   visit(lchildn)，运行
   n-1:visit(lchildn-1)，暂停在第5行
   …
   0:   visit(root)，暂停在第5行
5. 访问完lchildn，没有左孩子了，返回，调用栈出栈
   此时的调用栈：
   n-1:visit(lchildn-1)，运行至第6行，访问右孩子rchild1
   …
   0:   visit(root)，暂停在第5行
6. 继续（从lchildn到rchild1的访问变化是以lchildn-1为中间媒介的）
   此时的调用栈：
   n:   visit(rchild1)，运行
   n-1:visit(lchildn-1)，运行至第6行，访问右孩子rchild1
   …
   0:   visit(root)，暂停在第5行
7. 把rchild1看作root，类比步骤1~4
8. 运行，直到访问完rchild1
9. 继续，出栈
   此时的调用栈：
   n-2:visit(lchildn-2)，运行至第6行，访问右孩子rchild2
   …
   0:   visit(root)，暂停在第5行
10. 把rchild2看作root，类比步骤1~4
11. 运行，直到访问完rchild2
12. 继续，出栈
13. …
14. 直到调用栈为空

由此可以看出调用规律：

1. 对给定结点node，visit(node)即是先运行步骤1~4，依最左路径找到node的最左结点left0，并打印路径（因为路径上的结点依次已被访问过，故先打印根结点）
2. 访问完最左结点left0，找到其父结点，即是栈顶left1，left1已访问过，故访问left1的右孩子right1
3. 访问right1的方法参照调用规律1，是递归的

综上可以写出算法：

template <class T, class N>
void BiTree<T, N>::PreOrderNoRecursion2()
{
    stack<N*> s;
    N *p = root;
    while (p != NULL || !s.empty())
    {
        while (p != NULL)//遍历到最左结点，同时记录路径，输出路径（根-左=(根->最左)路径）
        {
            cout << p->data;
            s.push(p);
            p = p->lchild;
        }
        if (!s.empty())
        {
            p = s.top();
            s.pop();//访问后弹出最左结点，当前为最左父结点
            p = p->rchild;//访问最左父结点的右孩子
        }
    }
}

（II）中序遍历

递归遍历方法如下（伪代码）：

1. in_visit(node)

2. {
3. if(!node) return   
4. if(node.left) visit(node.left)

5. print node.data
6. if(node.right) visit(node.right)
7. }

结合（左-根-右）遍历方式，思考递归方法下中序遍历的调用栈情况（步骤）：

1. 从根结点root开始，访问左孩子lchild1（不打印），调用栈层数+1，父调用暂停在第4行

2. 访问lchild1，接着访问lchild1的左孩子lchild2（不打印），调用栈层数+1，父调用暂停在第4行
3. …
4. 访问到最左结点lchildn并打印，调用栈层数=n，父调用暂停在第4行始，此时调用栈已经相对较深了
   此时的调用栈：
   n:   visit(lchildn)，运行
   n-1:visit(lchildn-1)，暂停在第4行
   …
   0:   visit(root)，暂停在第4行
5. 访问完lchildn，没有左孩子了，返回，调用栈出栈
   此时的调用栈：
   n-1:visit(lchildn-1)，运行至第6行，访问右孩子rchild1
   …
   0:   visit(root)，暂停在第4行
6. 访问lchildn-1（不打印），继续（从lchildn到rchild1的访问变化是以lchildn-1为中间媒介的，即访问lchildn-1的右子树）
   此时的调用栈：
   n:   visit(rchild1)，运行
   n-1:visit(lchildn-1)，运行至第6行，访问右孩子rchild1
   …
   0:   visit(root)，暂停在第4行
7. 把rchild1看作root，类比步骤1~4
8. 运行，直到访问完rchild1
9. 继续，出栈
   此时的调用栈：
   n-2:visit(lchildn-2)，运行至第6行，访问右孩子rchild2
   …
   0:   visit(root)，暂停在第4行
10. 把rchild2看作root，类比步骤1~4
11. 运行，直到访问完rchild2
12. 继续，出栈
13. …
14. 直到调用栈为空

由此可以看出调用规律：（其实与前序遍历有相似之处）

1. 对给定结点node，visit(node)即是先运行步骤1~4，依最左路径找到node的最左结点left0

2. 访问完最左结点left0并打印，找到其父结点，即是栈顶left1，访问left1的右孩子right1（不打印）
3. 访问right1的方法参照调用规律1，是递归的
4. 结合规律2和3，可知：遍历完当前结点node后，应该遍历node的父结点（即栈顶）的右子树的最左结点，同样，这也是线索树的遍历顺序

综上可以写出算法：（就输出结果的那一行换了位置，总体逻辑是一样的，说明调用栈的变化规律也是一样的）

template <class T, class N>
void BiTree<T, N>::InOrderNoRecursion2()
{
    stack<N*> s;
    N *p = root;
    while (p != NULL || !s.empty())
    {
        while (p != NULL)//定位到最左结点
        {
            s.push(p);
            p = p->lchild;
        }
        if (!s.empty())
        {
            p = s.top();
            cout << p->data;//从最左结点开始访问
            s.pop();
            p = p->rchild;//访问最左结点（依次）的父结点的右孩子
        }
    }
}

（III）后序遍历

后序遍历较前序、中序复杂，调用栈的变化规律不同于前序、中序。究其原因，是在输出之前有两次递归调用，因此，无法通过取栈顶知晓遍历的上一个结点（遍历的直接前驱），故必须以一变量来记录上一次访问的结点。

递归遍历方法如下（伪代码）：

1. post_visit(node)

2. {
3. if(!node) return   
4. if(node.left) visit(node.left)

5. if(node.right) visit(node.right)
6. print node.data
7. }

结合（左-根-右）遍历方式，思考递归方法下后序遍历的调用栈情况（步骤）：

1. 从根结点root开始，访问左孩子lchild1（不打印），调用栈层数+1，父调用暂停在第4行

2. 访问lchild1，接着访问lchild1的左孩子lchild2（不打印），调用栈层数+1，父调用暂停在第4行
3. …
4. 访问到最左结点lchildn并打印，调用栈层数=n，父调用暂停在第4行始，此时调用栈已经相对较深了
   此时的调用栈：
   n:   visit(lchildn)，运行
   n-1:visit(lchildn-1)，暂停在第4行
   …
   0:   visit(root)，暂停在第4行
5. 访问完lchildn，访问lchildn-1的右孩子lchildn-1_rchild（假设有右孩子），lchildn-1_rchild为root最左父结点的右孩子，假如lchildn-1没有右孩子（右子树），那么lchildn-1的子树已访问完，应该打印lchildn-1
   此时的调用栈：
   n:   visit(lchildn-1_rchild)，运行
   n-1:visit(lchildn-1)，暂停在第5行，访问右孩子
   …
   0:   visit(root)，暂停在第4行
6. 把lchildn-1_rchild看作root，类比步骤1~4
7. 运行，直到访问完lchildn-1_rchild
8. 打印lchildn-1_rchild（仅在lchildn-1有右孩子lchildn-1_rchild的情况下）此时的调用栈：
   n:   visit(lchildn-1_rchild)，运行至第6行，打印lchildn-1_rchild
   n-1:visit(lchildn-1)，暂停在第5行，访问右孩子
   …
   0:   visit(root)，暂停在第4行
9. 继续，出栈
   此时的调用栈：
   n-1:visit(lchildn-1)，暂停在第6行，访问并打印最左父结点（在打印lchildn-1_rchild及其子结点之后才打印该结点lchildn-1）
   …
   0:   visit(root)，暂停在第4行
10. 继续，出栈，访问lchildn-2的右结点lchildn-2_rchild此时的调用栈：
    n-1:visit(lchildn-2_rchild)，运行
    n-2:visit(lchildn-2)，暂停在第5行
    …
    0:   visit(root)，暂停在第4行
11. 将lchildn-2_rchild看作root，运行步骤1~4（看步骤6，会发现很相似，都是遍历左结点的右子树）
12. …
13. 直到调用栈为空

设遍历过程中的前驱（上次遍历结点）为pre，由此可以看出调用规律：

1. 对给定结点node，visit(node)即是先运行步骤1~4，依最左路径找到node的最左结点left0

2. 访问完最左结点left0并打印，找到其右兄弟，访问右兄弟right0，访问完right0就打印right0。
3. 访问完right0后，找到并访问right0的父结点left1，访问完后，打印left1，left1访问完后，访问left2。
4. 上述访问右兄弟right0的方法参照调用规律1，是递归的

算法的实现需要解决几个问题：

1. 访问完当前结点后，如何找到其右兄弟

2. 访问完子树后，如何找到父结点

以后序遍历为基础，结合pre这个前驱变量的特征，可以罗列出pre的指向：

1. 有从子结点向父结点的过渡（父子过渡），此时pre=child，解决问题2

2. 有从左结点向右结点的过渡（兄弟过渡），此时pre=left，无法解决问题1

要解决问题1，只能通过栈来解决。将要访问的孩子结点索性一次性保存到栈中，由于兄弟结点的遍历顺序是先左再右，故而进栈顺序为先右再左。

那么按照这个方法，处理当前结点时，将其孩子压栈，这是父结点向孩子结点的过渡，是通过栈的，没有借助pre。

因此可以写出基本步骤：

1. 处理当前结点时，若孩子未访问过（pre<>孩子，兄弟过渡），就将孩子压栈（先右再左），自身不出栈（出栈后就没办法打印了），不使用pre

2. 处理当前结点时，若孩子已访问过（pre=孩子），则打印自身，然后自身出栈，父子过渡，使用pre

现在，问题简化成：

1. 什么情况下，将孩子压栈

2. 什么情况下，访问本结点

以上两种情况之间互斥。

因而有：

1. 压栈情况：孩子未访问过（pre<>lchild && pre<>rchild），且当前有孩子（lchild<>null || rchild<>null）

2. 访问情况：除压栈情况以外的情况

综上可以写出算法：

template <class T, class N>
void BiTree<T, N>::PostOrderNoRecursion2()
{
    stack<N*> s;
    N *cur = root;               //当前结点
    N *pre = NULL;               //前一次访问的结点
    s.push(root);
    while (!s.empty() && cur)
    {
        cur = s.top();
        if ((cur->lchild == NULL&&cur->rchild == NULL) ||
            ((pre == cur->lchild || pre == cur->rchild)))
        {
            //当前为叶子结点或上一次访问为孩子结点，即按左-右-根（孩子-根）顺序，孩子全部访问过，接着访问父结点
            cout << cur->data;
            s.pop();
            pre = cur;
        }
        else
        {
            //当前为从上到下访问，孩子没访问过，则孩子入栈
            if (cur->rchild != NULL) s.push(cur->rchild);
            if (cur->lchild != NULL) s.push(cur->lchild);//左-右-根，入栈顺序为(根)-右-左
        }
    }
}

二、通用方法

按指令拆解visit方法：

假设数据栈为s，指令栈为sip

1. visit(bt)

2. {
3. //---- ins #0
4. if(!bt)return                               //###return=>s.pop+sip.pop
5. //---- ins #1 pre
6. if(!bt.left)visit(bt.left)                  //###call visit(bt.left)=>s.push(bt.left)+sip.push(0)
7. //---- ins #2 in
8. if(!bt.right)visit(bt.right)             //###call visit(bt.right)=>s.push(bt.right)+sip.push(0)
9. //---- ins #3 post
10. }

设一变量为ins，代表指令所在行，按正常的运行顺序，应是0->1->2->3->end。

如果在某处需要返回，则只需将指令出栈即可。

接下来，我们就可以在ins#0 #1 #2 #3这四处地方写上相应的处理程序。若无返回或者调用，则当前ins自增。

1. ins#0，处理空值返回操作，判断数据栈顶是否为空，若为空则数据栈和指令栈都出栈一次。

2. ins#1，处理前序遍历操作，打印结点数据，递归访问左结点。
3. ins#2，处理中序遍历操作，打印结点数据，递归访问右结点。
4. ins#3，处理后序遍历操作，打印结点数据，处理返回操作，数据栈和指令栈都出栈一次。

故算法如下：

template <class T, class N>
void BiTree<T, N>::MainOrderNoRecursion(typename BiTree<T, N>::NoRecursionType type)
{
    if (root == NULL) return;

    //非递归树遍历通用版本，结合状态机指令

    stack<N*> s;//结点栈
    stack<int> sip;//状态机

    s.push(root);
    sip.push(0);

    while (!s.empty() || !sip.empty())
    {
        N* bt = s.top();//取结点栈顶

        switch (sip.top())//取指令栈顶
        {
        case 0: sip.top()++;
            if (bt == NULL)//遍历到NULL，出栈
            {
                s.pop();
                sip.pop();
                continue;
            }

        case 1: sip.top()++;
            if (type == PREORDER) cout << bt->data;
            if (bt->lchild != NULL)
            {
                s.push(bt->lchild);
                sip.push(0);
                continue;
            }

        case 2: sip.top()++;
            if (type == INORDER) cout << bt->data;
            if (bt->rchild != NULL)
            {
                s.push(bt->rchild);
                sip.push(0);
                continue;
            }

        case 3:
            if (type == POSTORDER) cout << bt->data;
            s.pop();
            sip.pop();
            continue;
        }

        throw "非法IP！";
    }
}

树的构建

一、扩展前缀

所谓扩展前缀，顾名思义，必须是前缀编码，扩展就是以“#”代替空结点。

如常见的算术表达式：3+4*5，扩展前缀就是+3##*4##5##。其中？##代表叶子结点。

扩展前缀构建也采用递归调用方式。

将前缀看作[Head] [Left] [Right]三个部分，返回一棵树。[Head]只有一个元素，直接取出来，作为父结点。那两个子结点就从[Left] [Right]这两个前缀中生成，这即是递归调用。

template <class T, class N>
N *BiTree<T, N>::CreateByPre(int& ipre)
{
    if (ipre >= (int)pre.size())
        throw "输入串错误";
    T e = pre[ipre++];
    if (e == '\0') return NULL;
    if (e == '#') return NULL;
    N *bt = New();
    bt->data = e;
    bt->lchild = CreateByPre(ipre);  // 建左子树
    bt->rchild = CreateByPre(ipre);  // 建右子树
    return bt;
}

二、前缀与中缀

把扩展前缀的“#”规则拿掉，那普通的前缀字串就无法生成一棵唯一的树了，究其原因，是无法知晓递归调用的出口，而“#”恰恰是递归的出口。

知道一棵树的前缀和中缀，就能够还原这棵树，条件是树的结点值不能有重复，也就是说，前缀和中缀能够完全确定一棵树，如何证明？

假设前缀为pre，中缀为in，pre和in的长度是n。将其作划分：

• pre=[Head] [Head-Left] [Head-Right]

• in=[Head-Left] [Head] [Head-Right]

现在，假设in中Head的下标为k，则Head-Left中缀的范围就是[0,k-1]，Head-Right中缀的范围就是[k+1,n-1]。

这样，经过一轮划分，生成一棵不完全中缀树——父结点为Head，孩子为Head-Left和Head-Right，且此树是唯一的。

接下来，按照同样方法，只不过这次划分的对象是Head-Left和Head-Right，重复直到Head-Left或Head-Right长度为1（即叶子结点）。

现在思想为什么树的结点值不能重复，关键在于在in中寻找Head——如果Head有多个，就不能保证找到了正确的Head。

举例：

• pre = *+xyz

• in   = x+y*z

第一次划分后：

• pre = * [+xy] [z]

• in   = [x+y] * [z]

第二次划分后：

• pre = * [+ [x] [y]] [z]

• in   = [[x] + [y]] * [z]

有优先级（括号）的中缀可以确定一棵二叉树，因此，该方法有效，一般的前缀和中缀可以还原二叉树。

template <class T, class N>
N* BiTree<T, N>::CreateByPreMid(int ipre, int imid, int n)
{
    if (n == 0) return NULL;
    N *p = New();
    p->data = pre[ipre];// 前缀为根-左-右
    int i;
    for (i = 0; i < n; i++)    // 在中序序列中定位根结点
    {
        if (pre[ipre] == mid[imid + i]) break;
    }
    if (i == n) throw "前缀和中缀字符不匹配！";
    p->lchild = CreateByPreMid(ipre + 1, imid, i);// 建左子树
    p->rchild = CreateByPreMid(ipre + i + 1, imid + i + 1, n - i - 1);// 建右子树
    return p;
}

总结

二叉树是计算机数据结构当中的核心内容，它本身有着优美的递归性质。

树结构在查找方面有平衡二叉树AVL、红黑树RBT等，在数据压缩方面有哈夫曼树等，在图形学领域有四叉树、八叉树等等，因而，掌握好树结构对于学习计算机算法而言是不可或缺的。