基于栈和二叉树实现广义表转二叉树

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
using namespace std;
//二叉树的结构定义
typedef struct Node {
	char data;
	struct Node* lchild, * rchild;
}Node;
typedef struct tree {
	Node* root;
	int length;
}Tree;
//栈的结构定义(储存二叉树节点地址)
typedef struct Stack {
	Node** data;
	int top, size;
}Stack;
Node* get_newNode(char);//初始化节点
Tree* get_newTree();//初始化树
void clear_node(Node*);//销毁二叉树的节点
void clear_tree(Tree*);//销毁二叉树
Stack* init_stack(int);//初始化栈
void clear_stack(Stack*);//栈的销毁
Node* top(Stack*);//输出栈顶元素
int empty(Stack*);//栈的判空
int push(Stack*, Node*);//入栈操作
int pop(Stack*);//出栈操作

Node* get_newNode(char val) {
	Node* p = (Node*)malloc(sizeof(Node));
	p->lchild = p->rchild = NULL;
	p->data = val;
	return p;
}
Tree* get_newTree() {
	Tree* t = (Tree*)malloc(sizeof(Tree));
	t->root = NULL;
	t->length = 0;
	return t;
}
void clear_node(Node* root) {
	if (root == NULL)return;
	clear_node(root->lchild);
	clear_node(root->rchild);
	free(root);
	return;
}
void clear_tree(Tree* tree) {
	if (tree == NULL)return;
	clear_node(tree->root);
	free(tree);
	return;
}
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;
}
void clear_stack(Stack* s) {
	if (s == NULL)return;
	free(s->data);
	free(s);
	return;
}
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;
}
//A(B(, D), C(E))
Node* bulid(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 = get_newNode(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 == NULL)p = temp;
	return p;
}
void in_order_node(Node* root) {
	if (root == nullptr)return;
	in_order_node(root->lchild);
	printf("%c ", root->data);
	in_order_node(root->rchild);
	return;
}
void in_order(Tree* t) {
	if (t == nullptr)return;
	printf("in_order(%d) : ",t->length);
	in_order_node(t->root);
	printf("\n");
	return;
}
void pre_order_node(Node* root) {
	if (root == nullptr)return;
	printf("%c ", root->data);
	pre_order_node(root->lchild);
	pre_order_node(root->rchild);
	return;
}
void pre_order(Tree* t) {
	if (t == nullptr)return;
	printf("pre_order(%d) : ", t->length);
	pre_order_node(t->root);
	printf("\n");
	return;
}
void post_order_node(Node* root) {
	if (root == nullptr)return;
	post_order_node(root->lchild);
	post_order_node(root->rchild);
	printf("%c ", root->data);
	return;
}
void post_order(Tree* t) {
	if (t == nullptr)return;
	printf("post_order(%d) : ", t->length);
	post_order_node(t->root);
	printf("\n");
	return;
}
int main() {
	char str[1000] = { 0 };
	int node_num = 0;
	cin >> str;
	//scanf_s("%[^\n]s", str);
	//getchar();
	Tree* tree = get_newTree();
	tree->root = bulid(str, &node_num);
	tree->length = node_num;
	pre_order(tree);
	in_order(tree);
	post_order(tree);
	clear_tree(tree);
	return 0;
}