二叉树遍历之递归、父结点、栈

二叉树结构

struct bst_node {    struct bst_node *parent;    struct bst_node *left;    struct bst_node *right;    int key;};

1. 递归

这个代码最直接，不需要父结点，不多解释

void bst_inorder(struct bst_node *node){    if (node) {        if (node->left)            bst_inorder(node->left);        printf("%d ", node->key);        if (node->right)            bst_inorder(node->right);    }}void bst_postorder(struct bst_node *node){    if (node) {        if (node->left)            bst_postorder(node->left);        if (node->right)            bst_postorder(node->right);        printf("%d ", node->key);    }}void bst_preorder(struct bst_node *node){    if (node) {        printf("%d ", node->key);        if (node->left)            bst_preorder(node->left);        if (node->right)            bst_preorder(node->right);    }}

2. 父结点

使用父结点回溯

2.1中序

void bst_nonrecur_inorder(struct bst_node *root){    struct bst_node *p = root, *parent;    while (p && p->left)        p = p->left;        for (;p;) {        printf("%d ", p->key);        if (p->right) {            p = p->right;            while (p && p->left)                p = p->left;        }        else {            parent = p->parent;            while (parent) {                if (parent->left == p) {                    break;                }                p = parent;                parent = parent->parent;            }            p = parent;        }    }}

遍历过程很简单，首先找到最左结点，即找根结点树的最小结点。

访问当前结点，如果当前结点有右子结点，则访问其右子结点的最左结点；否则回溯，直到某个祖先结点为其父结点的左子结点，此为后继结点；然后继续循环。

这个遍历过程就是算法导论中的两个过程，一个是取最小值，另一个是找后继结点

2.2 前序

void bst_nonrecur_preorder(struct bst_node *root){    struct bst_node *p = root, *parent;    while(p) {        printf("%d ", p->key);        if (p->left)            p = p->left;        else if (p->right)            p = p->right;        else {            for (;;) {                if (!(parent = p->parent)) {                    p = NULL;                    break;                }                if (parent->left == p && parent->right) {                    p = parent->right;                    break;                }                p = parent;            }        }    }}

前序遍历最简单，首先访问当前结点，然后优先访问左子树，然后右子树，如果遇到叶子结点，则回溯，直到其祖先结点为其父结点的左子结点而且该祖先结点有右子树

2.3 后序

void bst_nonrecur_postorder(struct bst_node *root){    struct bst_node *p = root, *parent;    while(p) {        if (p->left)            p = p->left;        else if (p->right)            p = p->right;        else {            printf("%d ", p->key);            for (;;) {                if (!(parent = p->parent)) {                    p = NULL;                    break;                }                if (parent->left == p) {                    if (parent->right) {                        p = parent->right;                        break;                    }                    printf("%d ", parent->key);                }                else if (parent->right == p) {                    printf("%d ", parent->key);                                    }                p = parent;            }        }    }}

后序遍历类似前序，只不过优先访问左子树，其次右子树，最后才是根结点。上述代码先访问叶子结点，在回溯的过程中，分两种情况讨论：

1. 该叶子结点在其某祖先结点的左子树，如果该祖先结点没有右子树，则直接访问该祖先结点，否则转向其右子树

2. 该叶子结点在其某祖先结点的右子树，由于从右子树回溯，表示左右子树都访问过了，直接访问该祖先结点

3. 栈

使用数组实现栈结构

3.1 中序

void bst_stack_inorder(struct bst_node *root){    int i = 0;    struct bst_node *s[1024] = {0, };    struct bst_node *p = root;    /* use s[0] as NULL pointer */#define PUSH_S(n, i) s[++(i)]=(n)#define POP_S(i)     s[(i)--]    PUSH_S(p, i);    while (p->left) {        PUSH_S(p->left, i);        p = p->left;    }    while (i > 0) {        /* pop top && visit top var */        p = POP_S(i);        printf("%d ", p->key);        /* push right */        if (p->right) {            PUSH_S(p->right, i);            p = p->right;            /* push all left */            while (p->left) {                PUSH_S(p->left, i);                p = p->left;            }        }    }}

遍历过程和使用父结点类似，只不过将回溯过程使用栈来处理

3.2 前序

void bst_stack_preorder(struct bst_node *root){    int i = 0;    struct bst_node *s[1024] = {0, };    struct bst_node *p = root;    /* use s[0] as NULL pointer */#define PUSH_S(n, i) s[++(i)]=(n)#define POP_S(i)     s[(i)--]    PUSH_S(p, i);    while (i > 0) {        /* pop top && visit top var */        p = POP_S(i);        printf("%d ", p->key);        /* push right */        if (p->right) {            PUSH_S(p->right, i);        }        /* push left */        if (p->left)            PUSH_S(p->left, i);    }}

此遍历过程最简单，首先访问当前结点，再将右子结点压栈，最后再压入左子结点，因为栈的后进先出原则保证优先访问左子结点

3.3 后序

static inline void bst_stack_post_push(struct bst_node *p, struct bst_node **s, int *i){    int index = *i;    s[++index] = p;    while (p->left || p->right) {        if (p->left)             p = p->left;        else            p = p->right;        s[++index] = p;    }    *i = index;}void bst_stack_postorder(struct bst_node *root){    int i = 0;    struct bst_node *s[1024] = {0, };    struct bst_node *p = root, *last;;    /* use s[0] as NULL pointer */#define PUSH_S(n, i) s[++(i)]=(n)#define POP_S(i)     s[(i)--]#define TOP_S(i)     s[(i)]    bst_stack_post_push(p, s, &i);    while (i > 0) {        /* get top */        p = TOP_S(i);        if (p->left == last && p->right) {            bst_stack_post_push(p->right, s, &i);        }        else {            p = POP_S(i);                        printf("%d ", p->key);            last = p;        }    }}

此遍历过程最复杂，优先访问左子结点，其次右子结点，一直到叶子结点，将其所有祖先结点入栈，这个过程由函数bst_stack_post_push完成

使用last 来保存上一个遍历的结点

遍历时，先查看栈顶元素，分两种情况讨论：

1.  如果遍历路径是从左子树到根，则查看根结点是否有右子树，如果有右子树，则需要先将右子树使用bst_stack_post_push处理，否则直接访问

2.  如果遍历路径是从右子树到根，则直接访问