C樹操作，前中後序遞歸遍歷，前中後序非遞歸遍歷，樹狀顯示

/*
 * BTress.c
 *
 *  Created on: 2013-9-3
 *      Author: youyou
 */
#include<stdio.h>
#include <stdlib.h>
typedef struct node {
	int num;
	int isFirst;
	struct node *lchild;
	struct node *rchild;
} Node;

typedef struct stack {
	Node* a[1000];
	int top;
	int bottom;
} Stack;
enum Enum {
	LEFT, RIGHT
};
//函數聲明
Node * pop(Stack * stack);
void gernerateTree(Node *node, int num);
Node * createBTree(int *p, int n);
enum Enum cmp(int root, int insertNum);
void mtranversal2(Node *root);
void push(Stack *stack, Node * num);
void mtranversal1(Node *root);
void ptranversal2(Node *root);
Node *popQueue(Stack *stack);
void displyTree(Node *root);
void btranversal2(Node *root);
int main(void) {
	int a[10] = { 14, 6, 1, 32, 27, 9, 16, 1, 10, 40 };
	Node *root = createBTree(a, 10);
	mtranversal2(root);
	printf("\n");
	ptranversal2(root);
	printf("\n");
	displyTree(root);
	printf("\n");
	btranversal2(root);
	return 1;
}
//生成樹
Node * createBTree(int *p, int n) {
	Node *root = (Node *) malloc(sizeof(Node));
	int i = 0;
	for (; i < n; i++) {
		if (i == 0) {
			root->num = p[i];
			root->lchild = NULL;
			root->rchild = NULL;
		} else {
			gernerateTree(root, p[i]);
		}
	}
	return root;
}

void gernerateTree(Node *node, int num) {
	switch (cmp(node->num, num)) {
	case LEFT:
		if (node->lchild != NULL ) {
			gernerateTree(node->lchild, num);
		} else {
			node->lchild = (Node *) malloc(sizeof(Node));
			node->lchild->num = num;
			node->lchild->lchild = NULL;
			node->lchild->rchild = NULL;
		}
		break;
	case RIGHT:
		if (node->rchild != NULL ) {
			gernerateTree(node->rchild, num);
		} else {
			node->rchild = (Node *) malloc(sizeof(Node));
			node->rchild->num = num;
			node->rchild->lchild = NULL;
			node->rchild->rchild = NULL;
		}
		break;
	}

}
enum Enum cmp(int root, int insertNum) {
	if (insertNum >= root) {
		return RIGHT;
	} else {
		return LEFT;
	}
}

//遞歸中序遍歷
void mtranversal1(Node *root) {
	if (root->lchild != NULL ) {
		mtranversal1(root->lchild);
	}
	printf("%d", root->num);
	if (root->rchild != NULL ) {
		mtranversal1(root->rchild);
	}

}
//非遞歸中序遍歷
void mtranversal2(Node *root) {
	Stack * stack = malloc(sizeof(Stack));
	Node *p = root;
	while (p != NULL || stack->top != 0) {
		while (p != NULL ) {
			push(stack, p);
			p = p->lchild;
		}
		if (stack->top != 0) {
			p = pop(stack);
			printf("%d\t", p->num);
			p = p->rchild;
		}

	}
	free(stack);

}
//遞歸前序遍歷
void ptranversal1(Node *root) {
	printf("%d", root->num);
	if (root->lchild != NULL ) {
		mtranversal1(root->lchild);
	}
	if (root->rchild != NULL ) {
		mtranversal1(root->rchild);
	}

}
//非遞歸前序遍歷
void ptranversal2(Node *root) {
	Stack * stack = malloc(sizeof(Stack));
	Node *p = root;
	while (p != NULL || stack->top != 0) {

		while (p != NULL ) {
			printf("%d\t", p->num);
			push(stack, p);
			p = p->lchild;
		}
		if (stack->top != 0) {
			p = pop(stack);
			p = p->rchild;
		}

	}
	free(stack);

}
//遞歸後序遍歷
void btranversal1(Node *root) {
	if (root->lchild != NULL ) {
		mtranversal1(root->lchild);
	}
	if (root->rchild != NULL ) {
		mtranversal1(root->rchild);
	}
	printf("%d", root->num);

}
//非遞歸後續遍歷
void btranversal2(Node *root) {
	Stack * stack = malloc(sizeof(Stack));
	Node *p = root;
	Node *temp = malloc(sizeof(Stack));
	while (p != NULL || stack->top != 0) {
		while (p != NULL ) {
			push(stack, p);
			p->isFirst = 1;
			p = p->lchild;
		}
		if (stack->top != 0) {
			temp = pop(stack);
			if (temp->isFirst == 1) {
				temp->isFirst = 0;
				push(stack, temp);
				p=temp->rchild;
			} else {
				printf("%d\t", temp->num);
				p = NULL;
			}

		}

	}
	free(stack);
	free(temp);

}
//打印樹狀圖
void displyTree(Node *root) {
	Stack * stack = malloc(sizeof(Stack));
	Stack * stackcp = malloc(sizeof(Stack));
	Node *p = root;
	push(stack, p);
	while (stack->bottom != stack->top || stackcp->bottom != stackcp->top) {
		while (stack->bottom != stack->top) {
			Node *temp = popQueue(stack);
			if (temp->lchild != NULL ) {
				push(stackcp, temp->lchild);
			}
			if (temp->rchild != NULL ) {
				push(stackcp, temp->rchild);
			}
			printf("%d\t", temp->num);
		}
		printf("\n");
		while (stackcp->bottom != stackcp->top) {
			Node *temp = popQueue(stackcp);
			if (temp->lchild != NULL ) {
				push(stack, temp->lchild);
			}
			if (temp->rchild != NULL ) {
				push(stack, temp->rchild);
			}
			printf("%d\t", temp->num);

		}
		printf("\n");
	}
	free(stack);
	free(stackcp);
}

Node * pop(Stack * stack) {
	return stack->a[--stack->top];
}
Node *popQueue(Stack *stack) {
	return stack->a[stack->bottom++];
}

void push(Stack *stack, Node *num) {
	stack->a[stack->top++] = num;
}