单链表
#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;
}