数据结构（1）线性表->顺序表

• 整理数据结构学习笔记
• 基于C++

---

一、线性表

1、定义

• 线性表是n个元素的有限序列，同一线性表中的元素必定具有相同的特性
• 通常将线性表记为（A1,A2,A3…Ai-1,Ai,Ai+1…An）
• Ai-1是Ai的“前驱”
• Ai+1是Ai的“后继”
• 表中元素个数n为线性表的“长度”，n=0时称“空表”
• i为数据元素Ai在表中的“位序”（注意位序是从1开始的）

2、线性数据结构的特点

• 存在唯一的被称为“第一个”的数据元素
• 存在唯一的被称为“最后一个”的数据元素
• 除第一个元素外，每个元素有且只有一个“前驱”
• 除最后一个元素外，每个元素有且只有一个“后继”

3、抽象数据类型定义

ADTList{
	//数据对象：D=Ai（i=1,2,3...n）
	//基本操作：
		1、InitList(&L)     		     //初始化，构造一个空表
		2、DestroyList(&L)  		     //销毁线性表
		3、ClearList(&L)      			 //将表重置为空
		4、ListEmpty(L)   				 //返回表是否为空
		5、ListLength(L)  				 //返回表中元素个数
		6、GetElem(L,i,&e)  			 //用e返回表中位序为i的元素值
		7、LocateElem(L,e)  			 //返回和e相等的第一个元素的位序，若不存在则返回0
		8、PriorElem(L,cur_e,&pre_e)	 //cur_e是表中元素且非第一个，用pre_e返回其前驱
		9、NextElem(L,cur_e,&next_e)	 //cur_e是表中元素且非最后一个，用next_e返回其前驱
		10、ListInsert(&L,i,e)   		 //在L中位序为i处插入元素e,L长度+1
		11、ListDelet(&L,i,&e)  		 //删除L中位序为i的元素，用e返回其值，L长度-1
		12、ListTraverse(L,visit())		 //遍历表L，对每个元素进行visit()操作
}ADT List

二、线性表的顺序表示和实现

1、定义&特点

• 线性表的顺序表示，是利用一组连续的存储单元依次存储数据元素，称这种线性表为“顺序表”
• 表中相邻元素Ai和Ai+1在内存中也有相邻的存储位置
• 只要确定起始位置，线性表中任一数据都可随机存取
• 通常利用动态申请的一维数组实现
• 示意图如下：
  

2、顺序表的存储结构

#define LIST_INIT_SIZE 100
#define LIST_INCREMENT 10

#define OVERFLOW -1
#define Error 0
#define OK 1

//顺序表的存储结构
typedef struct {
	int *Elem;//基地址
	int Length;//当前长度 
	int ListSize;//当前分配存储容量 
}SqList;

3、顺序表的实现

• 以数据元素类型为int型为例

（1）初始化 void InitList(&L)

• 申请LIST_INIT_SIZE大小空间，使表基地址指向它即可

//1、初始化线性表 
void InitList(SqList &L)
{
	L.Elem = (int *) malloc(LIST_INIT_SIZE*sizeof(int));
	if(!L.Elem)//分配空间失败
		exit(OVERFLOW);
	L.Length = 0;
	L.ListSize = LIST_INIT_SIZE;
}

（2）销毁 void DestroyList(&L)

• 释放空间，长度&容量设为0

//2、销毁线性表 
void DestoryList(SqList &L)
{
	free(L.Elem);
	L.Elem=NULL;
	L.Length = 0;
	L.ListSize = 0;
}

（3）清空 void ClearList(&L)

• 直接将L.Length设为0即可
• 注意与销毁表区分，清空表不需要释放空间
• 由于重新向表中插入元素时会复写数据，故清空表只需改写表长，不需把原有数据清0

//3、重置为空表 
void ClearList(SqList &L)
{
	L.Length = 0;
	L.ListSize = LIST_INIT_SIZE;
}

（4）查询是否为空表 bool ListEmpty(L)

• 判断表长L.Length,返回true或false

//4、返回线性表是否为空
bool  ListEmpty(SqList L)
{
	if(L.Length==0)
		return true;
	else
		return false;
}

(5)返回表长 int ListLength(L)

• 顺序结构存储时，直接用L.Length即可；链式存储时多用此函数

//5、返回表中元素个数 
int ListLength(SqList L)
{
	return L.Length; 
}

(6)获取表中位序为i的数 int GetElem(SqList L,int i,int &e)

• 利用指针找到Ai元素返回即可
• 用e返回数据元素Ai，e的类型应与数据元素类型相同
• 函数返回值代表操作成功与否（OK->1; Error->0）

//6、获取表中位序为i（第i个）的数 
int GetElem(SqList L,int i,int &e)
{
	if(i<1 || i>L.Length)//非法参数 
		return Error;
	else
		e = *(L.Elem+i-1);
	
	return OK;
}

