第7课-线性表的顺序存储结构

1. 顺序存储定义

线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的

数据元素。

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

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

(2)      线性表的最大容量：数组长度MAXSIZE

(3)      线性表的当前长度：length

#define MAXSIZE 20

typedef struct _tag_List

{

char node[MAXSIZE];

int length;

}List;

2. 获取元素操作

(1)      判断线性表是否合法。

(2)      判断位置是否合法。

(3)      直接通过数组下标的方式获取元素。

char Get(List* list, int pos)

{

char ret = -1;

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

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

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

//3. 获取元素

ret = list->node[pos];

}

return ret;

}

3. 插入元素操作

(1)      判断线性表是否合法。

(2)      判断插入位置是否合法。

(3)      把最后一个元素到插入位置的元素后移一个位置。

(4)      将新元素插入。

(5)      线性表长度加1。

元素插入算法：

int Insert(List* list, cahr c, int pos)

{

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

int ret = (list != NULL);

int i = 0;

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

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

rer = ret && (0 <= pos);

if( ret )

{

if( pos >= list->length)

{

pos = list->length;

}

//3. 从最后一个元素开始到pos个位置

//   分别都将他们向后移动一个位置

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

{

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

}

//4. 将新元素插入

list->node[i] = c;

//5. 长度加1

list->length++;

}

return ret;

}

4. 删除元素操作

(1)      判断线性表是否合法。

(2)      判断删除位置是否合法。

(3)      将元素取出。

(4)      将删除位置后的元素分别向前移动一个位置。

(5)      线性表长度减1。

元素删除算法：

char Delete(List* list, int pos)

{

char ret = -1;

int i = 0;

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

int ret = (list != NULL);

int i = 0;

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

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

{

//3. 取出删除的元素

ret = list->node[pos];

//4. 把删除位置pos后面的元素分别向前移动一个位置

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

{

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

}

//5. 长度减1

list->length--;

}

return ret;

}

5. 创建可复用顺序线性表

SepList.c

#include <stdio.h>

#include <malloc.h>

#include "SeqList.h"

typedef unsigned int TSeqListNode;

typedef struct _tag_SeqList

{

int capacity;

int length;

TSeqListNode* node;

} TSeqList;

SeqList* SeqList_Create(int capacity)  //O(1)

{

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);

}

return ret;

}

void SeqList_Destroy(SeqList* list)  //O(1)

{

free(list);

}

void SeqList_Clear(SeqList* list)   //O(1)

{

TSeqList*  sList = (TSeqList*)list;

if( sList != NULL)

{

sList->length = 0;

}

}

int SeqList_Length(SeqList* list)   //O(1)

{

TSeqList*  sList = (TSeqList*)list;

int ret = -1;

if( sList != NULL)

{

ret = sList->length;

}

return ret;

}

int SeqList_Capacicy(SeqList* list)     //O(1)

{

TSeqList*  sList = (TSeqList*)list;

int ret = -1;

if( sList != NULL)

{

ret = sList->capacity;

}

return ret;

}

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)   //最好O(1)，最坏O(n)

{

TSeqList*  sList = (TSeqList*)list;

int ret = (sList != NULL);

int i = 0;

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

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

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++;

}

return ret;

}

SeqListNode* SeqList_Get(SeqList* list, int pos)   //O(1)

{

TSeqList*  sList = (TSeqList*)list;

SeqListNode* ret = NULL;

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

{

ret = (SeqListNode*)(sList->node[pos]);

}

return ret;

}

SeqListNode* SeqList_Delete(SeqList* list, int pos)   //最坏O(n-1)

{

TSeqList*  sList = (TSeqList*)list;

SeqListNode* ret = SeqList_Get(list, pos);

int i = 0;

if( ret != NULL)

{

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

{

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

}

sList->length--;

}

return ret;

}

SepList.h

#ifndef _SEQLIST_H_

#define _SEQLIST_H_

typedef void SeqList;

typedef void SeqListNode;

//头文件中是void，到了实际的应用中才变得有类型。这是实际应用中的一种封装效果。

//这样不会因为一些错误的操作，产生不必要的结果。用void进行封装。

SeqList* SeqList_Create(int capacity);

void SeqList_Destroy(SeqList* list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacicy(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);

#endif

main.c

#include <stdio.h>

#include <stdlib.h>

#include"SeqList.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[])

{

SeqList* list = SeqList_Create(5);

int i = 0;

int j = 1;

int k = 2;

int x = 3;

int y = 4;

int z = 5;

int index = 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);

//连续添加6次，前一次的会往后移动。 最大容量是5，不可能加进去第六个元素。

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

{

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

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

}//结果为 4,3,2,1,0

printf("\n");

while( SeqList_Length(list) > 0)

{

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

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

}//结果为：4,3,2,1,0

SeqList_Destroy(list);

return 0;

}

优点

（1）无需为线性表中的逻辑关系增加额外的空间。

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

缺点

（1）插入和删除操作需要移动大量元素。

（2）当线性表长度变化较大时难以确定存储空间的容量。