二叉树-链表存储结构及其简单算法

适用于层次结构的数据（大部分算法用递归思想）

#include <stdio.h>
#define Max 100
结构体
typedef struct TNode{
	int data;
	struct Node * lchild;//左孩子结点
	struct Node * rchild;//右孩子节点
}TNode; 
//先序遍历(/根结点->左孩子->右孩子)
void preTrave(TNode* node){
	if(node!=NULL){
			printf("%d",node->data);
			preTrave(node->lchild);
			preTrave(node->rchild);
	}
}
//中序遍历(左孩子->根结点->右孩子)
void midTrave(TNode* node){
	if(node!=NULL){
		midTrave(node->lchild);
		printf("%d",node->data);
		midTrave(node->rchild);
	}
}
//后序遍历(左孩子->右孩子->根结点)
void lateTrave(TNode * node){
	if(node!=NULL){
		lateTrave(node->lchild);
		lateTrave(node->rchild);
		printf("%d",node->data;)
	}
}
//层序遍历(利用顺序(循环)队列的特性)
void cTrave(TNode *node){
		TNode * que[Max];//存放树结点
		int front,rear;
		front = rear = 0;//队列初始化
		TNode * s;
		if(node!=NULL){
			rear = (rear + 1)%Max;
			que[rear] = node;//根结点入队
			while(rear != front){//如果队不空
				front = (front+1) %Max;
				s = que[front];//根结点出队
				print("%d",s->data);
				if(s->lchild!=NULL){//如果左孩子不为空
					rear = (rear + 1)%Max;
					que[rear] = s->lchild;//左孩子结点入队
				}
				if(s->rchild!=NULL){//如果右孩子不为空
					rear = (rear +1)%Max;
					que[rear] = s->rchild;//右孩子入队
				}
			}
		}
}

//求宽度(利用顺序非循环的队列，增加一个结构体来存储结点指针以及结点所在的层次号)
typedef struct T{
	TNode * node;//结点指针
	int no;//结点所在层次号
}
int getWidth(TNode * node){
	T que[Max];
	int front,rear;//定义一个顺序非循环队列
	front = rear = 0;
	int i,j,n,max,Lno;
	TNode s;
	if(node!=NULL){
		++rear;
		que[rear].node = node;//根结点入队
		que[rear].no = 1;//根结点所在层次为1
		while(front!=rear){//如果队不空
			++front;
			s = que[front].node;//结点出队
			Lno = que[front].no;//关键一步：存储当前结点的层次号
			if(s->lchild!=NULL){//左孩子不空则将左孩子入队
				++rear;
				que[rear].node = s->lchild;
				que[rear].no = Lno+!;//关键一步：根据当前结点层次号计算其孩子结点层次号
			}
			if(s->rchild!=NULL){//如果右孩子不为空则将右孩子入队
				++rear;
				que[rear].node = s->rchild;
				que[rear].no = Lno+!;//关键一步：根据当前结点层次号计算其孩子结点层次号
			}
		}//循环结束，Lno中保存了这棵二叉树中最大的层数
		//以下代码找出含有结点最多的层中的结点数
		max = 0；
		for(i=0;i<=Lno;i++){
			n = 0;
			for(j=1;j<=rear;j++){
				if(que[j].no==i){
					++n;
				}
			}
			if(max<n){
				max = n;
			}
		}
		return max;
	}else{
		return 0;//空树直接返回0
	}
}

//求二叉树深度(递归)
int getDepth(TNode * node){
	int ld;rd;//用于接收左右深度
	if(node!=NULL){
		ld = getDepth(node->lchild);
		rd = getDepth(node->rchild);
		return (ld>rd?ld:rd)+1'
	}else{
		return 0;
	}
}
//求值为key的结点在二叉树中的位置
void getNo(TNode * root,int key,TNode ** node){
	if(root!=NULL){
		if(root->data == key){
			(*node) = root;
		}else{
			getNo(root->lchild,key,node);
			if(node!=NULL){
				getNO(root->rchild,key,node);
			}
		}
	}
}
//二叉树的创立(递归)
TNode * init(){
	int data;
	scanf("%d",&data);
	TNode * node = NULL;
	if(data!=-1){
		node = (TNode*)malloc(sizeof(TNode));
		node->data = data;//给树节点赋值
		root->lchild = init();//创建左孩子
		root->rchild = init();//创建右孩子
	}
	return node;
}
//二叉树的销毁（后序遍历思想）
void destory(TNode * node){
	if(node!=NULL){
		destory(node->lchild);
		destory(node->rchild);
		free(node);//释放结点
	}
}
//二叉排序树的插入(左孩子小右孩子大)
void insertNode(TNode ** node,int key){
	if(node!=NULL){//结点是否为空;不为空的比较大小插入
		if(key<(*node)->data){//比根结点小则在左边
			insertNode((*root)->lchild,key);
		}else{//比根结点大或者相等则在右边
			insetNode((*node)->rchild,key);
		}
	}else{//为空则新建结点
		(*root) = (TNode*)malloc(sizeof(TNode));
		(*root)->data =key;
	}
}
//在二叉排序树中查找某个结点
TNode * findNode(TNode * node,int key){
	if(node!=NULL){
		if(key==node->data){
			return node;
		}else if(key<node->data){
			findNode(node->lchild,key);
		}else{
			findNode(node->rchild,key);
		}
	}else{
		return NULL;
	}
}

//表达式(a-(b+c))*(d/e),编写程序求出该表达式的值（使用后序遍历）