通用树的实现

单链表

#ifndef __LINKLIST_H__
#define __LINKLIST_H__
typedef void LinkList;//链表的数据封装 
typedef struct _tag_LinkListNode LinkListNode;//指针域的重命名，指针域的定义最重要，在链表中遍历节点的时候就是利用指针域的移动，
//他既包含了当前节点的地址信息，由于它是结构体，所以又包含了下一个节点的地址信息； 
struct  _tag_LinkListNode{//指针域结构体的具体定义 
	LinkListNode* next;//用指针域定义指针域 
};

LinkList* LinkList_Create();

void LinkList_Destroy(LinkList* list);

void LinkList_Clear(LinkList* list);

int LinkList_Length(LinkList* list);

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);

LinkListNode* LinkList_Delete(LinkList* list, int pos);

LinkListNode* LinkList_Get(LinkList* list, int pos);

#endif

#include <stdio.h>
#include <malloc.h>
#include "LinkList.h"

typedef struct _tag_LinkList{//表头结构体 
	LinkListNode header;//表头指针，header是一个结构体，成员是一个指针 
	int length;//链表长度成员,在这里没有直接定义链表节点成员 
}TLinkList;

LinkList* LinkList_Create()
{
	TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));//动态分配空间，刚刚创建的时候只需要分配表头的空间 
	if (ret != NULL){
		ret->length = 0;//对长度初始化为0 
		ret->header.next = NULL; //对表头指针成员初始化为NULL 
	}
	return ret;//返回表头地址 
}


void LinkList_Destroy(LinkList* list)
{
	free(list);
}

void LinkList_Clear(LinkList* list)
{
	TLinkList* sList = (TLinkList*)list;
	if (sList != NULL){//让表头恢复到刚刚创建的状态 
		sList->length = 0;
		sList->header.next = NULL;
	}
}

int LinkList_Length(LinkList* list)
{
	TLinkList* sList = (TLinkList*)list;//除了destroy函数，其余函数基本上都会用到强制类型转换 
	int ret = -1;
	if (sList != NULL){//如果合法则返回当前长度 
		ret = sList->length;
	}
	return ret;
}

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)
{
	TLinkList* sList = (TLinkList*)list;//强制类型转换 
	int ret = (sList != NULL) && (pos >= 0) && (node != NULL);//合法性检测 
	int i = 0;

	if (ret){
		LinkListNode* current = (LinkListNode*)sList;//将表头指针强制转换为当前指针。结构体指针指向结构体中的第一个成员 
		for (i = 0; (i < pos) && (current->next != NULL); i++){//移动当前指针，使得当前指针的指针域指向的元素的位置即要插入新元素的位置 
			current = current->next;
		}
		node->next = current->next;//将当前指针指向的下一个元素的位置赋值给要插入的节点的指针域 
		current->next = node;//将要插入的节点的位置赋值给当前指针的指针域 
		sList->length++;//更新长度 
	}
	return ret;//成功插入返回1否则返回0 
}

LinkListNode* LinkList_Get(LinkList* list, int pos)
{
	TLinkList* sList = (TLinkList*)list;
	LinkListNode* ret = NULL;
	int i = 0;
	if ((sList != NULL) && (pos >= 0) && (pos < sList->length)){//合法性检测 
		LinkListNode* current = (LinkListNode*)sList;//将表头指针赋值为当前指针 
		for (i = 0; i < pos; i++){//移动当前指针使得它的指针域指向要获取的节点 
			current = current->next;
		}
		ret = current->next;//返回获取的节点 
	}
	return ret;//返回的是结构体的指针，即结构体的地址 
}

LinkListNode* LinkList_Delete(LinkList* list, int pos)
{
	TLinkList* sList = (TLinkList*)list;
	LinkListNode* ret = NULL;
	int i = 0;
	if ((sList != NULL) && (pos >= 0) && (pos < sList->length)){
		LinkListNode* current = (LinkListNode*)sList;
		for (i = 0; i < pos; i++){
			current = current->next;
		}
		ret = current->next;
		current->next = ret->next;//将当前指针的指针域指向要删除的节点的指针域，即可删除节点 
		sList->length--;//更新长度成员 
	}
	return ret;
}

通用树

#ifndef _GTREE_H_
#define _GTREE_H_

typedef void GTree;//树数据封装
typedef void GTreeData;//要存入树节点中的数据
typedef void (GTree_Printf)(GTreeData*);//重命名一个函数类型GTree_Printf

GTree* GTree_Create();

void GTree_Destroy(GTree* tree);

void GTree_Clear(GTree* tree);

int GTree_Insert(GTree* tree, GTreeData* data, int pPos);

GTreeData* GTree_Delete(GTree* tree, int pos);

GTreeData* GTree_Get(GTree* tree, int pos);

GTreeData* GTree_Root(GTree* tree);

int GTree_Height(GTree* tree);

int GTree_Count(GTree* tree);

int GTree_Degree(GTree* tree);

