树的操作

1、无序树的操作

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

struct bitTree
{
	char data;
	int times;   //用于非递归的后续遍历计数用
	struct bitTree *rtree;
	struct bitTree *ltree;
};

typedef struct bitTree BitTree;

//1、创建树
BitTree* create_node(char data)
{
	BitTree* newnode = (BitTree*) malloc(sizeof(BitTree));
	if(!newnode)
	{
		puts("malloc failed!");
		exit(-1);
	}
	else
	{
		newnode->data = data;
		newnode->ltree = NULL;
		newnode->rtree = NULL;
		
		return newnode;
	}
}

//2、插入节点
void insert_node(BitTree* cur, BitTree* lnode, BitTree* rnode)
{	
	cur->ltree = lnode;
	cur->rtree = rnode;
}

void print(BitTree *curnode)
{
	putchar(curnode->data);
	putchar('\t');
}

//3、递归遍历
void front_traverse(BitTree* tree)  //前序
{
	if(tree == NULL)
		return;
	else
	{	
		print(tree);
		front_traverse(tree->ltree);
		front_traverse(tree->rtree);	
	}
}
void mid_traverse(BitTree * tree)   //中序
{
	if(tree == NULL)
		return;
	else
	{
		mid_traverse(tree->ltree);
		print(tree);
		mid_traverse(tree->rtree);
	}
}
void rear_traverse(BitTree * tree)  //后序
{
	if(tree == NULL)
		return;
	else
	{
		rear_traverse(tree->ltree);
		rear_traverse(tree->rtree);
		print(tree);
	}
}

//非递归中序遍历，用栈实现
void traverse_mid(BitTree* root)			
{
	if(root == NULL)
		return;

	BitTree * stack[20];	//预定义栈大小
	int top = 0;
	BitTree * move = root;
	
	while(top != 0 || move)
	{
		while(move != NULL)	            //寻找最后一个左子数
		{
			stack[top++] = move;      //入栈
			move = move->ltree;       //遍历左子树
		}
		if(top != 0)                  //栈非空，取栈顶元素
		{
			move = stack[--top];      //栈顶元素
			printf("%c\t", move->data);
			move = move->rtree;       //遍历右树
		}
	}
}
//非递归前序遍历
void traverse_front(BitTree* root)
{
	if(root == NULL)
		return;

	BitTree *stack[20];	//预定义栈大小
	int top = 0;
	BitTree * move = root;
	
	while(top != 0 || move)
	{
		while(move != NULL)	//寻找最后一个左子数
		{
			printf("%c\t",move->data);
			stack[top++] = move;            //入栈
			move = move->ltree;             //遍历左子树
		}
		
		if(top != 0)                        //栈非空
		{
			move = stack[--top];            //栈顶元素
			move = move->rtree;             //遍历右树
		}
	}
}
//非递归后续遍历
void traverse_rear(BitTree* root)
{
	if(root == NULL)
		return;

	BitTree *stack[20];	//预定义栈大小
	int top = 0;
	BitTree * move = root;
	
	while(top != 0 || move != NULL)
	{
		while(move != NULL)	//寻找最后一个左子树
		{
			move->times = 1;              //节点首次被访问
			stack[top++] = move;          //入栈
			move = move->ltree;           //遍历左子树
		}	
		if(top != 0)                      //栈非空
		{
			move = stack[--top];		  //取栈顶元素
			if(move->times == 1)		  //右树未遍历
			{
				move->times++;			  //第一次出现在栈顶
				stack[top++] = move;	  //重新入栈
				move = move->rtree;		  //遍历右树
			}
			else if(move->times == 2)		//第二次出现在栈顶，左右树均遍历完毕
			{
				printf("%c\t",move->data);		
				move = NULL;                //
			}
		}		
	}
}

int main()
{
	//创建节点
	BitTree * A = create_node('A');
	BitTree * B = create_node('B');
	BitTree * C = create_node('C');
	BitTree * D = create_node('D');
	BitTree * E = create_node('E');
	BitTree * F = create_node('F');			
	BitTree * G = create_node('G');	
	BitTree * K = create_node('K');
	//连接成树
	insert_node(A,B,C);
	insert_node(B,D,E);
	insert_node(C,F,G);
	insert_node(F,NULL,K);
	//遍历树
	front_traverse(A);      //递归
	putchar(10);
	traverse_front(A);      //非递归
	putchar(10);
	
	mid_traverse(A);        //递归
	putchar(10);
	traverse_mid(A);        //非递归
	putchar(10);
	
	rear_traverse(A);       //递归
	putchar(10);
	traverse_rear(A);       //非递归
	putchar(10);
	
	return 0;
}