【数据结构】二、线性表：1.顺序表的定义与实现（静态分配、动态分配）

线性表linear list

线性表是具有相同数据类型的n (n≥0）个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。
若用L命名线性表，则其一般表示为：
$$L=(a^1,a^2,...,a^i,a^i+1,...,a^n)$$

• $a^i$是线性表中的“第i个”元素线性表中的位序。
• $a^1$是表头元素；$a^n$是表尾元素。
• 除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继。
• 数据类型相同，每个数据元素所占空间一样大。

存储、物理结构：

1. 顺序表（顺序存储）
2. 链表（链式存储）
   • 单链表
   • 双链表
   • 循环链表
   • 静态链表

基本操作

InitList(&L)：初始化表。构造一个空的线性表L，分配内存空间。

DestroyList(&L)：销毁操作。销毁线性表，并释放线性表L所占用的内存空间。

Listinsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定元素e。

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

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

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

其他常用操作：

Length(L)：求表长。返回线性表L的长度，即L中数据元素的个数。

PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值。

Empty(L)：判空操作。若L为空表，则返回true，否则返回false。

1.顺序表

顺序表：用顺序存储的方式实现线性表。

顺序存储：把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。

所以，设线性表第一个元素的存放位置是LOC(L)

LOC 是 location 的缩写

那么，第二个元素就是LOC(L)+数据元素的大小；第三个元素就是LOC(L)+数据元素的大小*2

判断一个数据的大小：

sizeof(int) = 4B

1.1静态分配

静态分配的实现方式

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

具体代码：

#include <stdio.h>
#define MaxSize 10		//定义最大长度

typedef struct{	
	int data[MaxSize];	//用静态的"数组"存放数据元素
    int length;			//顺序表的当前长度（总长度）
}SaList;				//顺序表的类型定义


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

int main() {
    SqList L;		//声明一个顺序表L
    InitList(L);	//初始化顺序表L
    //....未完待续，后续操作
    return 0;
}

1.2动态分配

动态分配的实现方式

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

内存分配：

#include<stdlib.h>
int *p = (int*)malloc(sizeof(int));	//让系统为p选择一个内存空间。
//因为int大小是4，所以也等于
int *p = (int*)malloc(4);

free(p);	//释放

具体代码：

#include<stdlib.h>
#define InitSize 10 //默认的最大长度
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;
}