数据结构—线性表（二）顺序表

---

顺序表的定义

顺序表是存储结构
顺序表：线性表的顺序存储表示。用一组地址连续的存储单元一次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。
顺序表的特点：逻辑顺序与其存储的物理顺序相同。
可以使用数组去实现线性表，注意：线性表中元素的位序是从1开始的，而数组中的元素的下标从0开始。

地址计算方法

假设顺序表存储的起始位置为LOC(A)，sizeof(ElemType)是每个数据元素所占用存储空间的大小，则表L中元素所对应的存储位置函数为：
LOC(Ai+1) = LOC(Ai) + sizeof(ElemType)
LOC(Ai) = LOC(A) + （i - 1) * sizeof(ElemType)
注意：此处的i是顺序表的位序，从1开始。

顺序表的静态存储

#include <stdio.h>
#define MaxSize 10  //定义最大长度
typedef struct{
    int data[MaxSize];  //用“静态数组”存放数据元素
    int length;          //顺序表当前长度
}SqList;                //顺序表类型定义

// 基本操作——初始化一个顺序表
void InitList(SqList &L){
    for (int i=0; i< MaxSize; i++)
        L.data[i] = 0;   //将所有数据元素设置为默认初始值
    L.length = 0;        //顺序表初始长度为0
}

int main(){
    SqList L;       //声明一个顺序表
    InitList(L);    //初始化顺序表
    return 0;
}

顺序存储结构需要三个属性：

• 存储空间的起始位置：数组data
• 线性表的最大存储容量：数据长度MAXSIZE
• 线性表的当前长度：length

一维数组可以是静态分配，也可以是动态分配。

顺序表的动态存储

