二叉树链式结构C语言实现

#include "string.h"
#include "stdio.h"    
#include "stdlib.h"   

#include "math.h"  
#include "time.h"


#define maxlen 100 /* 存储空间初始分配量 */



/* 用于构造二叉树********************************** */
int index1 = 1;
typedef char String[24]; /*  0号单元存放串的长度 */
String str;


/* ************************************************ */


typedef struct Node  /* 结点结构 */
{
	char data;		/* 结点数据 */
	struct Node* lchild, * rchild; /* 左右孩子指针 */
}Node, * Tree;




int create_tree(Tree* T)
{
	char ch;
	ch = str[index1];
	index1++;
	if (ch == '#')
	{
		*T = NULL;
		return 0;
	}
	else
	{
		*T = (Tree)malloc(sizeof(Node));
		(*T)->data = ch;
		create_tree(&((*T)->lchild));
		create_tree(&((*T)->rchild));
	}
}

int Strget(String T, char* chars)
{
	int i;
	if (strlen(chars) > maxlen)
		return 0;
	else
	{
		T[0] = strlen(chars);
		for (i = 1;i <= T[0];i++)
			T[i] = *(chars + i - 1);
		return 1;
	}
}

int pre_see(Tree T)
{
	if (T == NULL)
	{
		return 0;
	}
	printf("%c", T->data);
	pre_see(T->lchild);
	pre_see(T->rchild);
	return 1;
}

int in_see(Tree T)
{
	if (T == NULL)
		return;
	in_see(T->lchild); /* 中序遍历左子树 */
	printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
	in_see(T->rchild); /* 最后中序遍历右子树 */
}

int post_see(Tree T)
{
	if (T == NULL)
		return;
	post_see(T->lchild); 
	post_see(T->rchild); /* 最后中序遍历右子树 */
    printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
}

int destory_tree(Tree* T)
{
	if ((*T))
	{
		if ((*T)->lchild) /* 有左孩子 */
			destory_tree(&(*T)->lchild); /* 销毁左孩子子树 */
		if ((*T)->rchild) /* 有右孩子 */
			destory_tree(&(*T)->rchild); /* 销毁右孩子子树 */
		free(*T); /* 释放根结点 */
		*T = NULL; /* 空指针赋0 */
	}
}

int get_depth(Tree T)
{
	int i, j;
	if (!T)
	{
		return 0;
	}
	if (T->lchild)
	{
		i = get_depth(T->lchild);
	}
	else
	{
		i = 0;
	}
	if (T->rchild)
	{
		j = get_depth(T->rchild);
	}
	else
	{
		j = 0;
	}
	return i > j ? i+1 : j+1;

}

int inittree(Tree* T)
{
	*T = NULL;
	return 0;
}

int main()
{
	int i;
	Tree T;
	int depth;
	inittree(&T);
	Strget(str, "ABDH#K###E##CFI###G#J##");
	create_tree(&T);
	printf("\n前序遍历二叉树:");
	pre_see(T);
	printf("\n中序遍历二叉树:");
	in_see(T);

	depth = get_depth(T);
	printf("\n%d\n", depth);

	destory_tree(&T);
	depth = get_depth(T);
	printf("\n%d\n", depth);
}

下面是另外一种写法，与上面的不同是，get_tree函数将树的头结点直接作为实参。

get_tree1实测失败，还不知道为什么。

#include "string.h"
#include "stdio.h"    
#include "stdlib.h"   

#include "math.h"  
#include "time.h"
#define MAXSIZE 100 /* 存储空间初始分配量 */

typedef char String[24]; /*  0号单元存放串的长度 */
String str;
int index = 1;

typedef struct Node  /* 结点结构 */
{
	char data;		/* 结点数据 */
	struct Node* lchild, * rchild; /* 左右孩子指针 */
}Node;


/* 构造空二叉树T */
int initTree(Node *T)
{
	T = (Node*)malloc(sizeof(Node));
	return 1;
}

int stringget(String T, char* chars)
{
	int i;
	if (strlen(chars) > MAXSIZE)
		return 0;
	else
	{
		T[0] = strlen(chars);
		for (i = 1;i <= T[0];i++)
			T[i] = *(chars + i - 1);
		return 1;
	}
}

Node* getTree()
{
	char ch;
	ch = str[index++];
	if (ch == '#')
	{
		return NULL;
	}
	else
	{
		Node *T = (Node*)malloc(sizeof(Node));
		T->data = ch;
		T->lchild = getTree();
		T->rchild = getTree();
		return T;
	}
}



int getTree1(Node* T)
{
	char ch;
	ch = str[index];
	
	index++;
	if (ch == '#')
	{
		/*
		T->lchild = NULL;
		T->rchild = NULL;
		*/
		//free(T->lchild);
		T->lchild = NULL;
		T->rchild = NULL;
		T = NULL;
		free(T);
		
		
		return 0;
	}
	else
	{
		T->data = ch;
		if (T->lchild != NULL)
		{
			Node* Q;
			Q = (Node*)malloc(sizeof(Node));
			T->lchild = Q;
			getTree2(T->lchild);

		}
		if (T->rchild != NULL)
		{
			
			Node* J;
			J = (Node*)malloc(sizeof(Node));
			T->rchild = J;
			getTree2(T->rchild);
		}
		
	}
	return 1;
	
}


int TreeDepth(Node *T)
{
	int i, j;
	if (!T)
		return 0;
	if (T->lchild)
		i = TreeDepth(T->lchild);
	else
		i = 0;
	if (T->rchild)
		j = TreeDepth(T->rchild);
	else
		j = 0;
	return i > j ? i + 1 : j + 1;
}


int Pre_Traverse(Node* T)
{
	if (T==NULL)
	{
		
		return 0;
	}

	printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
	Pre_Traverse(T->lchild); /* 再先序遍历左子树 */
	Pre_Traverse(T->rchild); /* 最后先序遍历右子树 */
	return 1;
}

/* 初始条件: 二叉树T存在 */
/* 操作结果: 中序递归遍历T */
int In_Traverse(Node* T)
{
	if (T== NULL)
		return 0;
	In_Traverse(T->lchild); /* 中序遍历左子树 */
	printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
	In_Traverse(T->rchild); /* 最后中序遍历右子树 */
	return 1;
}

/* 初始条件: 二叉树T存在 */
/* 操作结果: 后序递归遍历T */
void Post_Traverse(Node* T)
{
	if (T== NULL)
		return;
	Post_Traverse(T->lchild); /* 先后序遍历左子树  */
	Post_Traverse(T->rchild); /* 再后序遍历右子树  */
	printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
}

Node *destory1(Node* T)
{
	
	if (T)
	{
		if (T->lchild)
		{
			destory1(T->lchild);
		}
		if (T->rchild)
		{
			destory1(T->rchild);
		}
		
		T->lchild = NULL;
		T->rchild = NULL;
		T = NULL;
		free(T);
	}
	return T;
	
}

Node* destory(Node* T)
{
	Node* Q;
	Q = destory1(T);
	Pre_Traverse(Q);
	Q = NULL;
	free(Q);
	return Q;
}


int main()
{
	Node *T;
	int depth;
	T = (Node*)malloc(sizeof(Node));
	stringget(str, "ABDH#K###E##CFI###G#J##");
	T = getTree(T);

	//getTree1(T);
	printf("\n前序遍历二叉树:");
	Pre_Traverse(T);
	printf("\n中序遍历二叉树:");
	In_Traverse(T);
	printf("\n后序遍历二叉树:");
	Post_Traverse(T);

	depth = TreeDepth(T);
	printf("\n%d\n", depth);



	

}