C语言二叉树遍历操作

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

#define MAX_TREE_SIZE 80

typedef struct bit_tree_node
{
	unsigned int num;
	struct bit_tree_node *lchild,*rchild;
}tree_node,*bit_tree;

unsigned int create_tree(bit_tree *tree)//指针的指针
{
	unsigned int num;

	printf("please input:\n");
	scanf("%d",&num);

	if(num == 0)
	{
		return -1;
	}
	else
	{
		*tree =(bit_tree)malloc(sizeof(tree_node));
		memset(*tree,0,sizeof(tree_node));
		(*tree)->num = num;
		printf("please input %d's left child:",(*tree)->num);
		create_tree(&((*tree)->lchild));
		printf("please input %d's right child:",(*tree)->num);
		create_tree(&((*tree)->rchild));
	}

	return 0;
}

void pre_order(bit_tree tree)//前序遍历
{
	if(tree != NULL)
	{
		printf("%d,",tree->num);
		pre_order(tree->lchild);
		pre_order(tree->rchild);
	}
}

void in_order(bit_tree tree)//中序遍历
{
	if(tree != NULL)
	{
		pre_order(tree->lchild);
		printf("%d,",tree->num);
		pre_order(tree->rchild);
	}
}

void post_order(bit_tree tree)//后序遍历
{
	if(tree != NULL)
	{
		pre_order(tree->lchild);
		pre_order(tree->rchild);
		printf("%d,",tree->num);
	}
}


void print_tree(bit_tree tree,int layer)
{
	if(tree == NULL)
	{
		return;
	}

	print_tree(tree->rchild,layer+1);
	for(int i=0;i<layer;i++)
	{
		printf("----");
	}
	printf("%d\n",tree->num);
	print_tree(tree->lchild,layer+1);

}

void pre_tree(bit_tree tree)//前序非递归遍历
{
	bit_tree stack[MAX_TREE_SIZE];
	int top = 0; 

	while(tree != NULL||top!= 0)
	{
		if(tree != NULL)
		{
			printf("%d\n",tree->num);

			top++;
			stack[top] = tree;
			tree = tree->lchild;
		}
		else
		{
			tree = stack[top];
			top--;
			tree = tree->rchild;
		}

	}
}

void in_tree(bit_tree tree)//中序非递归遍历
{
	bit_tree stack[MAX_TREE_SIZE];
	int top = 0; 

	while(tree != NULL||top!= 0)
	{
		if(tree != NULL)
		{
			top++;
			stack[top] = tree;
			tree = tree->lchild;
		}
		else
		{
			tree = stack[top];
			top--;
			printf("%d\n",tree->num);
			tree = tree->rchild;
		}

	}
}

void post_tree1(bit_tree tree)//后序非递归遍历1
{
	bit_tree stack[MAX_TREE_SIZE];
	int top = 0; 
	bit_tree p = tree;
	bit_tree q = NULL;

	while(p != NULL || top != 0)
	{
		while(p != NULL)
		{
			top++;
			stack[top] = p;
			p = p->lchild;
		}

		if(top>0)
		{
			p = stack[top];
			if(p->rchild == NULL || p->rchild == q)
			{
				top--;
				printf("%d\n",p->num);
				q = p;
				p= NULL;
			}
			else
			{
				p = p->rchild;
			}

		}
	}
}

void post_tree2(bit_tree tree)//后序非递归遍历2
{
	bit_tree stack[MAX_TREE_SIZE];
	int top = 0; 

	bit_tree save[MAX_TREE_SIZE];
	int save_top = 0;

	while(tree != NULL||top!= 0)
	{
		if(tree != NULL)
		{
			save_top++;
			save[save_top] = tree;

			top++;
			stack[top] = tree;
			tree = tree->rchild;
		}
		else
		{
			tree = stack[top];
			top--;
			tree = tree->lchild;
		}

	}

	while(save_top !=0)
	{
		printf("%d\n",save[save_top]->num);
		
		save_top--;

	}
}

void layer_tree(bit_tree tree)//层次遍历遍历
{
	bit_tree queue[MAX_TREE_SIZE];	
	int head = 0;
	int tail = 0;
	bit_tree tree_node;
	
	if(tree != NULL)
	{
		queue[tail] = tree;
		tail++;
	}

	while(head != tail)
	{
		tree_node = queue[head];
		head++;
		printf("%d\n",tree_node->num);

		if(tree_node->lchild != NULL)
		{
			queue[tail] = tree_node->lchild;
			tail++;
		}

		if(tree_node->rchild != NULL)
		{
			queue[tail] = tree_node->rchild;
			tail++;
		}
		
	}

}
void main()
{
	bit_tree tree;
	create_tree(&tree);
	int choice = 0;
	while(choice != -1)
	{
		scanf("%d",&choice);

		switch(choice)
		{
			case 1:
				print_tree(tree,1);
				break;

			case 2:
				pre_order(tree);
				break;

			case 3:
				pre_tree(tree);
				break;	

			case 4:
				post_tree1(tree);
				break;
			case 5:
				layer_tree(tree);
				break;
			case 7:
				in_tree(tree);
				break;
							
			case 8:
				post_tree2(tree);
				break;

			default:
				break;
		}
	}
}