二叉樹的前中後序的遞歸、非遞歸遍歷

C 代碼

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>

#define STACKSIZE 50

/*
 *  定義二叉樹結點以及二叉樹的結構
 */
typedef struct BiTreeNode_
{
    char data;
    struct BiTreeNode_ *left;
    struct BiTreeNode_ *right;
}BiTreeNode;

typedef struct BiTree_
{
    int size;
    BiTreeNode *root;
}BiTree;

/*
 *  定義棧的結構
 */
typedef struct Stack_
{
    BiTreeNode * base[STACKSIZE];
    int top;
    int stacksize;
}Stack;

void stack_init(Stack *stack)
{
    stack->top = -1;
    stack->stacksize = 0;
}

void push(Stack *stack, BiTreeNode *node)
{
    if (stack->stacksize == STACKSIZE)
        exit(-1);

    stack->base[++stack->top] = node;
    stack->stacksize++;
}

int stack_empty(Stack *stack)
{
    if ((-1 == stack->top) && (0 == stack->stacksize))
        return 1;
    else
        return 0;
}

BiTreeNode* pop(Stack *stack)
{
    if (stack->top < 0)
        exit(-1);
    else
    {
        stack->stacksize--;
        return stack->base[stack->top--];
    }
}

BiTreeNode* get_stack_top(Stack *stack)
{
    if (stack->top < 0)
        exit(-1);
    return stack->base[stack->top];
}

void bitree_init(BiTree *tree)
{
    tree->size = 0;
    tree->root = NULL;
}

//給樹tree的某個結點node插入數據域爲data的左子樹
int bitree_ins_left(BiTree *tree, BiTreeNode *node, const char data)
{
    BiTreeNode *new_node, **position;

    if (NULL == node)
    {
        if (tree->size > 0)
            return -1;
        position = &tree->root;
    }
    else
    {
        if (node->left != NULL)
            return -1;
        position = &node->left;
    }

    if (NULL == (new_node = (BiTreeNode *)malloc(sizeof(BiTreeNode))))
        return -1;
    new_node->data = data;
    new_node->left = NULL;
    new_node->right = NULL;
    *position = new_node;
    tree->size++;

    return 0;
}

//給樹tree的某個結點node插入數據域爲data的右子樹
int bitree_ins_right(BiTree *tree, BiTreeNode *node, const char data)
{
    BiTreeNode *new_node, **position;

    if (NULL == node)
    {
        if (tree->size > 0)
            return -1;

        position = &tree->root;
    }
    else
    {
        if (node->right != NULL)
            return -1;

        position = &node->right;
    }

    if (NULL == (new_node = (BiTreeNode *)malloc(sizeof(BiTreeNode))))
        return -1;

    new_node->data = data;
    new_node->left = NULL;
    new_node->right = NULL;

    *position = new_node;

    tree->size++;
    return 0;
}

// 先序遍歷函數
void pre_order(const BiTreeNode *node)
{
    if (node)
    {
        printf("%c", node->data);
        pre_order(node->left);
        pre_order(node->right);
    }
}

// 中序遍歷函數
void in_order(const BiTreeNode *node)
{
    if (node)
    {
        in_order(node->left);
        printf("%c", node->data);
        in_order(node->right);
    }
}

// 後序遍歷函數
void end_order(const BiTreeNode *node)
{
    if (node)
    {
        end_order(node->left);
        end_order(node->right);
        printf("%c", node->data);
    }
}

// 先序遍歷函數（非遞歸
void pre_order_norec(const BiTreeNode *node)
{
    Stack stack;
    stack_init(&stack);
    push(&stack, node);
    while (stack.stacksize != 0)
    {
        BiTreeNode *p = pop(&stack);
        if (p == NULL)
        {
            putchar(' ');
        }
        else
        {
            printf("%c", p->data);
            push(&stack, p->right);
            push(&stack, p->left);
        }
    }
}

// 中序遍歷函數（非遞歸
void in_order_norec(const BiTreeNode *node)
{
    Stack stack;
    stack_init(&stack);
    push(&stack, node);
    while (stack.stacksize != 0)
    {
        BiTreeNode *p = pop(&stack);
        while (p->left)
        {
            push(&stack, p);
            p = p->left;
        }
        putchar(' ');
        printf("%c", p->data);
        if (p->right)
        {
            push(&stack, p);
            push(&stack, p->right);
        }
        else
        {
            putchar(' ');
            while (stack.stacksize != 0)
            {
                BiTreeNode *from = pop(&stack);
                if (from->left == p)
                {
                    printf("%c", from->data);
                    push(&stack, from);
                    if (from->right)
                    {
                        push(&stack, from->right);
                        break;
                    }
                    else
                    {
                        putchar(' ');
                        p = from;
                    }
                }
                else
                {
                    p = from;
                }
            }
        }
    }
}

// 後序遍歷函數（非遞歸
void end_order_norec(const BiTreeNode *node)
{

}

int main()
{
    char data;
    Stack stack;
    BiTree tree;
    BiTreeNode *node;

    stack_init(&stack);
    bitree_init(&tree);

    printf("請以先序順序輸入結點值: \n");

    data = getchar();

    if (0 == tree.size)
    {
        if (' ' == data)
            return -1;
        bitree_ins_left(&tree, NULL, data);
        push(&stack, tree.root);
    }
    while (!stack_empty(&stack))
    {
        data = getchar();

        if (' ' == data)
        {
            node = pop(&stack);

            if (NULL == node->left)
            {
                data = getchar();
                if (' ' != data)
                {
                    bitree_ins_right(&tree, node, data);
                    push(&stack, node->right);
                }
            }
        }
        else
        {
            node = get_stack_top(&stack);
            if (NULL == node->left)
            {
                bitree_ins_left(&tree, node, data);
                push(&stack, node->left);
            }
            else
            {
                node = pop(&stack);
                bitree_ins_right(&tree, node, data);
                push(&stack, node->right);
            }
        }
    }
    printf("-----先序遞歸遍歷二叉樹-----\n");
    pre_order(tree.root);
    putchar('\n');

    printf("-----中序遞歸遍歷二叉樹-----\n");
    in_order(tree.root);
    putchar('\n');

    printf("-----後序遞歸遍歷二叉樹-----\n");
    end_order(tree.root);
    putchar('\n');

    printf("-----先序非遞歸遍歷二叉樹-----\n");
    pre_order_norec(tree.root);
    putchar('\n');

    printf("-----中序非遞歸遍歷二叉樹-----\n");
    in_order_norec(tree.root);
    putchar('\n');

    printf("-----後序非遞歸遍歷二叉樹-----\n");
    end_order_norec(tree.root);
    putchar('\n');

    return 0;
}