二叉树的实现

LqStack.h:

typedef struct stackNode{
	BiNode *value;
	struct stackNode* next;
}*linkStack,stackNode; 
typedef struct lqStack{
	linkStack top;
}lqStack;

void initStack(lqStack *stack);
void push(BiNode *value,lqStack *stack);
BiNode* pop(lqStack *stack);
int isEmpty(lqStack *stack);

LqStack.c:

#include 
#include 
#include "LqStack.h"

初始化栈 
void initStack(lqStack *stack){
	stack->top=NULL;
}
//入栈 
void push(BiNode *value,lqStack *stack){
	stackNode *node=(stackNode*)malloc(sizeof(stackNode));
	node->value=value;
	node->next=stack->top;
	stack->top=node;
}
//出栈 
BiNode* pop(lqStack *stack){
	if(stack->top){
		stackNode *node=stack->top;
		BiNode* value=node->value;
		stack->top=node->next;
		free(node);
		return value;
	}else{
		printf("链栈下溢操作！");
		return ' ';
	}
}
//判断链栈是否为空 
int isEmpty(lqStack *stack){
	return stack->top?0:1;
}

SqQueue.h:

#include "SqBiTree.h" 
#ifndef _SQQUEUE_H_ 
#define _SQQUEUE_H_
typedef struct {
	BiNode *base;
	int front;
	int erer;
	int size;
}SqQueue;
#endif

void initSqQueue(SqQueue *queue,int size);
void enqueue(SqQueue *queue,BiNode* node);
BiNode dequeue(SqQueue *queue);
int getSize(SqQueue *queue);

SqQueue.c:

#include 
#include 
#include "SqQueue.h"

void initSqQueue(SqQueue *queue,int size){
	queue->base=(BiNode*)malloc(sizeof(BiNode)*size);
	queue->erer=0;
	queue->front=0;
	queue->size=size;
}
//入队 
void enqueue(SqQueue *queue,BiNode* value){
	if(((queue->erer+1)%queue->size)==queue->front){
		printf("队满操作\n");
	}else if(value!=NULL){
		queue->base[queue->erer%queue->size]=*value;
		queue->erer=++queue->erer%queue->size;
	}
}
//出队 
BiNode dequeue(SqQueue *queue){
	if(queue->front!=queue->erer){
		BiNode deNode=(queue->base)[queue->front];
		queue->front=++queue->front%queue->size;
		return deNode;
	}else{
		printf("队空操作！\n");
	}
}

int getSize(SqQueue *queue){
	return 	(queue->erer-queue->front+queue->size)%queue->size;
}

SqBiTree.h:

#ifndef _SQBITREE_H_ 
#define _SQBITREE_H_
typedef struct BiNode{
	char value;
	struct BiNode *LTree;
	struct BiNode *RiTree;
}BiNode,*BiTree;
#endif

void init(BiTree *tree);
BiNode* createNode(char value);
void pushValue(BiTree *tree);
void DlrTraverse(BiTree tree);
void LdrTraverse(BiTree tree);
void  LdrTraverseByStack(BiTree tree);
void  DlrTraverseByStack(BiTree tree);
void LrdTraverseByStack(BiTree tree);
void  levelTraverse(BiTree tree); 

SqBiTree.c:

#include 
#include 
#include "SqBiTree.h" 
#include "LqStack.h"
#include "SqQueue.h"

void init(BiTree *tree){
	*tree=NULL;
}
//创造一个节点 
BiNode* createNode(char value){
	BiNode *newNode=(BiNode*)malloc(sizeof(BiNode));
	newNode->LTree=NULL;
	newNode->RiTree=NULL;
	newNode->value=value;
	return newNode;
}
void pushValue(BiTree *tree){
	char value; 
	scanf("%c", &value);
	if(value=='#') *tree=NULL;
	else{
		*tree=createNode(value);
		pushValue(&((*tree)->LTree));
		pushValue(&((*tree)->RiTree));
	}
	return;
}

