顺序表——数据结构

概念

顺序表：线性表的顺序存储结构，指的是用一段地址连续的存储单元以此存储线性表的数据元素
顺序表的优缺点：
优点：存储密度高，可以随机存取结点。
缺点：1、长度为定值，中途无法扩充。2、插入删除需要移动节点，效率低。
顺序表一般分为静态顺序表和动态顺序表
静态顺序表

#define MaxSize 20
typedef int DataType;    //自定义类型语句，定义整型常量ElemType
typedef struct
{
        ElemType array[MaxSize];   //数据类型为DataType的长度为MaxSize的数组array    
        int size;        //下标长度
}SqList;  

动态顺序表

#define MaxSize 20
typedef int DataType;    //自定义类型语句，定义整型常量ElemType
typedef struct
{
       DataType *array;   //数据类型为DataType的长度为MaxSize的数组array
       int capacity;      //当前容量等于静态顺序表MaxSize
       int size;        //下标长度
}SqList;  

区别
静态顺序表和动态顺序表唯一一点不同的是，静态顺序表再创建顺序表的时候容量已经确定为MaxSize，不可以更改，而动态顺序表的容量是由malloc函数动态开辟，当容量不够用时可以增加容量capacity
扩容方法：动态开辟一块新的空间（一般为原空间的两倍），将原空间的数据拷贝到新的空间，然后让array指针指向新的空间并且释放旧空间

优缺点比较
静态顺序表创建空间时为静态开辟，不用malloc函数，代码相对简单（一点点），不存在内存泄露问题
动态顺序表，动态开辟空间，使用相对灵活，相比于静态开辟空间也可以少空间浪费

代码实现

实现顺序表的代码如下：
SeqList.h

//顺序表
typedef int DataType;
typedef struct 
{
	DataType *array;//保存顺序表中有效元素个数
	int capacity;//空间总大小
	int size;//有效元素个数
}PSeqList;
//初始化
void SeqListInit(PSeqList *ps);
//清除
void SeqListDestroy(PSeqList *ps);

//尾插
void SeqListPushBack(PSeqList *ps,DataType data);
//尾删
void SeqListPopBack(PSeqList *ps);

//头插
void SeqListPushFront(PSeqList *ps, DataType data);
//头删
void SeqListPopFront(PSeqList *ps);

// 任意位置插入 
void SeqListInsert(PSeqList *ps, int pos, DataType data);

// 任意位置删除 
void SeqListErase(PSeqList *ps, int pos);

// 检测data是否在顺序表中 
int SeqListFind(PSeqList *ps, DataType data);

// 移除顺序表中第一个值为data的元素 
void SeqListRemove(PSeqList *ps, DataType data);

// 移除顺序表中所有值为data的元素 
void SeqListRemoveAll(PSeqList *ps, DataType data);

// 获取顺序表有效元素个数 
int SeqListSize(PSeqList *ps);

// 获取顺序表的容量 
int SeqListCapacity(PSeqList *ps);

// 检测顺序表是否为空 
int SeqListEmpty(PSeqList *ps);

// 获取顺序表中第一个元素 
DataType SeqListFront(PSeqList *ps);

// 获取顺序表中最后一个元素 
DataType SeqListBack(PSeqList *ps);

SeqList.c

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "List.h"
//初始化
void SeqListInit(PSeqList *ps)
{
	assert(ps!= NULL);
	ps->capacity = 20;
	ps->array = (int *)malloc(sizeof(DataType)*ps->capacity);
	ps->size = 0;
}
//清除
void SeqListDestroy(PSeqList *ps)
{
	assert(ps);
	assert(ps->array);
	free(ps->array);
	ps->array = NULL;
	ps->capacity = 0;
	ps->size = 0;
}

//尾插
void SeqListPushBack(PSeqList *ps, DataType data)
{
	ps->array[ps->size] = data;
	ps->size++;
}
//尾删
void SeqListPopBack(PSeqList *ps)
{
	assert(ps->size > 0);
	ps->size--;
}

//头插
void SeqListPushFront(PSeqList *ps, DataType data)
{
	for (int i=ps->size;i>=1;i--)
	{
		ps->array[i] = ps->array[i - 1];
	}
	ps->array[0] = data;
	ps->size++;
}
//头删
void SeqListPopFront(PSeqList *ps)
{
	assert(ps->size > 0);
	for (int i=0;i<ps->size-1;i++)
	{
		ps->array[i] = ps->array[i + 1];
	}
	ps->size--;
}

// 任意位置插入 
void SeqListInsert(PSeqList *ps, int pos, DataType data)
{
	for (int i=ps->size-1;i>=pos;i--)
	{
		ps->array[i + 1] = ps->array[i];
	}
	ps->array[pos] = data;
	ps->size++;
}

// 任意位置删除 
void SeqListErase(PSeqList *ps, int pos)
{
	assert(ps->size > 0);
	for (int i = pos + 1; i < ps->size; i++)
	{
		ps->array[i - 1] = ps->array[i];
	}
	ps->size--;
}

// 检测data是否在顺序表中 
int SeqListFind(PSeqList *ps, DataType data)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->array[i] == data)
		{
			return 1;
		}
	}
	return -1;
}

// 移除顺序表中第一个值为data的元素 
void SeqListRemove(PSeqList *ps, DataType data)
{
	for (int i=0; i < ps->size; i++)
	{
		if (ps->array[i]==data)
		{
			break; 
			for (int j = i + 1; j < ps->size; j++)
			{
				ps->array[j - 1] = ps->array[j];
			}
			ps->size--;
		}
	}
}

// 移除顺序表中所有值为data的元素 
void SeqListRemoveAll(PSeqList *ps, DataType data)
{
	for (int i = 0; i < ps->size; i++)
	{
		while (ps->array[i] == data)
		{
			for (int j = i + 1; j < ps->size; j++)
			{
				ps->array[j - 1] = ps->array[j];
			}
			ps->size--;
		}
	}
}

// 获取顺序表有效元素个数 
int SeqListSize(PSeqList *ps)
{
	return ps->size;
}

// 获取顺序表的容量 
int SeqListCapacity(PSeqList *ps)
{
	return ps->capacity;
}

// 检测顺序表是否为空 
int SeqListEmpty(PSeqList *ps)
{
	if (ps->size==0)
	{
		return 0;
	}
	return ps->size;
}

// 获取顺序表中第一个元素 
DataType SeqListFront(PSeqList *ps)
{
	return ps->array[0];
}

// 获取顺序表中最后一个元素 
DataType SeqListBack(PSeqList *ps)
{
	return ps->array[ps->size - 1];
}
int main()
{
	system("pause");
	return 0;
}

由代码可知，线性表的顺序储存结构，在存、读数据时，不管是哪个位置，时间复杂度都是O（1），而在插入或删除时，时间复杂度都是O（n)。
所以，顺序表适合元素个数比较稳定，不经常插入和删除元素，而更多的操作是存取数据的应用。
综上总结可得线性表的顺序存储结构的优缺点：
优点：
无须为表示表中元素之间的逻辑关系而增加额外的存储空间
可以快速地存取表中任意位置的元素
缺点：
插入和删除操作需要移动大量元素，耗费时间
当线性表长度变化较大时，难以确定存储空间的容量
容易造成存储空间的“碎片”