广义表转二叉树
广义表 A(B(,D),C(E,)) 转出为:
前序: A B D C E
中序: B D A E C
后序: D B E C A
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 = NULL;
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) return 0;
if (s->top == s->size - 1) return 0;
s->data[++s->top] = val;
return 1;
}
int pop(Stack *s) {
if (!s) return 0;
if (empty(s)) return 0;
s->top -= 1;
return 1;
}
void clear_stack(Stack *s) {
if (!s) return ;
free(s->data);
free(s);
return ;
}
void clear_node(Node *node) {
if (!node) return;
clear_node(node->lchild);
clear_node(node->rchild);
free(node);
return ;
}
void clear_tree(Tree *tree) {
if (!tree) return ;
clear_node(tree->root);
free(tree);
return ;
}
Node *build(const char *str, int *node_num) {
Stack *s = init_stack(strlen(str));
Node *temp = NULL, *p = NULL;
int flag = 0;
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 *node) {
if (!node) return;
printf("%c ", node->data);
pre_order_node(node->lchild);
pre_order_node(node->rchild);
return;
}
void pre_order(Tree *tree) {
if (!tree) return;
printf("%s: ", __func__);
pre_order_node(tree->root);
printf("\n");
}
void in_order_node(Node *node) {
if (!node) return;
in_order_node(node->lchild);
printf("%c ", node->data);
in_order_node(node->rchild);
return;
}
void in_order(Tree *tree) {
if (!tree) return;
printf("%s: ", __func__);
in_order_node(tree->root);
printf("\n");
}
void post_order_node(Node *node) {
if (!node) return;
post_order_node(node->lchild);
post_order_node(node->rchild);
printf("%c ", node->data);
return;
}
void post_order(Tree *tree) {
if (!tree) return;
printf("%s: ", __func__);
post_order_node(tree->root);
printf("\n");
}
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;
}
打印结果:
A(B(,D),C(E,))
pre_order: A B D C E
in_order: B D A E C
post_order: D B E C A