数据结构--单链表及静态链表

今天由于时间问题，简短的回忆下今天的内容：
首先简单说下链式结构的概念
链式存储结构：为了表示每个数据元素与其直接后继元素之间的逻辑关系，每个元素除了存储本身本身的信息外
还需要存储指示其直接后继的信息。
在C语言中可以用结构体来定义链表中的指针域
链表中的表头结点也可以用结构体实现
链式存储逻辑结构
n个结点连接成一个链式线性表的结构叫做链表
当每个结点中只包含一个指针域时，叫做单链表。
表头结点：链表中的第一个结点，包含指向第一个元素的指针以及链表自身的一些信息。
数据结点：链表中代表数据元素的节点，包含指向下一个数据元素的指针和数据元素信息
尾结点：链表的最后一个数据节点，其下一个元素指针为空，表示无后继。
下边用个图来说清他们的定义：
插入元素操作示意图（图来说话）：
讲下最重要的插入元素的算法
插入元素到位置的操作pos的算法：
判断线性表是否合法
判断插入位置是否合法
有表头开始通过next指针移动pos次后，当前元素的next指针即指向要插入的位置
将新元素插入
线性表长度加1
删除元素的算法与C表达：


注意：新链表的生成需要在旧链表未断裂的情况下进行，否则就会出错
存在的必要：顺序表存在的最大问题在于在输入与删除是需要移动大量的数据，而单链表很好的解决了这个问题。、
用于生疏操作，下面我直接贴代码（各个算法具体代码）：
typedef struct _tag_LinkList
{
LinkListNode header;
int length;
}TLinkList;

LinkList* LinkList_Create()
{
TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));
if(ret != NULL)
{
ret->length = 0;
ret->header.next = 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;
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;(current->next != NULL) && (i < pos);i++)
{
current = current->next;
}
node->next = current->next;
current->next = node;
slist->length++;
}
return ret;
}

LinkListNode* LinkList_Get(LinkList* list, int pos)
{
TLinkList* slist = (TLinkList*)list;
LinkListNode* ret = NULL;
int i = 0;
if((pos >= 0) && (pos <= slist->length) && (slist != NULL))
{
LinkListNode* current = (LinkListNode*)slist;
for(i=0;i

include “StaticList.h”

define AVAILABLE -1

typedef struct _tag_StaticListNode
{
unsigned int data;
int next;
}TStaticListNode;
typedef struct _tag_StaticList
{
int capacity;
TStaticListNode header;
TStaticListNode node[];
}TStaticList;
StaticList* StaticList_Create(int capacity)
{
TStaticList* ret = NULL;
int i = 0;
if(capacity >= 0)
{
ret = (TStaticList*)malloc(sizeof(TStaticList) + sizeof(TStaticListNode)*(capacity + 1));
}
if(ret != NULL)
{
ret->capacity = capacity;
ret->header.data = 0;
ret->header.next = 0;
for(i = 0;i < ret->capacity;i++)
{
ret->node[i].next = AVAILABLE;
}
}
return ret;
}

void StaticList_Destroy(StaticList* list)
{
free(list);
}

void StaticList_Clear(StaticList* list)
{
TStaticList* slist = (TStaticList*)list;
int i = 0;
if(slist != NULL)
{
slist->header.data = 0;
slist->header.next = 0;
for(i = 0;i < slist->capacity;i++)
{
slist->node[i].next = AVAILABLE;
}
}
}

int StaticList_Length(StaticList* list)
{
TStaticList* slist = (TStaticList*)list;
int ret = -1;
if(slist != NULL)
{
ret = slist->header.data;
}
return ret;
}

int StaticList_Capalist(StaticList* list)
{
TStaticList* slist = (TStaticList*)list;
int ret = -1;
if(slist != NULL)
{
ret = slist->capacity;
}
return ret;
}

int StaticList_Insert(StaticList* list, StaticListNode* node, int pos)
{
TStaticList* slist = (TStaticList*)list;
int ret = (slist != NULL);
int i = 0;
int index = 0;
int current = 0;

ret = ret && (slist->header.data + 1 <= slist->capacity);
ret = ret && (0 <= pos) && (node != NULL);
if(ret)
{
for(i = 1;i < slist->capacity;i++)
{
if(slist->node[i].next == AVAILABLE)
{
index = i;
break;
}
}
slist->node[index].data = (unsigned int)node;
slist->node[0] = slist->header;
for(i = 0;(i < pos) && (slist->node[current].next != 0);i++)
{
current = slist->node[current].next;
}
slist->node[index].next = slist->node[current].next;
slist->node[current].next = index;
slist->node[0].data++;
slist->header = slist->node[0];
}
return ret;
}

StaticListNode* StaticList_Get(StaticList* list, int pos)
{
TStaticList* slist = (TStaticList*)list;
StaticListNode* ret = NULL;
int current = 0;
int object = 0;
int i = 0;

if( (slist != NULL) && (0 <= pos) && (pos < slist->header.data))
{
slist->node[0] = slist->header;
for(i = 0;i < pos;i++)
{
current = slist->node[current].next;
}
object = slist->node[current].next;
ret = (StaticListNode*)(slist->node[object].data);
}
return ret;
}

StaticListNode* StaticList_Delete(StaticList* list, int pos)
{
TStaticList* slist = (TStaticList*)list;
StaticListNode* ret = NULL;
int current = 0;
int object = 0;
int i = 0;

if( (slist != NULL) && (0 <= pos) && (pos < slist->header.data))
{
slist->node[0] = slist->header;
for(i = 0;i < pos;i++)
{
current = slist->node[current].next;
}
object = slist->node[current].next;
slist->node[current].next = slist->node[object].next;
slist->node[0].data–;
slist->header = slist->node[0];
slist->node[object].next = AVAILABLE;
ret = (StaticListNode*)(slist->node[object].data);
}
return ret;
}

小结： 静态链表其实是单链表的另一种实现形式
静态链表的实现“媒介”不是指针，而是数组
静态链表主要用于不支持指针的程序设计语言中
静态链表的实现是一种内存管理的简易方法