静态链表单向实现

静态链表的单向实现,初衷是为了模拟没有指针的高级语言，用数组来代替指针来描述单向链表，所用方法为游标实现法

数组元素用两个数据域组成，一个为数据值，一个为当前数据的后继下标

----实现了单向链表的初始化创建 插入 和 删除

----优点：改进了顺序储存结构中插入删除需要大量移动数据的缺点

----缺点：1.连续分配空间 表长难以确定

                2.失去了顺序结构储存的快速读取功能

总结：为了模拟 为了实现这种巧妙的构思 为了好玩

#include <stdio.h>
#include <windows.h>
#define MAX_LEN (502)

//不用指针的静态链表 模拟高级语言使用
typedef struct node{
int value;
int NextSet;
}StaticList;

void CreateStaticList(StaticList static_list[],int length_src,int init_num[],int length_put)
{
int count;
int NullEndSet;
if(static_list == NULL || length_src <= 0 || length_src > MAX_LEN ||init_num == NULL)return ;

memset( static_list,0,length_src*sizeof(StaticList) );
//初始化next指向
for(count = 1;count<length_src-2;count++)
{
static_list[count].NextSet = count+1;
}
static_list[count].NextSet = 0;
NullEndSet = count;
//初始化用户赋值
for(count = 0;count<length_put;count++)
{
static_list[count+1].value = init_num[count];
}
static_list[count].NextSet = 0;//最后的元素向后链接位置为位置0
//初始化空位置头和有数据位置头
static_list[0].value = NullEndSet;//空数据尾位置
static_list[0].NextSet = count+1;//空数据头位置
static_list[length_src-1].value = count;//数据数量
static_list[length_src-1].NextSet = count==0?-1:1;//有数据头位置
}

//插入
//插入插入位置之前
void InsertStaticNode(StaticList static_list[],int length_src,int insertnum,int insertindexset)
{
int NullSet;
int HeaderSet;
int DataCount;
int count;
int NewNextSet;
int NewLastSet;
if(static_list == NULL || length_src <= 0 || length_src+1 > MAX_LEN ||insertindexset <= 0 ||insertindexset >MAX_LEN)return ;

NullSet = static_list[0].NextSet;//空位置头 也是 插入位置
HeaderSet = static_list[length_src-1].NextSet;
DataCount = static_list[length_src-1].value;
if(insertindexset >  DataCount)
{
printf("当前静态链表长度为：%d\n请进行正确位置的添加，谢谢使用\n",DataCount);
return ;
}
static_list[NullSet].value = insertnum;//插入数据
static_list[0].NextSet = static_list[NullSet].NextSet;//更新空位置头

NewLastSet = NewNextSet = HeaderSet;
for(count = 1;count<insertindexset;count++)
{
NewLastSet = NewNextSet;
NewNextSet = static_list[NewNextSet].NextSet;
}
static_list[NullSet].NextSet = NewNextSet;//向后链接
//向前链接
if(1 == insertindexset)
{
static_list[length_src-1].NextSet = NullSet;
}
else
{
static_list[NewLastSet].NextSet = NullSet;
}

static_list[length_src-1].value++;//更新已存在数据数量
}

//删除
void DeleteStaticNode(StaticList static_list[],int length_src,int deleteindexset)
{
int DataCount;
int HeaderSet;
int NullEndSet;
int count;
int DelLastSet;
int DelNode;
int DelNextNode;
if(static_list == NULL || length_src <= 0 || length_src > MAX_LEN ||deleteindexset <= 0 ||deleteindexset >MAX_LEN)return ;
DataCount = static_list[length_src-1].value;
if(deleteindexset > DataCount)
{
printf("当前静态链表长度为：%d\n请进行正确位置的删除，谢谢使用\n",DataCount);
return ;
}

HeaderSet = static_list[length_src-1].NextSet;
NullEndSet = static_list[0].value;
if(deleteindexset == 1)//删除头
{
DelNode = HeaderSet;
static_list[length_src-1].NextSet = static_list[HeaderSet].NextSet;
}
else
{
DelNode = DelLastSet = HeaderSet;
for(count = 1;count<deleteindexset;count++)
{
DelLastSet = DelNode;
DelNode = static_list[DelNode].NextSet;
}

if(deleteindexset == DataCount)//删除尾
{
static_list[DelLastSet].NextSet = 0;
}
else//删除中间
{
DelNextNode = static_list[DelNode].NextSet;
static_list[DelLastSet].NextSet = DelNextNode;
}
}

static_list[DelNode].value = 0;//置零
static_list[DelNode].NextSet = 0;//置零
static_list[NullEndSet].NextSet = DelNode;//无数据元素尾添加

static_list[length_src-1].value--;//更新已存在数据数量
}
int main()
{
int head;
StaticList static_list[102] = {0};
int putinarr[] = {3,4,5,7,8,3,3,4,8,56,78,6,2,45};

CreateStaticList(static_list,sizeof(static_list)/sizeof(static_list[0]),putinarr,sizeof(putinarr)/sizeof(putinarr[0]));
InsertStaticNode(static_list,sizeof(static_list)/sizeof(static_list[0]),123131,1);
DeleteStaticNode(static_list,sizeof(static_list)/sizeof(static_list[0]),15);
InsertStaticNode(static_list,sizeof(static_list)/sizeof(static_list[0]),999,14);
head = static_list[sizeof(static_list)/sizeof(static_list[0])-1].NextSet;
while(head)
{
printf("%d  ",static_list[head].value);
head = static_list[head].NextSet;
}

system("pause");
return 0;
}