（7）获取表中第一个值为e的元素的位序 int LocateElem(SqList L,int e)

• 遍历线性表，依次与e比较，相等则返回位序
• 若没有查到，返回0

//7、获取表中第一个值为e的元素的位序 
int LocateElem(SqList L,int e)
{
    int *p;
    for(p=L.Elem;p<L.Elem+L.Length;p++) 
    {
    	if(*p==e)
    		return p-L.Elem+1;
    }	
    return 0;
}

（8）返回cur_e的前驱 int PriorElem(SqList L,int cur_e,int &pre_e)

• 调用LocateElem找到cur_e位置，用GetElem得其前驱并返回
• 用pre_e返回前驱元素，pre_e的类型应与数据元素类型相同
• 函数返回值代表操作成功与否（OK->1; Error->0）

//8、返回cur_e的前驱 
int PriorElem(SqList L,int cur_e,int &pre_e)
{
	int i=LocateElem(L,cur_e);
	if(i==1)
		return Error;
	else
		GetElem(L,i-1,pre_e);
	return OK;
}

（9）返回cur_e的后继 int NextElem(SqList L,int cur_e,int &next_e)

• 调用LocateElem找到cur_e位置，用GetElem得其后继并返回
• 用next_e返回后继元素，next_e的类型应与数据元素类型相同
• 函数返回值代表操作成功与否（OK->1; Error->0）

//9、返回cur_e的后继 
int NextElem(SqList L,int cur_e,int &next_e)
{
	int i=LocateElem(L,cur_e);
	if(i==L.Length)
		return Error;
	else
		GetElem(L,i+1,next_e);
	return OK;
}

（10）在第i位插入元素 int ListInsert(SqList &L,int i,int e)

• 找到插入位置，将其后元素依次后移，再插入e，表长度+1，复杂度o(n)
• 注意超过表容量时，realloc干三件事：申请新空间，拷贝数据，释放原空间
  

//10、在第i位插入元素e 
int ListInsert(SqList &L,int i,int e)
{
	if(i<1 || i>L.Length+1)//非法参数 
		return Error;
	if(L.Length>=L.ListSize)//空间不足 
	{
		int *newbase = (int *)realloc(L.Elem,(L.Length+LIST_INCREMENT)*sizeof(int));
		if(!newbase)
			exit(OVERFLOW);
		L.Elem = newbase;
		L.ListSize += LIST_INCREMENT;
	}
	
	int *q = L.Elem+i-1;//插入位置 
	for(int *p=L.Elem+L.Length-1;p>=q;p--)//移动元素
		*(p+1)=*(p);
	*q=e;
	L.Length++;
	return OK;
}

（11）删除第i位元素 int ListInsert(SqList &L,int i,int &e)

• 先用e获取被删除元素值
• 找到删除位置，将其后元素依次前移，表长度-1，复杂度o(n)
  

int ListDelet(SqList &L,int i,int &e)
{
	if(i<1 || i>L.Length)
		return Error;
	int *p = L.Elem+i-1;
	e=*p;
	for(int *q=L.Elem+i-1;q<=L.Elem+L.Length-1;q++)
		*q=*(q+1);
	
	L.Length--;
	return OK;	
}

（12）遍历线性表，并对每个元素进行visit操作 void ListTraverse(L,visit())

• 遍历线性表，利用函数指针依次调用visit()

//12、遍历线性表，并对每个元素进行visit操作 
void ListTraverse(SqList L,void (*visit)(int a))
{
	for(int *p=L.Elem;p<=L.Elem+L.Length-1;p++)
		visit(*p);
}

//以输出形参为例
void Visit(int a)
{
	cout<<a<<endl;
}

//调用时这样写
ListTraverse(List,Visit);

三、线性表顺序存储结构优缺点分析

1、优点：

• 无需为表示结点间的逻辑关系而增加额外的存储空间；

• 可方便地随机存取表中的任一元素。

2、缺点：

• 插入或删除运算不方便，除表尾的位置外，在表的其它位置上进行插入或删除操作都必须移动大量的结点，其效率较低；

• 由于顺序表要求占用连续的存储空间，存储分配只能预先进行静态分配。因此当表长变化较大时，难以确定合适的存储规模。

3、时间复杂度对比

项目	顺序表	链式表
存取	o(1)	o(n)
插入	o(n)	o(1)
删除	o(n)	o(1)

四、其他相关算法

1、建表

• 输入表长n和n个数据，建立线性表

//输入n个元素，建立线性表 
void CreatList(SqList &L,int n)
{
	InitList(L);
	int a;
	SqList *p;
	for(int i=0;i<n;i++)
	{
		cin>>a;
		L.Elem[i]=a;
		L.Length+=1; 
	} 
} 

2、表中元素依次非递减有序，插入x并保持有序性

void Insert(SqList &L,int x)
{
	int i=1;
	while(i<=L.Length && *(L.Elem+i-1)<x)
		i++;
	ListInsert(L,i,x);
}