广义表转二叉树

广义表转二叉树

/*************************************************************************
	> File Name: table_to_tree.c
	> Author: Luzelin
	> Mail: 
	> Created Time: 
 ************************************************************************/

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

typedef struct Node {           //树的结点定义
    char data;
    struct Node *lchild, *rchild;
} Node;

typedef struct Tree {           //树的定义
    Node *root;
    int n;
} Tree;

typedef struct Stack {          //定义栈，栈的每个元素都是一个树结点地址
    Node **data;
    int top, size;
} Stack;

Node *getNewNode(char val) {    //实例化一个树结点
    Node *p = (Node *)malloc(sizeof(Node));
    p->data = val;
    p->lchild = p->rchild = NULL;
    return p;
}

Tree *getNewTree() {            //实例化一颗树
    Tree *tree = (Tree *)malloc(sizeof(Tree));
    tree->root = NULL;
    tree->n = 0;
    return tree;
}

Stack *init_stack(int n) {      //实例化栈
    Stack *s = (Stack *)malloc(sizeof(Stack));
    s->data = (Node **)malloc(sizeof(Node *) * n);
    s->top = -1;
    s->size = n;
    return s;
}

Node *top(Stack *s) {           //取栈顶元素
    return s->data[s->top];
}

int empty(Stack *s) {           //栈判空
    return s->top == -1;
}

int push(Stack *s, Node *val) {  //压栈
    if(s == NULL)  return 0;
    if(s->top == s->size - 1)  return 0;
    s->data[++(s->top)] = val;
    return 1;
}

int pop(Stack *s) {              //弹栈
    if(s == NULL)  return 0;
    if(empty(s))  return 0;
    s->top -= 1;
    return 1;
}

void clear_stack(Stack *s) {     //释放栈
    if(s == NULL)  return ;
    free(s->data);
    free(s);
    return ;
}

void clear_node(Node *node) {   //释放结点（前序遍历）
    if(node == NULL)  return ;
    clear_node(node->lchild);
    clear_node(node->rchild);
    free(node);
    return ;
}

void clear_tree(Tree *tree) {   //释放树
    if(tree == NULL)  return ;
    clear_node(tree->root);
    free(tree);
    return ;
}

Node *build(const char *str, int *node_num) {
    Stack *s = init_stack(strlen(str));
    int flag = 0;
    Node *temp = NULL, *p = NULL;
    while(str[0]) {
        switch(str[0]) {
            case '(': {
                push(s, temp);
                flag = 0;
            } break;

            case ')': {
                p = top(s);
                pop(s);
            } break;

            case ',': {
                flag = 1;
            } break;

            case ' ': break;

            default: {
                temp = getNewNode(str[0]);
                if(!empty(s) && flag == 0) {
                    top(s)->lchild = temp;
                }
                else if(!empty(s) && flag == 1) {
                    top(s)->rchild = temp;
                }
                ++(*node_num);
            } break;
        }
        ++str;
    }
    clear_stack(s);
    if(temp && !p)  p = temp;   //防止只输入一个根结点的情况 
    return p;
}

//前
void pre_order_node(Node *root) {
    if(root == NULL)  return ;
    printf("%c ", root->data);
    pre_order_node(root->lchild);
    pre_order_node(root->rchild);
    return ;
}

void pre_order(Tree *tree) {
    if(tree == NULL)  return ;
    printf("pre_order : ");
    pre_order_node(tree->root);
    printf("\n");
    return ;
}

//中
void in_order_node(Node *root) {
    if(root == NULL)  return ;
    in_order_node(root->lchild);
    printf("%c ", root->data);
    in_order_node(root->rchild);
    return ;
}

void in_order(Tree *tree) {
    if(tree == NULL)  return ;
    printf("in_order : ");
    in_order_node(tree->root);
    printf("\n");
    return ;
}

//后
void post_order_node(Node *root) {
    if(root == NULL)  return ;
    post_order_node(root->lchild);
    post_order_node(root->rchild);
    printf("%c ", root->data);
    return ;
}

void post_order(Tree *tree) {
    if(tree == NULL)  return ;
    printf("post_order : ");
    post_order_node(tree->root);
    printf("\n");
    return ;
}

int main() {
    char str[1000] = {0};
    int node_num = 0;
    scanf("%[^\n]s", str);
    Tree *tree = getNewTree();
    tree->root = build(str, &node_num);
    tree->n = node_num;
    pre_order(tree);
    in_order(tree);
    post_order(tree);
    clear_tree(tree);
    return 0;
}