线性表的顺序存储

1，头文件对操作进行声明

#ifndef _SEQLIST_H_

#define _SEQLIST_H_

typedef void SeqList;

typedef void SeqListNode;

SeqList* SeqList_Create(int capacity);

void SeqList_Destroy(SeqList* list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(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

2，对上述声明进行实现

#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_Capacity(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(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)

{

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;

}

3，写完这些操作代码，我们进行具体的测试

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

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_Destroy(list);

return 0;

}

注：

插入操作步骤：

判断线性表是否合法---判断插入位置是否合法---把最后一个元素到插入位置的元素后移一个位置

---将新元素插入---线性表长度加1

删除操作步骤：

判断线性表是否合法---判断删除位置是否合法---将元素取出---将删除位置后的元素分别向前移动一个位置

线性表的长度减1

获取元素操作：

判断线性表是否合法---判断位置是否合法---获取元素

顺序实现的优点：1，无需为线性表中的逻辑关系增加额外空间。2，可以快速的获取表中合法位置的元素。

顺序实现的缺点：1，插入和删除操作需要移动大量的元素。2，当线性表长度变化较大时，难以确定存储空间的容量。