C语言树的简单实现和相关算法

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define maxSize 10
typedef struct BTNode
{
	char data;
	struct BTNode* lchild;
	struct BTNode* rchild;
}BTNode;

void init(BTNode**T)
{
	(*T) = (BTNode*)malloc(sizeof(BTNode));
	(*T)->lchild = NULL;
	(*T)->rchild = NULL;
}


//自己初始化一颗树，用来验证算法的正确性
void createT(BTNode** T)
{
	(*T)->data ='A';
    BTNode* l= (BTNode*)malloc(sizeof(BTNode));
	l->data = 'B';
	l->lchild = NULL;
	l->rchild = NULL;
	(*T)->lchild = l;

	BTNode* l2 = (BTNode*)malloc(sizeof(BTNode));
	l2->data = 'D';
	l2->lchild = NULL;
	l2->rchild = NULL;
	(*T)->lchild->lchild = l2;

	BTNode* l3 = (BTNode*)malloc(sizeof(BTNode));
	l3->data = 'X';
	l3->lchild = NULL;
	l3->rchild = NULL;
	(*T)->lchild->lchild->rchild = l3;

	BTNode* r = (BTNode*)malloc(sizeof(BTNode));
	r->data = 'C';
	r->lchild = NULL;
	r->rchild = NULL;
	(*T)->rchild = r;

	BTNode* r2 = (BTNode*)malloc(sizeof(BTNode));
	r2->data = 'E';
	r2->lchild = NULL;
	r2->rchild = NULL;
	(*T)->rchild->lchild = r2;

	BTNode* r3 = (BTNode*)malloc(sizeof(BTNode));
	r3->data = 'F';
	r3->lchild = NULL;
	r3->rchild = NULL;
	(*T)->rchild->rchild = r3;
}

//层次遍历
void level(BTNode**T)
{
	int front=0, rear=0;
	BTNode* que[maxSize];
	BTNode* q;
	if ((*T) != NULL)
	{
		rear = (rear + 1) % maxSize;  //这里假设队列空间足够
		que[rear] = (*T);
		while (front != rear)
		{
			front = (front + 1) % maxSize;
			q = que[front];
			printf("%c",q->data);
			if (q->lchild!=NULL)
			{
				rear = (rear + 1) % maxSize;  //这里假设队列空间足够
				que[rear] = q->lchild;
			}
			if (q->rchild != NULL)
			{
				rear = (rear + 1) % maxSize;  //这里假设队列空间足够
				que[rear] = q->rchild;
			}
		}
	}
}

//先序遍历
void preorder(BTNode** T)
{
	if ((*T) != NULL)
	{
		printf("%c ",(*T)->data);
		preorder(&(*T)->lchild);
		preorder(&(*T)->rchild);
	}
}

//中序遍历
void inorder(BTNode** T)
{
	if ((*T) != NULL)
	{		
		inorder(&(*T)->lchild);
		printf("%c ", (*T)->data);
		inorder(&(*T)->rchild);
	}
}

//后序遍历
void postorder(BTNode** T)
{
	if ((*T) != NULL)
	{
		postorder(&(*T)->lchild);
		postorder(&(*T)->rchild);
		printf("%c ", (*T)->data);
	}
}

//返回一颗树深度
int getDepth(BTNode** T)
{
	int LD, RD;
	if ((*T) == NULL)
		return 0;
	else
	{
		LD = getDepth(&(*T)->lchild);
		RD = getDepth(&(*T)->rchild);
		return (LD > RD ?LD:RD) + 1;
	}
}

//返回一棵树宽度(思路：层次遍历所有结点，为它们打上层数编号，最后在循环找出宽度)
int getWidth(BTNode** T)
{
	typedef struct St
	{
		int Lno;
		BTNode* T;
	}St;

	int front = 0, rear = 0;
	int Lno = 0,max=0;
	int i, j,n;
	BTNode* q;
	St que[maxSize];
	if ((*T) == NULL)
		return 0;
	else
	{
		++rear;
		que[rear].Lno = 1;
		que[rear].T = (*T);
		while (front != rear)
		{
			++front;
			q = que[front].T;
			Lno = que[front].Lno;
			if (q->lchild != NULL)
			{
				++rear;
				que[rear].Lno = Lno+1;
				que[rear].T = q->lchild;
			}
			if (q->rchild != NULL)
			{
				++rear;
				que[rear].Lno = Lno + 1;
				que[rear].T = q->rchild;
			}
		}
		for (i = 1; i <= Lno; ++i)
		{
			n = 0;
			for (j = 1; j <= rear; ++j)
			{
				if (que[j].Lno == i)
					++n;
			}
			if (max < n)
			  max = n;
		}
		return max;
	}
}

//找到树中值为key的结点位置用q指向它，若找不到q指向NULL
void search(BTNode*T,BTNode**q,char key)  
{
	if (T != NULL)
	{
		if (T->data == key)
			(*q) = T;
		else
		{
			//请注意此处的q，和main函数中调用时q
			search(T->lchild,q,key);
			if ((*q) == NULL)
			search(T->rchild,q,key);
		}
	}
}
int main()
{
	BTNode* T;
	init(&T);
	createT(&T);
	printf("层次遍历：");
	level(&T);
	printf("\n");
	printf("先序遍历：");
	preorder(&T);
	printf("\n");
	printf("中序遍历：");
	inorder(&T);
	printf("\n");
	printf("后序遍历：");
	postorder(&T);
	printf("\n");
	printf("树高度:%d\n",getDepth(&T));
	printf("树宽度:%d\n",getWidth(&T));

	char c = 'X', c2 = 'M';
	BTNode* x = NULL;
	search(T, &x, c);
	if (x!=NULL)
	{
		printf("找到%c\n",x->data);
	}
	else
	{
		printf("未找到%c\n",c);
	}
	x = NULL;
	search(T, &x, c2);
	if (x != NULL)
	{
		printf("找到%c\n", x->data);
	}
	else
	{
		printf("未找到%c\n",c2);
	}
	return 0;
}