BinaryTree

#include<stdio.h>
#include<stdlib.h>
#ifndef _BITNODE_H_
#define _BITNODE_H_
typedef struct BiTNode{
	int data;
	BiTNode* lchild;
	BiTNode* rchild;
}*BiTree;
#endif

#define STACKSIZE 10
#define STACKINCREMENT 5
#include"BiTNode.h"
struct SqStack{
	BiTree* top;
	BiTree* base;
	int stacksize;
};
void InitStack(SqStack& s){
	s.base=(BiTree *)malloc(sizeof(BiTree)*STACKSIZE);
	if(!s.base){
		printf("分配内存失败！");
		exit(1);
	}
	s.top=s.base;
	s.stacksize=STACKSIZE;
}
void DestoryStack(SqStack& s){
	free(s.base);
	s.base==NULL;
	s.top=NULL;
	s.stacksize=0;
}
void ClearStack(SqStack& s){
	s.top=s.base;
}
bool StackEmpty(SqStack s){
	return s.base==s.top;
}
bool GetTop(SqStack s,BiTree &p){
	if(StackEmpty(s)){
		p=NULL;
		printf("栈为空");
		return false;
	}
	p= *(s.top-1);
	return true;
}
void Push(SqStack &s,BiTree p){
	if(s.top-s.base>=STACKSIZE){
		BiTree* newbase=(BiTree *)realloc(s.base,sizeof(BiTree)*(STACKSIZE+STACKINCREMENT));
		if(!newbase){
			printf("内存分配失败\n");
			exit(1);
		}
		s.base=newbase;
		s.stacksize+=STACKINCREMENT;
	}
	*s.top++=p;
}
void Pop(SqStack &s,BiTree &p){
	if(StackEmpty(s)){
		p=NULL;
		printf("栈为空");
		return;
	}
	p=*--s.top;
}

#include"BiTNode.h"
typedef struct QNode{
	BiTree val;
	QNode* next;
}*QueuePtr;
struct LinkQueue{
	QueuePtr front;
	QueuePtr rear;
};
void InitQueue(LinkQueue &q){
	q.front=(QNode*)malloc(sizeof(QNode));
	if(!q.front){
		printf("内存分配失败!\n");
		return;
	}
	q.front->next=NULL;
	q.rear=q.front;
}
void DestroyQueue(LinkQueue &q){
	while(q.front){
		q.rear=q.front->next;
		free(q.front);
		q.front=q.rear;
	}
}
void ClearQueue(LinkQueue &q){
	q.rear=q.front;
	QNode *p=q.front->next;
	q.front->next=NULL;
	QNode *t;
	while(p){
		t=p->next;
		free(p);
		p=t;
	}
}
bool QueueEmpty(LinkQueue q){
	return q.front==q.rear;
}
int QueueLength(LinkQueue q){
	int i=0;
	QNode *p=q.front;
	while(p!=q.rear){
		i++;
		p=p->next;
	}
	return i;
}
void EnQueue(LinkQueue &q,BiTree e){
	QNode* p=(QNode*)malloc(sizeof(QNode));
	if(!p){
		printf("内存分配失败\n");
		return;
	}
	p->val=e;
	p->next=NULL;
	q.rear->next=p;
	q.rear=p;
}
void DeQueue(LinkQueue &q,BiTree &e){
	QNode* p=q.front->next;
	e=p->val;
	q.front->next=p->next;
	p->next=NULL;
	if(p==q.rear)
		q.rear=q.front;
	free(p);
}

