408计算机综合数据结构笔记--线性表（1）顺序表

408计算机综合数据结构笔记–线性表（1）顺序表

线性表的定义（逻辑结构）

线性表是具有相同数据类型的n$（n\ge 0）$个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表，若用L命名线性表，则其一般表示为：
$L=(a_1,a_2,....a_i,a_{i+1},...a_n)$
注解：
1）相同数据类型，表示每个数据元素占据的空间是相同的；
2）有限序列，数据元素的数量是有限的而且是按照一定的顺序排列的。
几个概念：
1）$a_i$是线性表中“第i个”元素线性表中的位序
2）$a_1$是表头元素，$a_n$是表位元素
3）除第一个元素外每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且只有一个直接后继。

线性表的操作（运算）

InitList(&L)：初始化表。创建一个空的线性表L，分配内存空间。
DestoryList(&L)：销毁操作。销毁线性表，并释放线性表L所占据的内存空间。

ListInsert(&L,i,e):插入操作。在表L中的第i个位置插入元素e.
ListDelete(&L,i,&e):删除操作。删除表L中第i个位置的的元素，并用e返回删除元素的值。

LocateElem(L,e):按值查找操作。在表L中查找具有给定关键字值e的元素。
GetElem(L,i):按位查找操作。获取表L中第i个位置的元素的值。

其它常用操作：
Length(L):求表长。返回线性表L的长度，即L中数据元素的个数。
PrintList(L):输出操作。按前后顺序输出线性表L的所有元素值。
Empty(L):判空操作。若L为空表，则返回true,否则返回false。

线性表的两种存储结构

顺序表（顺序存储）和链表（链式存储）

顺序表

顺序表的定义

顺序表–用顺序存储的方式实现线性表
顺序存储。把逻辑上相邻的元素存储在物理位置也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。

顺序表的实现

静态分配

#denfine MaxSize 10                   //定义最大长度
typedef struct{
	ElemType data[MaxSize];   //用静态的数组存放数据元素
	int length;               //顺序表的当前长度
}SqList                       //顺序表的类型定义（静态分配方式）

1）
其中的“ElemType”表示数据类型，具体实现的按照需要使用int,float等基本数据类型或者自定义的数据类型来替换。
2）
给各个元素分配连续的存储空间，大小为MaxSize*sizeof(ElemType.)
示例

#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;

}

动态分配

#define InitSize 10 //顺序表的初始长度
typedef struct{
	ElemType* data;  //指示动态分配数组的指针
	int MaxSize;    //顺序表的最大容量
	int length;     //顺序表的当前长度
}SeqList           //顺序表的类型定义

c语言中通过malloc和free函数来实现内存空间的动态申请和释放。
malloc会申请一整片连续的内存空间，返回一个指向该内存空间起始地址的指针。
比如：

SeqList L;
L.data = (ElemType*)malloc(sizeof(ElemType)*InitSize);

1)申请的连续空间大小为sizeof(ElemType)InitSize，用设定变量ElemType的大小乘以初始长度。
2）返回的指针类型的值赋给L.data，所以需要用*(ElemType*)将malloc返回的指针强制类型转换**成和data一样的类型
示例

#include<stdio.h>
#define InitSize 10 //顺序表的初始长度
typedef struct{
	int* data;  //指示动态分配数组的指针
	int MaxSize;    //顺序表的最大容量
	int length;     //顺序表的当前长度
}SeqList 

void InitList(SeqList &L){
	//用malloc动态申请一片空间
	L.data = (int*)malloc(sizeof(ElemType)*InitSize);
	L.length=0;
	L.MaxSize = InitSize;
}
void IncreasingSize(SeqList &L,int len){
	int *p = L.data;
	L.data = (int*)malloc(sizeof(int)*(L.MaxSize+len));
	for(int i=0;i<L.length;i++){
		L.data[i]=p[i];//将数据复制到新区域
	}
	L.MaxSize = L.MaxSize+len;//原来的最大长度增加len
	free(p);释放原来的空间
}
int main(){
	SeqList L;
	InitList（L)；
	......
	//...随便往动态表里面插几个数字
	IncreasingSize(L,5);//长度加5
	return 0;
}

