线性表概念及顺序表的相关操作

_线性表

1.定义

线性表是具有相同（每个数据元素所占空间一样大）数据类型的n（n≥0）个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为

L=(a₁,a₂,…,a_j,a_j+1,…,a_n)

几个概念：

a_i是线性表中的“第i个”元素线性表中的位序

a₁是表头元素：a_n是表尾元素。

除第一个元素外，每个元素有且仅有一个直接前驱：除最后一个元素外，每个元素有且仅有一个直接后继

2.线性表基本操作

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

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

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

ListDelete(&L,&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。

Tips：

①对数据的操作（记忆思路）————创销、增删改查

②C语言函数的定义 ———— <返回值类型>函数名{<参数1类型>参数1，<参数2类型>参数2，…}

③实际开发中，可根据实际需求定义其他的基本操作

④函数名和参数的形式、命名都可改变（Reference：严蔚敏版《数据结构》）

⑤什么时候要传入引用"&" ——对参数的修改结果需要“带回来”

顺序表

顺序表的定义

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

如何河道一个数据元素的的大小？

C语言sizeof(ElemType)

顺序表的实现——静态分配

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

大小确定之后不可改变

Q：如果“数组”存满了怎么办？

A：可以放弃治疗，顺序表的表长刚开始确定后就无法更改（存储空间是静态的）

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

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

Key：动态申请和释放内存空间

C —— malloc、free 函数

​ L.data = (ElemType *)malloc(sizeof(ElemType)*InitSie);

Tips：malloc函数返回一个指针，需要请回转型为你定义的数据元素类型指针

代码示例

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

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

void IncreaseSize(SeqList &L,int len) {
    int *p=L.data;
    L.data=(int *)malloc((L.MaxSize+len)*sieof*(int));
    for(int i=0;i<length;i++){
        L.data[i]=p[i];           // 将数据复制到新区域
    }
    L.MaxSize=L.MaxSize+len;     // 顺序表最大长度增加 len
    free(p)                      // 释放原来的内存空间
}
    

顺序表的特点

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

顺序表的基本操作——插入

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

插入操作的时间复杂度

bool ListInsert(SqList &L,int i ,int e){
	if(i<1||i>L.length+1)                  // 判断i的范围是否有效
		return false;
	if(L.ength>=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个元素全都向后移动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次，平均时间复杂度=O(n/2)

顺序表的基本操作——删除

代码示例

bool ListDelete(SqList &L,int i,int &e){
	if(i<1||i>L.length)
		return false;
	 e=L.data[i-1];
	 for(int j=i;j<L.length;j++)
	   L.data[j-1]=L.data[j];
	  L.length--;
	  return true;
}

删除的时间复杂度

最好情况：删除表尾元素，不需要移动其他元素 i=n，循环0次；最好时间复杂度=O(1)

最坏情况：删除表头元素，需要将后续的n-1个元素全都向前移动 i=1，循环n-1次；最坏时间复杂度=O(n);

平均情况：假设删除任何一个元素的概率相同，即i=1,2,3,…,length的概率都是p=1/n i=1，循环n-1次；i=2时，循环n-2次；i=3，循环n-3次 …i=n时，循环0次 平均时间复杂度=O(n)

顺序表的基本操作——查找

1.按位查找

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

代码示例：

1. 静态

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

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

2. 动态

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

按位查找的时间复杂度

时间复杂度为O(1)

注：

1. 一个int占4B
2. 一个ElemType占2000B

2.按值查找

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

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

// 在顺序表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的元素值等于e，返回其位序i+1
    return 0;                           // 退出循环，说明查找失败
}

按值查找的时间复杂度

最好情况： 元素在表头，最好时间复杂度=O(1)

最坏情况： 元素在表尾，最坏时间复杂度=O(n)

平均情况：平均时间复杂度=O(n)