链表结构与应用-优快云博客

译者：Mrzhu007
日期：2018年04月13日
博客地址：金色世界

listlist.h头文件

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

typedef void LinkList;
typedef struct _tag_LinkListNode
{
	struct _tag_LinkListNode* next;
}LinkListNode;


Linklist* LinkList_Create();

void LinkList_Destroy(LinkList* list);

void LinkList_Clear(LinkList* list);

int LinkList_Length(LinkList* list);

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

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

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

linklist.c资源文件

#include <stdio.h>
#include "stdlib.h"
#include "string.h"
#include "linklist.h"

typedef struct _tag_LinkList
{
	//头结点内含指向下一节点
	LinkListNode header;
	int length;
}TLinkList;

LinkList* LinkList_Create()
{
	TLinkList *ret = (TLinkList *)malloc(sizeof(TLinkList));
	if(ret == NULL)
	{
		return NULL;
	}
	memset(ret, 0, sizeof(TLinkList));
	ret->header.next = NULL;
	ret->length = 0;
	retrun ret;
}
void LinkList_Destroy(LinkList* list)
{
	if(list == NULL)
	{
		return;
	}
	free(list);
	return;
}
void LinkList_Clear(LinkList* list)
{
	TLinkList *tList = NULL;
	if(list == NULL)
	{
		return;
	}
	tList = (TLinkList *)list;
	tList->length = 0;
	tList->header.next = NULL;
	return;
}
int LinkList_Length(LinkList* list)
{
	TLinkList *tList = (TLinkList *)list;
	if(tList == NULL)
	{
		return -1;
	}
	return tList->length;
}
int LinKList_Insert(LinkList* list, LinkListNode* node, int pos)
{
	int i = 0;
	TlinkList *tList = NULL;
	LinkListNode *current = NULL;
	tList = (TLinkList *)list;
	current = &tList->header;
	for(i = 0; i < pos && (current->next! = NULL); i++)
	{
		current = current->next;
	}
	node->next = current->next;
	current->next = node;
	tList->length++;
	return 0;
}
LinkListNode* LinkList_Get(LinkList* list, int pos)
{
	int i = 0;
	TLinkList *tList = NULL;
	LinkListNode *current = NULL;
	LinkListNode *ret = NULL;
	tList = (TLinkList *)list;

	if(list == NULL || pos < 0 || pos >= tList->length)
	{
		return NULL;
	}
	current = &tList->header;
	for(i = 0; i < pos &&(current->next != NULL); i++)
	{
		current = current->next;
	}
	ret = current->next;
	return ret;
}
LinkListNode* LinkList_Delete(LinkList* list, int pos)
{
	int i = 0;
	TLinkList *tList = NULL;
	LinkListNode *current = NULL;
	LinkListNode *ret = NULL;
	tList = (TLinkList *)list;
	if(list == NULL || pos < 0 || pos >= tList->length)
	{
		return NULL;
	}
	current = &tList->header;
	for(i = 0; i < pos && (current->next != NULL); i++)
	{
		current = current->next;
	}
	ret = current->next;
	current->next = ret->next;
	tList->length--;
	return ret;
}

线性表链式存储应用

#include <stdio.h>
#include "stdlib.h"
#include "string.h"
#include "linklist.h"

typedef struct Teacher
{
	LinkListNode node;
	char name[64];
	int age;
}Teacher;

int main()
{
	Teacher t1,t2,t3;
	int length, i = 0;
	LinkList *list = NULL;
	t1.age = 31;
	t2.age = 32;
	t3.age = 33;
	list = LinkList_Create();
	length = LinkList_Length(list);

	LinkList_Insert(list, (LinkListNode *)&t1, LinkList_Length(list));
	LinkList_Insert(list, (LinkListNode *)&t2, LinkList_Length(list));
	LinkList_Insert(list, (LinkListNode *)&t3, LinkList_Length(list));

	for(i = 0; i < LinkList_Length(list); i++)
	{
		Teacher *tmp = (Teacher *)LinkList_Get(list, i);
		if(tmp != NULL)
		{
			printf("age:%d ", tmp->age);
		}
	}
	while(LinkList_Length(list) > 0)
	{
		Teacher *tmp = (Teacher *)LinkList_Delete(list, 0);
		if(tmp != NULL)
		{
			printf("age:%d ", tmp->age);
		}
	}
	LinkList_Destroy(list);
	retrun 0;
}

该结构体现数据和算法分离的思想，写一种算法可应用不同的业务场景之中。
优点：
无需一次性定制链表的容量
插入和删除无需移动数据元素
缺点：
数据元素必须保存后继元素的位置信息
获取制定数据的元素操作需要顺序访问之前的元素
更新说明：

线性表定义
①：零个或多个数据元素的集合
②：数据之间是有顺序的
③：元素个数是有限的
④：数据元素类型必须相同
数学定义
线性表是具有相同类型的N（N>=0）个数据元素的有限序列（a1,a2,a3,…,an）
ai是表项，n是表长度。
性质
①：a0为线性表的第一个元素，只有一个后继
②：an为线性表的最后一个元素，只有一个前驱
③：除a0和an外的其他元素ai，既有前驱，又有后继
④：线性表能够逐项访问和顺序存取
线性表的操作
①：创建线性表
②：销毁线性表
③：清空线性表
④：将元素插入线性表
⑤：将元素从线性表中删除
⑥：获取线性表中某个位置的元素
⑦：获取线性表的长度

线性表的链式存储