#define Nil 0
#include"BiTNode.h"
#include"QueueLink.h"
#include"Stack.h"
void InitBiTree(BiTree &T){
	T=NULL;
}
void DestroyBiTree(BiTree &T){
	if(T){
		if(T->lchild)
			DestroyBiTree(T->lchild);
		if(T->rchild)
			DestroyBiTree(T->rchild);
		free(T);
		T=NULL;
	}
}
void CreateBiTree(BiTree &T){
	int temp;
	printf("请输入结点的值\n");
	scanf("%d",&temp);
	if(temp==Nil)
		T=NULL;
	else{
		T=(BiTNode*)malloc(sizeof(BiTNode));
		if(!T){
			printf("内存分配失败!\n");
			exit(0);
		}
		T->data=temp;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
}
bool BiTreeEmpty(BiTree T){
	return T==NULL;
}
int BiTreeDepth(BiTree T){
	int i,j;
	if(!T) return 0;
	if(T->lchild) i=BiTreeDepth(T->lchild);
	else i=0;
	if(T->rchild) j=BiTreeDepth(T->rchild);
	else j=0;
	return i>j?(i+1):(j+1);
}
int Root(BiTree T){
	if(T==NULL)
		return Nil;
	else return T->data;
}
int Parent(BiTree T,int e){
	if(T->data==e){
		printf("根节点不存在父节点\n");
		return Nil;
	}
	BiTree p;
	LinkQueue q;
	InitQueue(q);
	EnQueue(q,T);
	while(!QueueEmpty(q)){
		DeQueue(q,p);
		if(p->lchild){
			if(p->lchild->data==e)
				return p->data;
			EnQueue(q,p->lchild);
		}
		if(p->rchild){
			if(p->rchild->data==e)
				return p->data;
			EnQueue(q,p->rchild);
		}
	}
	return Nil;
}
BiTree Point(BiTree T,int e){
	BiTree p;
	LinkQueue q;
	InitQueue(q);
	EnQueue(q,T);
	while(!QueueEmpty(q)){
		DeQueue(q,p);
		if(p->data==e) return p;
		if(p->lchild) EnQueue(q,p->lchild);
		if(p->rchild) EnQueue(q,p->rchild);
	}
	return NULL;
}
int LeftChild(BiTree T,int e){
	BiTree p=Point(T,e);
	if(p&&p->lchild)
		return p->lchild->data;
	return Nil;
}
void PreOrderTraverse(BiTree T){
	SqStack s;
	InitStack(s);
	while(T || !StackEmpty(s)){
		if(T){
			Push(s,T);
			printf("%3d",T->data);
			T=T->lchild;
		}
		else{
			Pop(s,T);
			T=T->rchild;
		}
	}
	DestoryStack(s);
}
void InOrderTraverse(BiTree T){
	SqStack s;
	InitStack(s);
	while(T || !StackEmpty(s)){
		if(T){
			Push(s,T);
			T=T->lchild;
		}
		else{
			Pop(s,T);
			printf("%3d",T->data);
			T=T->rchild;
		}
	}
	DestoryStack(s);
}
void InOrderTraverseAgain(BiTree T){
	SqStack s;
	InitStack(s);
	Push(s,T);
	BiTNode* p;
	while(!StackEmpty(s)){
		while(GetTop(s,p)&&p){
			Push(s,p->lchild);
			p=p->lchild;
		}
		Pop(s,p);
		if(!StackEmpty(s)){
			Pop(s,p);
			printf("%3d",p->data);
			p=p->rchild;
			Push(s,p);
		}
	}
	DestoryStack(s);
}
void PostOrderTraverse(BiTree T){//双栈法
	SqStack s1,s2;
	InitStack(s1);
	InitStack(s2);
	Push(s1,T);
	BiTree p;
	while(!StackEmpty(s1)){
		Pop(s1,p);
		Push(s2,p);
		if(p->lchild)
			Push(s1,p->lchild);
		if(p->rchild)
			Push(s1,p->rchild);
	}
	while(!StackEmpty(s2)){
		Pop(s2,p);
		printf("%3d",p->data);
	}
}
void PostOrderTraverseAgain(BiTree T){//标记有孩子节点是否被访问过
	SqStack s;
	InitStack(s);
	BiTree pre=NULL;
	BiTree p=T;
	while(p||!StackEmpty(s)){
		while(p){
			Push(s,p);
			p=p->lchild;
		}
		GetTop(s,p);
		// 当前节点的右孩子如果为空或者已经被访问，则访问当前节点   
		if(p->rchild==NULL||p->rchild==pre){
			printf("%3d",p->data);
			pre=p;
			Pop(s,p);
			p=NULL;
		}
		else p=p->rchild;
	}
}
void main(){
	int temp;
	BiTree T;
	CreateBiTree(T);
	printf("树的深度为%3d\n",BiTreeDepth(T));
	printf("求其父节点：请输入节点的值\n");
	scanf("%d",&temp);
	int parent=Parent(T,temp);
	if(parent)
		printf("父节点的值为%3d\n",parent);
	else printf("父节点不存在\n");
	printf("求其子节点:请输入父节点的值\n");
	scanf("%d",&temp);
	int child=LeftChild(T,temp);
	if(child)
		printf("子节点为%3d\n",child);
	else printf("没有子节点\n");
	PreOrderTraverse(T);
	printf("\n");
	InOrderTraverse(T);
	printf("\n");
	InOrderTraverseAgain(T);

	PostOrderTraverse(T);
	PostOrderTraverseAgain(T);
}