线性链表的顺序存储结构

线性表（List）

线性表是数据元素的有序的并且有限的集合，线性表中的数据元素必须是同种类型的；

线性表的常用操作：

1.创建线性表List*List_Creat()

2.销毁线性表voidLlist_Destroy(List*list)

3.清空线性表voidLlist_Clear(List*list)

4.将元素插入线性表intList_Insert(List*list,ListNode*node,intpos);

5.将元素从线性表删除ListNode*List_Delete(List*list,intpos);

6.获取线性表中某个位置的元素ListNode*List_Get(List*list,intpos)

7.获取线性表的长度intList_length(intlength)

顺序存储结构：

在C语言中可以使用一维数组来实现顺序存储结构

一.

存储空间的起始位置：数组node

线性表的最大容量：MAXSIZE

线性表的当前长度:length

#defineMAXSIZE20

typedefstruct_tag_list_

{

charnode[MAXSIZE];

intlength

}List

二.获取元素操作

1.判断线性表是否合法

2.判断位置是否合法

3.直接通过数组下表的方式获取元素

charget(List*list,intpos)

{

charret=-1;

//1.判断线性表是否合法

//2.判断位置是否合法

if((list!=NULL)&&(pos=>0)&&(pos<list->length))

{

//3.获取元素

ret=list->node[pos];

}

returnret;

}

三：顺序存储结构算法

1.插入元素

1.判断线性表是否合法

2.判断插入的位置是否合法

3.把最后一个元素到插入位置的元素后移一个位置

4.将新元素插入

5.线性表的长度加1

intInsert(List*list,charc,intpos)

{

/*1.判断线性表是否合法*/

intret=(list!=NULL);

inti=0;

/*2.判断位置是否合法*/

ret=ret&&(list->length+1>MAXSIZE);

ret=ret&&(pos>0)

if(ret)

{

if(pos>=list->length)

{

pos=list->length;

}

/*3.从最后一个元素开始到pos位置，分别将他们向后移动一个位置*/

for(inti=list->length;i>pos;i--)

{

list->node[i]=list->node[i-1];

}

/*4.将新元素插入*/

list->node[pos]=c;

list->length++;

}

returnret;

}

2.删除元素

1.判断线性表是否合法
2.判断插入的位置是否合法
3.将元素取出

4.把最后一个元素到删除元素的位置的前移一个位置
5.线性表的长度减1

intDelete(List*list,intpos)

{

intret=-1;

inti=0;

/*1.判断线性表是否合法*/

ret=ret&&(list!=NULL);

/*2.判段删除的位置是否合法*/

ret=ret&*&(pos>=0)&&(pos->length);

if(ret)

{

/*3.将元素取出*/

ret=list->node[pos];

/*4.把删除位置pos，后的元素向前移动一个位置*/

for(i=pos+1;i<list->length;i++)

{

list->node[i-1]=list->node[i];

}

/*5.线性表的长度减1*/

list->length--;

}

returnret;

}

四.可复用的顺序线性表

sellist.c文件

#include<stdio.h>

#include<malloc.h>

#include"seqlist.h"

/*用于存放数据元素的地址*/

typedefunsignedintTSeqlistNode;//在32位计算机中一个地址是四个字节，32位

typedefstruct_tag_Seqlist

{

intcapacity;//表明线性表的最大容量

intlength;//表明线性表的长度

TSeqlistNode*node;

}TSeqlist;

/*创建一个最大容量为capacity的线性表*/

SeqList*SeqList_Creat(intcapacity)

{

TSeqlist*ret=NULL;

if(capacity>=0)

{

ret=(TSeqlist*)malloc(sizeof(TSeqlist)+sizeof(TSeqlistNode)*capacity);

}

if(ret!=NULL)

{

ret->capacity=capacity;

ret->length=0;

ret->node=(TSeqlistNode*)(ret+1);

}

returnret;

}

voidSeqList_Destory(SeqList*list)

{

free(list);

}

voidSeqList_Clear(SeqList*list)

{

TSeqlist*slist=(TSeqlist*)list;

if(slist!=NULL)

{

slist->length=0;

}

}

intSeqList_Length(SeqList*list)

{

TSeqlist*slist=(TSeqlist*)list;

intret=-1;//线性表里没有负数

if(slist!=NULL)

{

ret=slist->length;

}

returnret;

}

intSeqList_Capacity(SeqList*list)

{

TSeqlist*slist=(TSeqlist*)list;

intret=-1;//线性表里没有负数

if(slist!=NULL)

{

ret=slist->capacity;

}

returnret;

}

intSeqList_Insert(SeqList*list,ListNode*node,intpos)

{

TSeqlist*slist=(TSeqlist*)list;

intret=(slist!=NULL);

inti=0;

ret=ret&&(slist->length+1<=slist->capacity);

ret=ret&&(pos>=0);

if(ret)

{

if(pos>slist->length)

{

pos=slist->length;

}

for(i=slist->length;i>pos;i--)

{

slist->node[i]=slist->node[i-1];

}

slist->node[i]=(TSeqlistNode)node;

slist->length++;

}

returnret;

}

ListNode*SeqList_Get(SeqList*list,intpos)

{

TSeqlist*slist=(TSeqlist*)list;

ListNode*ret=NULL;

if((slist!=NULL)&&(0<=pos)&&(pos<slist->capacity))

{

ret=(ListNode*)(slist->node[pos]);

}

returnret;

}

ListNode*SeqList_Delete(SeqList*list,intpos)

{

TSeqlist*slist=(TSeqlist*)list;

ListNode*ret=SeqList_Get(list,pos);

inti=0;

if(ret!=NULL)

{

for(i=pos+1;i<slist->length;i++)

{

slist->node[i-1]=slist->node[i];

}

slist->length--;

}

returnret;

}

seqlist.h

#ifndef_SEQLIST_H_

#define_SEQLIST_H_

typedefvoidSeqList;

typedefvoidListNode;

SeqList*SeqList_Creat(intcapacitv);

voidSeqList_Destory(SeqList*list);

voidSeqList_Clear(SeqList*list);

intSeqList_Capacity(SeqList*List);

intSeqList_Insert(SeqList*list,ListNode*node,intpos);

ListNode*SeqList_Delete(SeqList*list,intpos);

ListNode*SeqList_Get(SeqList*list,intpos);

intSeqList_Length(SeqList*list);

#endif

main.c

#include<stdio.h>

#include"seqlist.h"

intmain()

{

SeqList*list=SeqList_Creat(5);

inti=0;

intj=1;

intk=2;

intx=3;

inty=4;

intz=5;

intindex=0;

SeqList_Insert(list,&i,0);

SeqList_Insert(list,&j,0);

SeqList_Insert(list,&k,0);

SeqList_Insert(list,&x,0);

SeqList_Insert(list,&y,0);

SeqList_Insert(list,&z,0);

for(index=0;index<SeqList_Length(list);index++)

{

int*p=(int*)SeqList_Get(list,index);

printf("%d\n",*p);

}

printf("\n");

while(SeqList_Length(list)>0)

{

int*p=(int*)SeqList_Delete(list,0);

printf("%d\n",*p);

}

SeqList_Destory(list);

return0;

}

五:顺序存储结构的优点以及缺点

优点:

1.无需为线性表的逻辑关系增加额外的空间

2.可以快速的获取表中合法位置的元素

缺点:

1.当出入或者删除元素时需要移动大量的数据

2.线性表的长度变化较大，难以确定存储空间的容量