//递归的前序遍历 
void DlrTraverse(BiTree tree){
	if(tree!=NULL){
		printf("%c ",tree->value);
		DlrTraverse(tree->LTree);
		DlrTraverse(tree->RiTree);
	}
}
//递归的中序遍历 
void LdrTraverse(BiTree tree){
	if(tree!=NULL){
		LdrTraverse(tree->LTree);
		printf("%c ",tree->value); 
		LdrTraverse(tree->RiTree);
	}
}
//递归的后序遍历 
void LrdTraverse(BiTree tree){
	if(tree!=NULL){
		LrdTraverse(tree->LTree);
		LrdTraverse(tree->RiTree);
		printf("%c ",tree->value); 
	}
}
//非递归的中序遍历
void  LdrTraverseByStack(BiTree tree){
	BiTree p;
	lqStack stack;
	initStack(&stack);
	p=tree;
	while(p||!isEmpty(&stack)){
		if(p){
			push(p,&stack);
			p=p->LTree; 
		}else{
			BiNode *node=pop(&stack);
			printf("%c ",node->value);
			p=node->RiTree;
		}
	}
}
//非递归的先序遍历
void  DlrTraverseByStack(BiTree tree){
	if(tree==NULL) return;
	lqStack stack;
	initStack(&stack);
	push(tree,&stack);
	while(!isEmpty(&stack)){
		BiNode *node=pop(&stack);
		printf("%c ",node->value);
		if(node->RiTree!=NULL){
			push(node->RiTree,&stack);
		}
		if(node->LTree!=NULL){
			push(node->LTree,&stack);
		}	
	}
}
//非递归的后序遍历
void LrdTraverseByStack(BiTree tree){
	if(tree==NULL) return;
	lqStack stack;
	initStack(&stack);
	lqStack stack1;
	initStack(&stack1);
	push(tree,&stack);
	
	while(!isEmpty(&stack)){
		BiNode *node=pop(&stack);
		push(node,&stack1);
		if(node->LTree)
			push(node->LTree,&stack);
		if(node->RiTree)
			push(node->RiTree,&stack);
	}
	
	while(!isEmpty(&stack1)){
		printf("%c ",pop(&stack1)->value); 
	}	
}
//二叉树的层次遍历
void  levelTraverse(BiTree tree){
	BiNode *p;
	SqQueue queue;
	initSqQueue(&queue,20);
	p=tree;
	enqueue(&queue,p);
	while(getSize(&queue)!=0){  //这里有点问题 
		*p=dequeue(&queue);
		if(p!=NULL){
			printf("%c ",p->value);
			enqueue(&queue,p->LTree);
			enqueue(&queue,p->RiTree);
		}
	}
} 

//复制二叉树
void copyTree(BiTree tree,BiTree *newtree){  
	if(tree==NULL){ //空树停止拷贝 
		newtree=NULL;
	}else{
		*newtree=createNode(tree->value);
		copyTree(tree->LTree,&((*newtree)->LTree));
		copyTree(tree->RiTree,&((*newtree)->RiTree));
	}
	
}

//计算二叉树的深度
int Depth(BiTree tree){
	if(tree==NULL) return 0;
	int m,n;
	m=Depth(tree->LTree);
	n=Depth(tree->RiTree);
	if(m>n) return (m+1);
	 else return (n+1);
} 

//计算二叉树的结点总数
int nodeCount(BiTree tree){
	if(tree==NULL) return 0;
	else
		return nodeCount(tree->LTree)+nodeCount(tree->RiTree)+1;
} 

//计算二叉树的叶子结点 
int  LeadCount(BiTree tree){
	if(tree==NULL) return 0;
	if(tree->LTree==NULL&&tree->RiTree==NULL) return 1;
	else
		return LeadCount(tree->LTree)+LeadCount(tree->RiTree);
} 

main.c:

#include 
#include 
#include "SqBiTree.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */
//
int main(int argc, char *argv[]) {
	BiTree tree;
	init(&tree);
	pushValue(&tree);
	printf("树的深度：\n");
	printf("%d",Depth(tree));
	printf("\n");
	printf("树的结点总个数：\n");
	printf("%d",nodeCount(tree));
	printf("\n");
	printf("树的叶子结点个数：\n");
	printf("%d",LeadCount(tree));
	printf("\n");
	printf("树的前序遍历：\n");
	DlrTraverse(tree);
	printf("\n");
	printf("树的中序遍历：\n");
	LdrTraverse(tree);
	printf("\n");
	printf("树的后序遍历：\n");
	LrdTraverse(tree);
	printf("\n");
	printf("树的非递归前序遍历：\n");
	DlrTraverseByStack(tree);
	printf("\n");
	printf("树的非递归中序遍历：\n");
	LdrTraverseByStack(tree);
	printf("\n");
	printf("树的非递归后序遍历：\n");
	LrdTraverseByStack(tree);
	printf("\n");
	printf("复制的树的前序遍历和中序遍历：\n");
	BiTree newtree=NULL;
	copyTree(tree,&newtree);
	DlrTraverse(newtree);
	printf("\n");
	LdrTraverse(newtree);
	printf("\n");
	printf("树层次遍历：\n");
	levelTraverse(tree);  //这个函数会将原树变化 
	printf("\n");
	printf("=============\n");
	
	system("pause");
	return 0;
}

输出结果：

图解相关操作：

树的前序遍历： DlrTraverse：

树的中序遍历：LdrTraverse：

后序遍历：LrdTraverse：

树的非递归前序遍历：DlrTraverseByStack:

树的非递归中序遍历：LdrTraverseByStack:

树的非递归后序遍历：LrdTraverseByStack:

复制的树：copyTree:

树层次遍历：levelTraverse：

树的深度：Depth：

树的结点总个数：nodeCount：

树的叶子结点个数：LeadCount：