二叉树的遍历打印

二叉树的遍历打印, 前序, 中序, 后序, 层级. (图形化打印见<二叉树的增加,删除>)

#include "stdlib.h"
#include "stdio.h"
#include "string.h"

typedef char element_type;

typedef struct tree_node {
    element_type element;
    struct tree_node *left_child, *right_child;
    //struct tree_node *parent;
} tree_node_t;

void pre_order_traverse(tree_node_t *root, int depth)
{
    if (root) {
       
        for(int i = 0; i < depth; i++) printf(" |");
        printf("-%c\n", root->element);
        pre_order_traverse(root->left_child, depth + 1);
        pre_order_traverse(root->right_child, depth + 1);
    }
}

void in_order_traverse(tree_node_t *root, int depth)
{
    if (root) {
        in_order_traverse(root->left_child, depth + 1);
        for(int i = 0; i < depth; i++) printf(" |");
        printf("-%c\n", root->element);
        in_order_traverse(root->right_child, depth + 1);
    }
}

void last_order_traverse(tree_node_t *root, int depth)
{
    if (root) {
        last_order_traverse(root->left_child, depth + 1);
        last_order_traverse(root->right_child, depth + 1);
        for(int i = 0; i < depth; i++) printf(" |");
        printf("-%c\n", root->element);
    }
}

typedef struct {
    tree_node_t *node[128];
    int head,tail;
} tree_node_queue_t;

tree_node_queue_t tree_node_queue;

void tree_node_queue_init()
{
    memset(&tree_node_queue, 0, sizeof(tree_node_queue_t));
}

void tree_node_queue_in(tree_node_t *node)
{
    tree_node_queue.node[tree_node_queue.head++] = node;
    if (tree_node_queue.head == 127)
        tree_node_queue.head = 0;
}

tree_node_t *tree_node_queue_out(void)
{
    tree_node_t *node = NULL;
    if (tree_node_queue.tail !=  tree_node_queue.head) {
        node = tree_node_queue.node[tree_node_queue.tail++];
        if (tree_node_queue.tail == 127)
            tree_node_queue.tail = 0;
    }
    return node;
}

int is_empty_queue()
{
    return (tree_node_queue.tail ==  tree_node_queue.head);
}

void depth_order_traverse(tree_node_t *root)
{
    tree_node_t* print_node;
    int cur,next;
    if (root) {
        tree_node_queue_init();
        tree_node_queue_in(root);
        cur = 1; //current depth node num
        next = 0; //next depth node num
        while(!is_empty_queue()) {
            print_node = tree_node_queue_out();
            if (print_node) {
                printf(" %c ", print_node->element);
            }
            cur--;
            
            if (print_node->left_child) {
                tree_node_queue_in(print_node->left_child);
                next++;
            }
            if (print_node->right_child) {
                tree_node_queue_in(print_node->right_child);
                next++;
            }

            if (cur == 0) { //cur depth print done print\n
                cur = next;
                next = 0;
                printf("\n");
            }
        }
    }
}

tree_node_t *creat_tree(int depth)
{
    tree_node_t *node;
    element_type element;

get:
    scanf("%c", &element);
    if (element == '\n') {
        goto get;
    }

    if (element == '#') {
        node = NULL;
        printf("depth %d element null\n", depth);
    }
    else {
        printf("depth %d element %c\n", depth, element);
        node = (tree_node_t *)malloc(sizeof(tree_node_t));
        node->element = element;
        printf("depth %d element %c left child:", depth, element);
        node->left_child = creat_tree(depth + 1);
        printf("depth %d element %c right child:", depth, element); 
        node->right_child = creat_tree(depth + 1);
    }

    return node;
}

int main(int argc, char* argv[])
{
    tree_node_t *root;
    root = creat_tree(0);
    printf("pre order print\n");
    pre_order_traverse(root, 0);
    printf("in order print\n");
    in_order_traverse(root, 0);
    printf("last order print\n");
    last_order_traverse(root, 0);
    printf("depth order print\n");
    depth_order_traverse(root);
}