#defined InitSize 100 #表长度的初始定义
typedef struct{
	ElemType *data;   //指示动态分配数组的指针
	int MaxSize,length;

初始动态分配语句为：

L.data = (ElemType*)malloc(sizeof(ElemType)*InitSize);
//(ElemType*) 因为malloc返回一个指针，需要强制转型为定义的数据元素类型的指针
//malloc函数的参数 需要指明分配多大的存储空间

动态分配不是链式存储，它同样属于顺序存储结构，物理结构没有变化，依然是随机存储方式，只是分配的空间大小可以在运行时动态决定。

#include <stdlib.h>
#define InitSize 10  //默认的最大长度
typedef struct{
    int *data;          //用“静态数组”存放数据元素
    int MaxSize;        //顺序表的最大容量
    int length;          //顺序表当前长度
}SqList;                //顺序表类型定义

// 基本操作——初始化一个顺序表
void InitList(SqList &L){
    L.data = (int *)malloc(InitSize*sizeof(int));
    L.length = 0;
    L.MaxSize = InitSize;
}

//可动态增加数组的长度
void IncreaseSize(SqList &L, int len){
    int *p = L.data;
    L.data = (int *)malloc((L.MaxSize+len)*sizeof(int));
    for (int i=0; i< L.length; i++){
        L.data[i] = p[i];   //将所有数据元素复制到新区域
    }
    L.MaxSize = L.MaxSize + len;
    free(p);        //释放原来的空间
}

int main(){
    SqList L;       //声明一个顺序表
    InitList(L);    //初始化顺序表
    IncreaseSize(L,5)
    return 0;
}

顺序表的主要优点：
1、可进行随机访问。
2、存储密度高。
缺点：
1、元素的插入和删除都需要移动大量的元素。
2、顺序存储分配需要一段连续的存储空间，不够灵活。

顺序表的插入和删除

顺序表的插入

顺序表：用于存储位置的相邻来体现数据元素之间的逻辑关系

ListInsert(&L,i,e) 插入操作，在表L中的第i个位置上插入指定元素e。（i是位序）

#define MaxSize 10
typedef struct{
	ElemType data[MaxSize]; //用静态的“数组”存放数据元素
	int length;				//顺序表当前的长度
}SqList;					//顺序表的类型定义

void ListInsert(SqList &L,int i,int e){
	for(int j=L.length;j>=i;j--)	//将第i个元素及以后的元素向后移动
		L.data[j] = L.data[j-1]		
	L.data[i-1] = e;				//在位置第i个放入e
	L.length++;				//长度+1
}

int main(){
	SqList L;		//声明一个顺序表
	InitList(L);	//初始化顺序表
	ListInsert(L,3,3);	
	return 0;
}

好的代码应该具有“健壮性”。能够处理异常情况，并给使用者反馈。
下面代码中添加了插入位置的非法判断

#define MaxSize 10
typedef struct{
	ElemType data[MaxSize]; //用静态的“数组”存放数据元素
	int length;				//顺序表当前的长度
}SqList;					//顺序表的类型定义

bool ListInsert(SqList &L,int i,int e){
	if (i<1 || i>L.length+1)	//判断i的范围是否有效
		return false;
	if (L.length>=MaxSize)		//当存储空间已满，不能插入
		return false;
	for(int j=L.length;j>=i;j--)	//将第i个元素及以后的元素向后移动
		L.data[j] = L.data[j-1];		
	L.data[i-1] = e;		//在位置第i个放入e
	L.length++;				//长度+1
	return true;
}

int main(){
	SqList L;		//声明一个顺序表
	InitList(L);	//初始化顺序表
	ListInsert(L,3,3);	
	return 0;
}

插入操作的时间复杂度

最好的情况，就是插入元素在表尾，就不需要移动元素
i = n+1 循环0次，此时最好时间复杂度为O(1)。
最坏的情况，就是插入元素在表头，需要移动表中所有元素
i = 1，循环n次，此时最坏时间复杂度为O(n)。
平均情况，就是假设新元素插入到任何一个位置的概率相同，即i=1,2,3,……,length + 1的概率p都相同1/(n+1)
i = 1时，循环n次，
i=2时，循环n-1次，
i = 3时，循环n-2次
……
i = n+1时，循环0次
平均循环次数 = np + (n-1)p + (n-2)p + …… + 1*p = n/2
平均时间复杂度为O(n)。

顺序表的删除

ListDelete(&L,i,&e) 删除操作，删除表中第i个位置的元素，并使用e返回删除元素的值。（i是位序）

#define MaxSize 10
typedef struct{
	ElemType data[MaxSize]; //用静态的“数组”存放数据元素
	int length;				//顺序表当前的长度
}SqList;					//顺序表的类型定义

bool ListDelete(SqList &L,int i,int &e){
	if (i<1 || i>L.length+1)	//判断i的范围是否有效
		return false;
	e = L.data[i-1];
	for(int j=i;j<L.length;j++)	//将第i个元素及以后的元素向后移动
		L.data[j-1] = L.data[j];
	L.length--;				//长度+1
	return true;
}

int main(){
	SqList L;		//声明一个顺序表
	InitList(L);	//初始化顺序表
	int e = -1;		//用变量把删除的元素“带回来”
	if (ListDelete(L,3,e))
		printf("已删除第3个元素，删除的元素值为=%d\n",e);	
	else
		printf("位序i不合法，删除失败");
	return 0;
}

删除操作的时间复杂度

最好的情况，删除表尾元素，就不需要移动元素
i = n 循环0次，此时最好时间复杂度为O(1)。
最坏的情况，删除表头元素，需要移动表中所有元素
i = 1，循环n次，此时最坏时间复杂度为O(n)。
平均情况，就是假设新元素插入到任何一个位置的概率相同，即i=1,2,3,……,length + 1的概率p都相同1/n
i = 1时，循环n次，
i=2时，循环n-1次，
i = 3时，循环n-2次
……
i = n+1时，循环0次
平均循环次数 = np + (n-1)p + (n-2)p + …… + 1*p = (n-1)/2
平均时间复杂度为O(n)。

顺序表的查找

顺序表的按位查找

静态分配
GetElem(L;i)：按位查找操作。获取表中第i个位置的元素的值。

#define MaxSize 10
typedef struct{
	ElemType data[MaxSize];
	int length;
}SqList;

ElemType GetElem(SqList L, int i){
	return L.data[i-1];
}

动态分配
GetElem(L;i)：按位查找操作。获取表中第i个位置的元素的值。

#define InitSize 10
typedef struct{
	ElemType *data;
	int MaxSize;
	int length;
}SqList;

ElemType GetElem(SqList L, int i){
	return L.data[i-1];
}

若元素是int类型

#define InitSize 10
typedef struct{
	int *data;
	int MaxSize;
	int length;
}SqList;

void InitList(SqList &L){
	L.data = (int *)malloc(InitSize * sizeof(int));
	L.length = 0;
	L.MaxSize = InitSize;
}
int GetElem(SqList L, int i){
	return L.data[i-1];
}

按位查找的时间复杂度是O(1)
由于顺序表的各个数据元素在内存中连续存放，因此可以根据起始地址和书元素大小立即找到第i个元素——“随机存取”特性

顺序表的按值查找

LocateElem(L,e)：按值查找操作。在表L中查找具有给定关键字值的元素。

#define InitSize 10
typedef struct{
	ElemType *data;
	int MaxSize;
	int length;
}SqList;

int LocateElem(SqList L,ElemType e){
	for(int i=0; i<L.length;i++)
		if (L.data[i]==e)
			return i+1
	return 0;
}

按值查找的时间复杂度

最好情况：目标元素在表头
循环1次，最好的时间复杂度为O(1)
最坏情况：目标元素在表尾
循环n次：最坏时间复杂度为O(n)；
平均情况：假设目标元素出现在任意位置的概率都相同，都是1/n
计算平均循环次数是(n+1)/2，平均时间复杂度为O(n)