数据结构——树的简单操作

//树的实现
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct node{
	int data;
	struct node* left;
	struct node* right;
}treeNode;

//初始化队列
typedef struct QueueNode{
	struct treeNode* n;
	struct QueueNode* next;
}QueueNode;


int Max=100;//深度
char *p;
//访问结点数据
void VisitNode(treeNode* n){
	printf("%d ",n->data);
}

//先序遍历
void PreOrder(treeNode* n){
	if(n!=NULL){
		VisitNode(n);
		PreOrder(n->left);
		PreOrder(n->right);
	}
}

//后序遍历
void PostOrder(treeNode* n){
	if(n!=NULL){
		PostOrder(n->left);
		PostOrder(n->right);
		VisitNode(n);
	}
}

//中序遍历
void InOrder(treeNode* n){
	if(n!=NULL){
		InOrder(n->left);
		VisitNode(n);
		InOrder(n->right);
		
	}
}
//求深度

void DeepTree(treeNode* n,int m){
	if(n!=NULL){
		m++;
		if(Max<m)
			Max=m;
		DeepTree(n->left,m);
		DeepTree(n->right,m);
	}
}

//树的层次遍历
void LevelOrder(treeNode* n){
	treeNode list[50],m;//list队列
	int top,base;
	top=0;
	base=0;
	list[top++]=*n;		//根结点入队
	while(top!=base){
		//入队list[top]的左右结点
		m=list[base];
		if(m.left)
			list[top++]=*m.left;
		if(m.right)
			list[top++]=*m.right;
		//出队
		base++;
		VisitNode(&m);
	}
}


//入队
void DeQueue(QueueNode** Rear,treeNode** n){
	QueueNode* m=(QueueNode*)malloc(sizeof(QueueNode));
	(*n)->left=NULL;
	(*n)->right=NULL;
	m->n=*n;
	m->next=NULL;
	(*Rear)->next=m;
	(*Rear)=m;
}

//出队
treeNode* ExQueue(QueueNode* front){
	QueueNode* m=front->next;
	front->next=m->next;
	return m->n;
}

//判空
int IsEmptyQueue(QueueNode* Rear,QueueNode* front){
	return Rear==front?1:0;
}



//生成二叉树(层序)
void LevelInput(treeNode* tree){
	//实例化队列
	QueueNode* Queue;
	QueueNode* Rear;
	char a[50];
	int i=0;
	//头尾指针指向头结点
	Queue=Rear=(QueueNode*)malloc(sizeof(QueueNode));
	gets(a);
	//根结点入队
	tree->data=a[i++]-48;
	DeQueue(&Rear,&tree);
	if(Queue->next==NULL){
		//空队列
		Queue->next=Rear;
	}
	while(i!=strlen(a)){
		//上一个结点出队
		treeNode* r=ExQueue(Queue);
		//申请结点
		treeNode* mleft=(treeNode*)malloc(sizeof(treeNode));
		treeNode* mright=(treeNode*)malloc(sizeof(treeNode));
		//左结点操作
		if(a[i]!='#'){
			mleft->data=a[i++]-48;
			//结点拼接
			r->left=mleft;
			//mleft结点入队
			DeQueue(&Rear,&mleft);
			if(Queue->next==NULL){
				//空队列
				Queue->next=Rear;
			}
		}
		else{
			r->left=NULL;
			i++;
		}

		if(i==strlen(a)){
			continue;
		}

		//右结点操作
		if(a[i]!='#'){
			mright->data=a[i++]-48;
			//结点拼接
			r->right=mright;
			//mright结点入队
			DeQueue(&Rear,&mright);
			if(Queue->next==NULL){
				//空队列
				Queue->next=Rear;
			}
		}
		else{
			r->right=NULL;
			i++;
		}
	}
}
//生成二叉树(先序)
treeNode* PreInput(){
    treeNode* temp;
    while(*p==' ')p++;//去掉空格
    if(*p=='#'){
        p++;
		return NULL;
    }
    if(*p!='\0'){
        temp = (treeNode *)malloc(sizeof(treeNode));
        temp->data=*p++-48;
        temp->left=PreInput();
        temp->right=PreInput();
	}
	return temp;
	
}

void test1(){
	//先序
	treeNode * head;
	char str[50];p=str;
	gets(str);
    if(*p!='\0'&&*p!=' '&&*p!='#'){
		head=(treeNode *)malloc(sizeof(treeNode));
		head->data=*p++-48;
        head->left=PreInput();
        head->right=PreInput();
	}
	printf("\n");
	LevelOrder(head);
}
void test2()
{
	//层序
	treeNode* tree;
	
	tree=(treeNode*)malloc(sizeof(treeNode));
	LevelInput(tree);
	LevelOrder(tree);
	printf("\n");
}