数据结构之线性表的顺序存储结构

顺序存储结构

一.在C语言中用一维数组实现顺序存储结构

1.存储空间的存储位置：数组 node;

2.线性表的最大容量 MAXSIZE;

3.线性表的当前长度：length;

#define MAXZIXE 20

typedef struct _tag_List

{

char node [MAXSIZE];

int length;

}List;

二.获取元素操作

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;

}

三.插入元素算法

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

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

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

4.将新元素插入;

5.线性表元素加1.

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

{

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

int ret = (list != NULL);

int i = 0;

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

ret = ret && (list->length + 1 <= MAXSIZE);//线性表中是否有空位

ret = ret && (0 < pos);//插入的位置是否合法

if(ret)

{

if(pos >= list->length )

{

pos = list->length;

}

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

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

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

{

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

}

//将新元素插入

list->node[i] = c;

//5.长度加1

list->length++;

}

return ret;

}

四.删除元素操作

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

2.判断删除位置是否合法;

3.将元素取出;

4.将删除位置之后的元素分别向前移动一个位置;

5.线性表长度减一.

char Delete(Lsit* list,int pos)

{

char ret = -1;

int i = 0;

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

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

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

{

// 3. 取出元素

ret = list->node[pos];

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

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

{

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

}

// 5.线性表长度减一

list->length--;

}

return ret;

}

五.以下是可以复用的产品级别的C实现代码：

源文件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);

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;

}

源文件SeqList.h

#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

源文件SeqList.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_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;

}