二叉树

二叉树是一种树型结构，二叉树的特点是每个节点最多可以有两棵子树。并且，二叉树的两棵子树有左右之分，其次序不能颠倒。二叉树有下面三条性质：

性质1：在二叉树的第i层上最多可以有2^(i-1)个节点。

性质2：深度为k的二叉树最多可以有2^k-1个节点。

性质3：对于一棵二叉树，如果叶子节点数为m，度为2的节点数为n，那么m = n + 1。

下面这个图描述了一棵简单的二叉树。

由于二叉树中每个节点可以有两个子节点，因此二叉树不是一种线性结构。为了方便起见，通常用链式结构表示二叉树中的节点。二叉树中的节点可以用下面的数据结构定义：

typedef struct bitnode {
        int data;
        struct bitnode *lchild; 
        struct bitnode *rchild;
}bitnode, *bitree;

二叉树遍历是二叉树中的基本操作，按照节点访问顺序不同，可以分为四种方式：

先序遍历：  （1）访问根节点；（2）先序遍历左子树；（3）先序遍历又子树。

中序遍历：  （1）中序遍历左子树；（2）访问根节点；（3）中序遍历又子树。

后续遍历：  （1）后续遍历左子树；（2）后续遍历又子树；（3）访问根节点。

层次遍历：  按照节点在二叉树中的层次从上到下从左到右访问各个节点。

上面这个例子中，各种遍历方式的结果如下：

先序遍历：  5, 8, 12, 1, 6, 9, 20, 11, 17

中序遍历：  12, 8, 6, 1, 9, 5, 11, 17, 20

后续遍历：  12, 6, 9, 1, 8, 17, 11, 20, 5

层次遍历：  5, 8, 20, 12, 1, 11, 6, 9, 17

在对二叉树进行遍历前，我们首先需要先构造一棵二叉树，二叉树可以采用递归方法进行构造，方法如下：

void createbitree(bitnode **t)
{
        int ch;
        scanf("%d", &ch);
        if (ch == 0)
                *t = NULL;
        else {
                *t = (bitree)malloc(sizeof(bitnode));
                if (*t == NULL)
                        return;
                (*t)->data = ch;
                createbitree(&((*t)->lchild));
                createbitree(&((*t)->rchild));
        }
        return;
}

按照程序设计方法不同，二叉树遍历又可以分为递归算法和非递归算法两种。递归算法比较简单，逻辑非常清晰，代码如下：

// 先序遍历递归算法
void preorder(bitree t, void (*visit)(bitree node))
{
        if (t) {
                visit(t);
                preorder(t->lchild, visit);
                preorder(t->rchild, visit);
        }
}

// 中序遍历递归算法
void inorder(bitree t, void (*visit)(bitree node))
{
        if (t) {
                inorder(t->lchild, visit);
                visit(t);
                inorder(t->rchild, visit);
        }
}

// 后续遍历递归算法
void postorder(bitree t, void (*visit)(bitree node))
{
        if (t) {
                postorder(t->lchild, visit);
                postorder(t->rchild, visit);
                visit(t);
        }
}

与递归算法 相比，非递归算法的逻辑有些复杂，非递归算法借助堆栈实现了二叉树的遍历过程。理解非递归算法的关键是理解各个节点入栈、出栈的顺序。

先序遍历非递归算法

void preordernorec(bitree t, void (*visit)(bitree node))
{
        bitree queue[100];
        bitree p;
        int index = 0;

        if (t != NULL) {
                queue[index++] = t;
                while (index != 0) {
                        p = queue[--index];
                        visit(p);
                        if (p->rchild != NULL) {
                                queue[index++] = p->rchild;
                        }
                        if (p->lchild != NULL) {
                                queue[index++] = p->lchild;
                        }
                }
        }
}

中序遍历非递归算法

void inordernorec(bitree t, void (*visit)(bitree node))
{
        bitree queue[100];
        bitree p;
        int index = 0;

        while ((t!= NULL) ||(index != 0)) {
                if (t != NULL) {
                        queue[index++] = t;
                        t = t->lchild;
                } else {
                        p = queue[--index];
                        visit(p);
                        t = p->rchild;
                }
        }

}

后续遍历非递归算法

void postordernorec(bitree t, void (*visit)(bitree node))
{
        bitree queue1[100];
        bitree queue2[100];
        bitree p;
        int index1 = 0;
        int index2 = 0;

        if (t != NULL) {
                queue1[index1++] = t;
                while (index1 != 0) {
                        p = queue1[--index1];
                        queue2[index2++] = p;
                        if (p->lchild != NULL)
                                queue1[index1++] = p->lchild;
                        if (p->rchild != NULL)
                                queue1[index1++] = p->rchild;
                }

                for (index1 = index2 - 1; index1 >=0; index1--)
                        visit(queue2[index1]);
        }
}

层次遍历二叉树

void levelorder(bitree t, void (*visit)(bitree node))
{
        bitree queue[100];
        bitree p;
        int front = 0;
        int rear = 0;

        if (t != NULL) {
                queue[rear++] = t;
                while (front != rear) {
                        p = queue[front++];
                        visit(p);
                        if (p->lchild != NULL)
                                queue[rear++] = p->lchild;
                        if (p->rchild != NULL)
                                queue[rear++] = p->rchild;
                }
        }
}

测试程序

void visit(bitree node)
{
        printf("%d ", node->data);
}

int main(int argc, char *argv[])
{
        bitree t;

        createbitree(&t);
        printf("pre order: ");
        preorder(t, visit);
        printf("\npre order no rec: ");
        preordernorec(t, visit);

        printf("\n\nin order: ");
        inorder(t, visit);
        printf("\nin order no rec: ");
        inordernorec(t, visit);

        printf("\n\npost order: ");
        postorder(t, visit);
        printf("\npost order no rec: ");
        postordernorec(t, visit);

        printf("\n\nlevel order: ");
        levelorder(t, visit);
        printf("\n");

        return 0;
}

输出结果如下：

pre order: 5 8 12 1 6 9 20 11 17 
pre order no rec: 5 8 12 1 6 9 20 11 17 

in order: 12 8 6 1 9 5 11 17 20 
in order no rec: 12 8 6 1 9 5 11 17 20 

post order: 12 6 9 1 8 17 11 20 5 
post order no rec: 12 6 9 1 8 17 11 20 5 

level order: 5 8 20 12 1 11 6 9 17