线性表的顺序存储结构

线性表可以说是最简单的数据结构，它的描述为：n个数据元素的有限序列。

记为：L=(a1,a2,...,an)

按照存储结构它又可以分为顺序存储结构和链式存储结构。

本节主要是顺序存储结构

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

线性列表的每个数据元素的类型都相同，可以用以为数组来实现顺序存储结构。即把第一个数据元素存到数组下标为0的位置中，接着把线性列表相邻的元素存储在数组中相邻的位置。

先看下线性表的顺序存储的结构代码

#define MAXLENGTH 20

struct sequencelist

{

int data[MAXLENGTH];

int length;

};

顺序数组结构所需的三个属性：

data数组为这个线性表的主要部分，数据元素就存在于此数组中，而对这个线性表的操作都是基于这个数组。

MAXLENGTH线性表的最大存储容量。

length是这个线性表的一个属性，表示这个线性表包含元素的个数。

线性列表有三种操作：获取元素，插入，删除操作

1. 获取元素操作

int getElement(struct sequencelist list, int index, int *element)
{
	int length = list.length;
	if (length == 0 || index < 1 || index > length)
		return ERROR;
	*element = list.data[index-1];
	return OK;
}

2. 插入操作

int insert(struct sequencelist *list, int index, int element)
{
	int length = list->length;
	if (length == 0 || index < 1 || index > length || length >= MAXLENGTH)
		return ERROR;
	for (int i = length - 1; i>=index - 1; i --)
	{
		list->data[i + 1] = list->data[i];
	}
	list->data[index - 1] = element;//插入index所在位置的值
	list->length++;
	return OK;
}

3. 删除操作

int dele(struct sequencelist *list, int index)
{
	int length = list->length;
	if (length == 0 || index < 1 || index > length )
		return ERROR;
	for (int i = index; i<length; i++)
	{
		list->data[i-1] = list->data[i];
	}
	list->length--;
	return OK;
}

4. 较为完整的调试例子：

#include <stdio.h>
#include<iostream>
using namespace std;
//线性列表的定义从1开始

#define OK 1
#define ERROR -1
#define TURE 1
#define FALSE 0
#define MAXLENGTH 20

struct sequencelist
{
	int data[MAXLENGTH];
	int length;
};

//getElement opration
//
int getElement(struct sequencelist list, int index, int *element)
{
	int length = list.length;
	if (length == 0 || index < 1 || index > length)
		return ERROR;
	*element = list.data[index-1];
	return OK;
}

//insert opration
//
int insert(struct sequencelist *list, int index, int element)
{
	int length = list->length;
	if (length == 0 || index < 1 || index > length || length >= MAXLENGTH)
		return ERROR;
	for (int i = length - 1; i>=index - 1; i --)
	{
		list->data[i + 1] = list->data[i];
	}
	list->data[index - 1] = element;//插入index所在位置的值
	list->length++;
	return OK;
}

// Delete opration
//
int dele(struct sequencelist *list, int index)
{
	int length = list->length;
	if (length == 0 || index < 1 || index > length )
		return ERROR;
	for (int i = index; i<length; i++)
	{
		list->data[i-1] = list->data[i];
	}
	list->length--;
	return OK;
}

int main()
{
	struct sequencelist list =
	{
		{ 3, 1, 5, 7, 12, 78, 34 },
		7
	};

	printf("list length  : %d\n", list.length);
	//Test get
	int *element = 0, test = 8;
	element = &test;
	if (OK == getElement(list, 2, element))
	{
		printf("list get 2 :%d\n", *element);
	}
	//Test insert
	if (OK == insert(&list, 7, 520))
	{
		printf("list insert 7 ok!\n");
	}
	if (OK == getElement(list, 8, element))
	{
		printf("list get 8 :%d\n", *element);
	}
	if (OK == insert(&list, 3, 520))
	{
		printf("list insert 3 ok!\n");
	}
	if (OK == getElement(list, 4, element))
	{
		printf("list get 4 :%d\n", *element);
	}

	//Test delete
	if (OK == dele(&list, 3))
	{
		printf("list delete 3 ok!\n");
	}
	if (OK == getElement(list, 3, element))
	{
		printf("list get 3 :%d\n", *element);
	}
	if (OK == dele(&list, 6))
	{
		printf("list delete 6 ok!\n");
	}
	if (OK == getElement(list, 6, element))
	{
		printf("list get 6 :%d\n", *element);
	}
	else
	{
		printf("list get ERROR!\n");
	}
	system("pause");
	return 1;
   
}

总结：线性表的顺序存储结构在存，读取数据时，时间复杂度都是0(1)，而在删除和插入时，时间复杂度都是0(n)。所以说它比较适合元素个数不太变化，存储数据的应用。

优点是可以快速存取任一位置的元素，缺点是插入和删除操作需要移动大量元素；造成存储空间的“碎片”。