DS 0819（第二章 顺序表）

线性表

数据结构三要素

1. 定义：线性表是具有相同数据类型的n个数据元素的有限数列每个数据所占的储存空间一样大，有次序，其中n为表长，当n=0时线性表是一个空表

注：

1. 若用L命名线性表，一般表示为L=（a1，a2，…an）;
2. ai是线性表中的第i个，i是位序
3. a1是表头元素，an是表尾元素
4. 除去首尾元素，每个元素都有一个直接前驱和直接后继
5. 位序从1开始，数组从0开始

线性表的基本操作（liner list）

 1. InitList(&L) :初始化表。构造一个空的线性表。分配内存空间
 2. DestoryList(&L)：销毁操作。销毁线性表，并释放线性表L所占的内存空间

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

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


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

1. 对数据的操作：增删查改
2. C语言函数的定义----<返回值类型>函数名（<参数1类型>参数1，。。。）
3. 实际开发中，可根据 其他的需求定义其他的操作
4. 函数名，参数的形式，命名都可以改变（reference：严）
5. 什么时候要传入引用&-----当对参数的修改结果需要带回来。

#include<stdio.h>

void test(int x){
	x=1024;
	printf("test 函数内部x=%d\n",x);
}

int main(void){
	int x=1;
	printf("调用test前x=%d\n",x);
	test(x);
	printf("调用test函数后x=%d\n",x);
}

//c++
#include<stdio.h>

void test(int &x){
	x=1024;
	printf("test 函数内部x=%d\n",x);
}

int main(void){
	int x=1;
	printf("调用test前x=%d\n",x);
	test(x);
	printf("调用test函数后x=%d\n",x);
}

为什么要实现对数据结构的基本操作

1. 定义的数据结构，要让别人能够很方便的使用
2. 避免重复工作，降低出错风险

线性表的定义

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

sizeof（Elem Type）—》sizeof（int）=4b

顺序表的实现—静态分配

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

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

int main(void){
	SqList L;
	InitList(L);
	
	//后续操作
	
	return 0; 
}

注

1.静态分配的顺序表的表长确定后就无法更改

顺序表的实现------动态分配

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

动态申请和释放内存空间

1. C—malloc，free函数
2. malloc可以申请一整片连续的存储空间
   L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);; //存放10个int所需的类型大小
   malloc函数返回一个指针（指向连续空间的首地址），需要将其强制转换为所定义的数据类型的指针类型
3. C+±–new，delete关键字

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

void InitList(SeqList &L){
	//用malloc函数申请一片连续的存储空间
	L.data=(int *)malloc(InitSize*sizeof(int));
	L.length=0;
	L.MaxSize=InitSize; 
} 

//增加动态数组的长度
void IncreaseSize(SeqList &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;			//顺序表最大长度增加len 
	free(p);							//释放原来的内存空间 
} 

int main(){
	SeqList L;   //声明一个顺序表
	InitList(L);  //初始化顺序表
	//往顺序表中顺表添加几个元素 
	IncreaseSize(L,5);
	return 0; 
} 

顺序表的特点

1. 随机访问：即可以在O（1）时间内找到第i个元素
2. 存储密度高，每个结点只存储数据元素
3. 扩展容量不方便：静态分配不可以扩展，动态分配扩展长度的时间复杂度也比较高
4. 插入删除操作不方便，需要移动大量元素

顺序表的基本操作

插入
LIstInsert（&L，i，e）：插入操作。在表中第i个位置是插入指定元素e。

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

void ListInsert(SqList &L,int i,int e){
	for(int j=L.length;j>=i;j--)
	L.data[j]=L.data[j-1];
	L.data[i-1]=e;
	L.length++;
}

int main(){
	SqList L;  //声明一个新顺序表
	InitList(L);
	// 此处省略插入几个元素的代码
	ListInsert(L,3,3);
	return 0; 
}

**代码健壮性调整，**防止插入的数据位序超出范围，或者当前储存空间已满

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

时间复杂度分析
最好情况：新元素插入到表尾，不需要移动元素，i=n+1，循环0次，最好时间复杂度为O(1)
最坏情况：新元素插入到表头，需要将原有的n个元素全部后移，循环n次，O(n)
平均情况：假设插到每个位置的概率相同p=1/n+1
n+n-1+n-2.。。。+1）*p=n/2 所以O（n）

删除操作
LIstDelete(&L,i,&e):删除表中第i个位置的元素，并用e返回删除元素的值

bool ListDelete(SqList &L,int i,int &e){
	if(i<1||i>L.length)				//判断i的范围是否有效 
	return false;
	e=L.data[i-1];					//将被删除的元素值赋给e 
	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; //用变量e把删除的元素带回来
	if(ListDelete(L,3,e))
	printf("已删除第3个元素，删除元素值为%d\n",e);
	else
	printf("位序不合法，删除失败")；
	return 0; 
}

时间复杂度分析

平均情况：概率相同P=1/n；
n-1+n-2+。。。0）*1/n=（n-1）/2，，，O（n）

按位查找、
GetElem（L，i）：按位查找操作，获取L中第i个位置的元素的值

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

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

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

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

时间复杂度 O（1）：顺序表的各个元素在内存中连续存放，因此可以根据起始地址和数据元素大小立即找到第i个元素—随机存取的特性

**按值查找：**在表L中查找具有给定关键字值的元素

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

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

//在顺序表L中查找第一个元素值等于e的元素，并返回他的位序
int LocateELem(SeqList L,ElemType e){
	for(int i=0;i<L.length;i++)
	if(L.data[i]==e)
	return i+1;    //数组下标为i，则其位序为i+1 
	return 0;		//退出循环说明查找失败 
} 

注：==符号不可以对比连个结构体，智能一个一个比较，或者在c++中比较

**时间复杂度：**O（n）