一、StaticList.h
#ifndef _STATICLIST_H_
#define _STATICLIST_H_
typedef void StaticList;
typedef void StaticListNode;
StaticList* StaticList_Create(int capacity);
void StaticList_Destroy(StaticList* list);
void StaticList_Clear(StaticList* list);
int StaticList_Length(StaticList* list);
int StaticList_Capacity(StaticList* list);
int StaticList_Insert(StaticList* list, StaticListNode* node, int pos);
StaticListNode* StaticList_Get(StaticList* list, int pos);
StaticListNode* StaticList_Delete(StaticList* list, int pos);
#endif
二、StaticList.c
#include <stdio.h>
#include <malloc.h>
#include "StaticList.h"
#define AVAILABLE -1 //链表空闲位置的标志
typedef struct _tag_StaticListNode //结点结构体的定义
{
unsigned int data; //data为存放节点的数据信息
int next; //next存放下标元素
} TStaticListNode;
typedef struct _tag_StaticList //静态链表结构体定义
{
int capacity; //链表的最大容量
TStaticListNode header; //表头结点
TStaticListNode node[]; //结点信息
} TStaticList;
StaticList* StaticList_Create(int capacity) // O(n)
{
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=1; i<=capacity; i++)
{
ret->node[i].next = AVAILABLE;
}
}
return ret;
}
void StaticList_Destroy(StaticList* list) // O(1)
{
free(list);
}
void StaticList_Clear(StaticList* list) // O(n)
{
TStaticList* sList = (TStaticList*)list; //将链表进行强制转化
int i = 0;
if( sList != NULL )
{
sList->header.data = 0; //链表的长度置0
sList->header.next = 0; //头节点的下标清空
for(i=1; i<=sList->capacity; i++)
{
sList->node[i].next = AVAILABLE;
}
}
}
int StaticList_Length(StaticList* list) // O(1)
{
TStaticList* sList = (TStaticList*)list; //将链表进行强制转化
int ret = -1;
if( sList != NULL )
{
ret = sList->header.data; //获取链表当前的长度
}
return ret;
}
int StaticList_Capacity(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) // O(n)
{
TStaticList* sList = (TStaticList*)list; //将链表进行强制转化
int ret = (sList != NULL);
int current = 0;
int index = 0;
int i = 0;
ret = ret && (sList->header.data + 1 <= sList->capacity);
ret = ret && (pos >=0) && (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; //将链表的头赋给链表的第0个元素,此时的current的下标为0
for(i=0; (i<pos) && (sList->node[current].next != 0); i++)
{
current = sList->node[current].next; //获取第pos元素的下标current
}
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) // O(n)
{
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; //将链表的头赋给链表的第0个元素,此时的current的下标为0
for(i=0; i<pos; i++)
{
current = sList->node[current].next; //获取第pos个元素的下标
}
object = sList->node[current].next; //将第pos个元素的赋值给object
ret = (StaticListNode*)(sList->node[object].data); //强制转化第pos元素的值,然后赋给ret
}
return ret;
}
StaticListNode* StaticList_Delete(StaticList* list, int pos) // O(n)
{
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]; //表头重新指向第0个元素
sList->node[object].next = AVAILABLE; //标记为链表的空闲位置
ret = (StaticListNode*)(sList->node[object].data);//将删除的元素赋值给ret
}
return ret;
}
三、main.c
#include <stdio.h>
#include <stdlib.h>
#include "StaticList.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main(int argc, char *argv[])
{
StaticList* list = StaticList_Create(10);
int index = 0;
int i = 0;
int j = 1;
int k = 2;
int x = 3;
int y = 4;
int z = 5;
StaticList_Insert(list, &i, 0);
StaticList_Insert(list, &j, 0);
StaticList_Insert(list, &k, 0);
for(index=0; index<StaticList_Length(list); index++)
{
int* p = (int*)StaticList_Get(list, index);
printf("%d\n", *p);
}
printf("\n");
while( StaticList_Length(list) > 0 )
{
int* p = (int*)StaticList_Delete(list, 0);
printf("%d\n", *p);
}
printf("\n");
StaticList_Insert(list, &x, 0);
StaticList_Insert(list, &y, 0);
StaticList_Insert(list, &z, 0);
printf("Capacity: %d Length: %d\n", StaticList_Capacity(list), StaticList_Length(list));
for(index=0; index<StaticList_Length(list); index++)
{
int* p = (int*)StaticList_Get(list, index);
printf("%d\n", *p);
}
StaticList_Destroy(list);
return 0;
}
静态链表的特点:
1.通过移动元素的下标来实现链表的相关操作;
2.pos为0代表头结点元素,最后一个元素的下标为0
3.将某些元素删除后,要将元素进行链表空闲位置的标记
4.在插入新元素时,要先给插入元素查找链表的空闲位置