void GTree_Display(GTree* tree, GTree_Printf* pFunc, int gap, char div);

#endif

#include "LinkList.h"
#include "GTree.h"
#include <stdio.h>
#include <malloc.h>

typedef struct _tag_GTreeNode GTreeNode;//树节点结构体定义

struct _tag_GTreeNode{
	GTreeData* data;//存放要插入节点的数据的指针，插入的是数据，而不是节点，对于节点的分配有通用树的函数来在底层实现
	GTreeNode* parent;//指向双亲节点的指针
	LinkList* child;//指向孩子的指针链表（链表里的数据元素存放的是孩子的物理地址）
};

typedef struct _tag_TLNode TLNode;//组织链表节点结构体定义

struct _tag_TLNode{
	LinkListNode header;//存放树节点在组织链表中的位置
	GTreeNode* node;//指向树节点
};




//format表示她的孩子相对于他缩进多少个字符
static void recursive_display(GTreeNode* node, GTree_Printf* pFunc,int format, int gap, char div_symbol)
{
	int i = 0;

	if (node != NULL){
		for(i = 0; i < format;i++){
			printf("%c",div_symbol);
		}
		pFunc(node->data);//回调函数，利用了函数指针
		printf("\n");
		for (i = 0; i < LinkList_Length(node->child); i++){
			TLNode* trNode = (TLNode*)LinkList_Get(node->child,i);//找到该节点的孩子依次打印出来，
																//每次从链表获得的节点的node成员才是真正的树节点
			recursive_display(trNode->node, pFunc,format + gap,gap,div_symbol);//递归调用显示函数，使得每一个孩子
																		//相对他的父亲以gap个div_symbol字符缩进
		}
	}
}




static void recursive_delete(LinkList* list,GTreeNode* node)
{
	if ((list != NULL) && (node != NULL)){//合法性检测
		GTreeNode* parent = node->parent;//获取要删除节点的父节点，为了下一步利用该父节点将其从父节点的child链表删除
		int index = -1;
		int i = 0;
		for (i = 0; i < LinkList_Length(list); i++){//从组织链表中寻找要删除的节点
			TLNode* trNode = (TLNode*)LinkList_Get(list,i);
			if (trNode->node == node){
				LinkList_Delete(list, i);
				free(trNode);
				index = i;//用来检查看从组织链表返回来的位置是否合法，在下一步从child链表中删除节点用到
				break;
			}
		}
		if (index >= 0){//表示从组织链表找到合法的节点


			if (parent != NULL){//将节点从其父节点的child链表中删除
				for (i = 0; i < LinkList_Length(parent->child);i++){
					TLNode* trNode = (TLNode*)LinkList_Get(parent->child, i);
					if (trNode->node == node){
						LinkList_Delete(parent->child, i);
						free(trNode);//删除一个节点以后，要记得free
						break;
					}
				}
			}


			while (LinkList_Length(node->child) > 0){//将以该节点开头的子树递归删除
				TLNode* trNode = (TLNode*)LinkList_Get(node->child, 0);
				recursive_delete(list, trNode->node);
			}
			LinkList_Destroy(node->child);//将该节点的child链表销毁
			free(node);//释放该节点的空间
		}
		
	}
}



static int recursive_height(GTreeNode* node)
{
	int ret = 0;
	if (node != NULL){
		int subHeight = 0;//子树的高度
		int i = 0;
		for (i = 0; i < LinkList_Length(node->child);i++){//依次去遍历每一个孩子(先求子树)
			TLNode* trNode = (TLNode*)LinkList_Get(node->child, i);//取出子树的根节点
			subHeight = recursive_height(trNode->node);
			if (ret < subHeight){
				ret = subHeight;
			}
		}
		ret = ret + 1;//最后的结果要加上根节点本身
	}
	return ret;
}



static int recursive_degree(GTreeNode* node)
{
	int ret = 0;
	if (node != NULL){

		int subDegree = 0;
		int i = 0;

		ret = LinkList_Length(node->child);//先求根节点的度
		for (i = 0; i < LinkList_Length(node->child);i++){//再递归依次求出各个子节点的度
			TLNode* trNode = (TLNode*)LinkList_Get(node->child, i);
			subDegree = recursive_degree(trNode->node);

			if (ret < subDegree){//和height一样，一边求以便判断与当前度数大小
				ret = subDegree;
			}
		}
	}
	return ret;
	
}



GTree* GTree_Create()//返回组织链表的地址
{
	return LinkList_Create();
}

void GTree_Destroy(GTree* tree)
{
	GTree_Clear(tree);
	LinkList_Destroy(tree);
}

void GTree_Clear(GTree* tree)
{
	GTree_Delete(tree,0);//根节点一旦被删除，整棵树将会全部被清空
}