关于void IncreasingSize(SeqList &L,int len)即对动态表L增加len个长度。
1）首先将原本空间的首地址传给p;即int p = L.data;
2）申请一个比原本空间长len的新空间并且将新空间的首地址返回给L.data,即 L.data = (int)malloc(sizeof(int)*(L.MaxSize+len));
3）for循环中的内容即是将原来空间的内容放到新空间里面。
4）最后将最大长度更新，并且，释放原来的空间

顺序表的特点

1）随机访问，即可以在O(i)时间内找到第i个元素
2）存储密度高，每个节点只存储数据元素。
3）拓展容量不方便，静态分配无法实现拓展容量，动态分配在拓展容量的时候时间复杂度也比较高。
4）插入删除不方便，需要移动大量的元素

顺序表的操作–插入

#include <stdio.h>
#define MaxSize 10
typedef struct{
	int data[MaxSize];   //用静态的数组存放数据元素
	int length;               //顺序表的当前长度
}SqList
bool ListInset(SqList &L,int i,int e){
	if(i<1||i>L.length+1)
	return fales;
	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;
}

注意：

1. void ListInset(SqList &L,int i,int e)中的i是顺序表的位序，即第i个，因为在数组里面操作，第i个元素在数组的下标是i-1。
2. 由于顺序表的元素位置是相邻的，因此插入的位置不能超过现有长度，且如果该线性表已经被填满，也不可以插入。
   时间复杂度分析：
   问题规模n=L.length
   最好情况：新元素插到表尾，任何元素都不需要移动
   i=n+1，循环0次：最好时间复杂度：$=O(1)$
   最坏情况：新元素插到表头，所有元素都需要往后移动
   i=1;循环n次：最坏时间复杂度：$=o(n)$
   平均情况：新元素插到任意位置的概率都相同，即i=1,2,3…L.length+1的概率$p=\frac{1}{n+1}$
   i=1，循环n次；
   i=2，循环n-1次；
   i=3，循环n-2次；
   。。。
   i=n+1，循环0次
   平均循环次数：$=(n+(n-1)+(n-2)+...+0)p=\frac{n(n+1)}{2}\frac{1}{n+1}=\frac{n}{2}$
   因此，平均时间复杂度$=O(n)$

顺序表的操作–删除

bool ListDelet(SqList &L,int i,int &e){
	if(i<1||i>L.length)//判断i是否为有效范围
		return fales;
	e=L.data[i-1];//将被删除的元素赋给e
	for(int j=i;j<L.length;j++)//将第i个位置后的元素前移
		L.data[j-1]=L.data[j];
	L.length--; // 线性表长度减一
	return true;
}

顺序表的操作–查找

按位查找

//静态分配的查找
ElemType GetElem(SqList L,int i){
	return L.data[i-1];
}
//动态分配的查找
ElemType GetElem(SeqList L,int i){
return L.data[t-1];
}

线性表的按位查找都可以直接返回要查找的值，所以时间复杂度为O(1);

按值查找

//在顺序表中找到第一个值为e的元素，并且返回其位序
int LocateElem(SeqList L,ElemType e){
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)
			return i+1;
	return 0; //退出循环查找失败
}

注意这种比较方式只适合基本数据类型，不适合结构数据类型。
如果是结构类型，比如：

typedef struct{
	int num;
	int people;
}Customer
//判断
void test(){
	Customer a,b;
	......
	//判断
	if(a.num==b.num&&a.people==b.people)
	printf("相等");
	else
	printf("不相等");
}

时间复杂度：最好：O(1);
最坏：O(n);
平均：O(n);
计算方法与上述一样。