//将Data作为pPos代表的树结点的孩子插入，
//故pPos是指其父亲在组织链表中的位置,插入的如果是根节点，则pPos为-1
int GTree_Insert(GTree* tree, GTreeData* data, int pPos)
{
	LinkList* list = (LinkList*)tree;

	int ret = (list != NULL) && (data != NULL) && (pPos < LinkList_Length(list));

	if (ret){
		GTreeNode* cNode = (GTreeNode*)malloc(sizeof(GTreeNode));//申请树节点所需要的本身空间
		TLNode* cldNode = (TLNode*)malloc(sizeof(TLNode));//申请树节点在其父节点的child链表中的节点空间
		TLNode* trNode = (TLNode*)malloc(sizeof(TLNode));//申请树节点在组织链表中的节点空间
		TLNode* pNode = (TLNode*)LinkList_Get(list,pPos);//通过传入的pPos参数找到要插入的节点在插入以后的父节点

		ret = (cNode != NULL) && (cldNode != NULL) && (trNode != NULL);

		if (ret)//初始化
		{
			cNode->data = data;
			cNode->parent = NULL;//准备得到父节点
			cNode->child = LinkList_Create();//为该节点创建他自己的child链表

			trNode->node = cNode;
			cldNode->node = cNode;

			LinkList_Insert(list, (LinkListNode*)trNode, LinkList_Length(list));//将树节点插入组织链表的最后
			if (pNode != NULL){//如果插入的是根节点，则他不属于人和节点的孩子，故不存在cldNode
				
				cNode->parent = pNode->node;
				LinkList_Insert(pNode->node->child, (LinkListNode*)cldNode, LinkList_Length(pNode->node->child));
			}
			else{
				free(cldNode);
			}
			
		}
		else{
			free(trNode);
			free(cldNode);
			free(cNode);
		}
	}

	return ret;
}

GTreeData* GTree_Delete(GTree* tree, int pos)//根据树节点在组织链表中的位置来删除树节点
{
	GTreeData* ret = NULL;
	TLNode* trNode = (TLNode*)LinkList_Get(tree,pos);//先得到树节点在组织链表中所在的链表节点
	if (trNode != NULL){
		ret = trNode->node->data;
		recursive_delete(tree,trNode->node);
	}
	return ret;
}

GTreeData* GTree_Get(GTree* tree, int pos)
{
	GTreeData* ret = NULL;
	TLNode* trNode = (TLNode*)LinkList_Get(tree, pos);//先得到树节点在组织链表中所在的链表节点
	if (trNode != NULL){
		ret = trNode->node->data;
	}

	return ret;
}

GTreeData* GTree_Root(GTree* tree)
{
	return GTree_Get(tree,0);
}

int GTree_Height(GTree* tree)
{
	TLNode* trNode = (TLNode*)LinkList_Get(tree, 0);//获取根节点
	int ret = 0;
	if (trNode != NULL){//合法性检测
		ret = recursive_height(trNode->node);
	}
	return ret;
}

int GTree_Count(GTree* tree)
{
	return LinkList_Length(tree);
}

int GTree_Degree(GTree* tree)
{
	TLNode* trNode = (TLNode*)LinkList_Get(tree,0);
	int ret = -1;
	if (trNode != NULL){
		ret = recursive_degree(trNode->node);
	}
	return ret;
}

void GTree_Display(GTree* tree, GTree_Printf* pFunc, int gap, char div)
{
	TLNode* trNode = (TLNode*)LinkList_Get(tree,0);//通过找组织链表的第0个元素找到根节点所在的链表节点，
													//实际上的根节点是trNode->node

	if (trNode != NULL){
		recursive_display(trNode->node,pFunc,0,gap,div);//根节点由于没有父节点所以不用空出位置，即format为0
	}
}

测试文件

#include "GTree.h"
#include <stdio.h>

void Display(GTreeData* data){
	printf("%c",(char)data);
}
int main(){
	GTree* tree = GTree_Create();

	GTree_Insert(tree, (GTreeData*)'A',-1);
	GTree_Insert(tree, (GTreeData*)'B', 0);
	GTree_Insert(tree, (GTreeData*)'C', 0);
	GTree_Insert(tree, (GTreeData*)'D', 0);
	GTree_Insert(tree, (GTreeData*)'E', 1);
	GTree_Insert(tree, (GTreeData*)'F', 1);
	GTree_Insert(tree, (GTreeData*)'G', 3);

	printf("Root!\n");
	printf("%c\n",(int)GTree_Root(tree));

	printf("Height!\n");
	printf("%d\n", GTree_Height(tree));

	printf("Degree!\n");
	printf("%d\n", GTree_Degree(tree));

	printf("Count!\n");
	printf("%d\n", GTree_Count(tree));


	printf("The second!\n");
	printf("%c\n", (int)GTree_Get(tree,2));


	GTree_Display(tree,Display,4,'*');


	GTree_Delete(tree, 2);
	printf("After Delete!\n");
	GTree_Display(tree, Display, 4, '*');


	GTree_Clear(tree);
	printf("After Clear!\n");
	GTree_Display(tree, Display, 4, '*');


	GTree_Destroy(tree);

	system("PAUSE");
	return 0;
}