线性表 Linear List

线性表 Linear List

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

线性表是具有相同数据类型的n（n>=0）个数据元素的有限序列，其中n为表长，当n=0是线性表是一个空表。若用L命名线性表，则其一般表示为：
$$L=(a_1,a_2,a_3,...,a_i,...,a_n)$$
几个概念：

• 每个数据元素所占空间一样大
• a_i是线性表中的“第i个”元素线性表中的位序（从1开始，但是在数组中从0开始）
• a₁是表头元素，a_n是表尾元素
• 除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后驱

---

线性表的基本操作（运算）

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

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

ListInsert(&L,i,e):插入操作。在i处插入e。

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

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

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

其他常用操作：

Length(L):求表长。返回线性表L的长度。

PrintList(L):输出操作。输出L中所有元素值

Empty(L):判空操作。若L空，返回True，否则返回False。

什么时候要传入参数的引用“&”—对参数的修改结果要带回来时，如以下两种情况：

#include <stdio.h>
void test(int x){
	x=1024;
	printf("%d\n",x);
}

int main()
{
   int x=5;
	printf("%d\n",&x);
	test(x);
	printf("%d\n",&x);
}

该代码执行的结果为：5 1024 5，因为在函数test中的x只是主函数中x的替代品，修改x的值只将替代品x修改，并无法传回主函数中。如果我们需要在函数中修改x的值，就需要使用引用“&”，如下程序：

#include <stdio.h>
void test(int &x){
	x=1024;
	printf("%d\n",x);
}

int main()
{
   int y=5;
	printf("%d\n",y);
	test(y);
	printf("%d\n",y);
}

---

存储/物理结构

顺序表（顺序存储）

顺序表的定义

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

如果第一个线性表存放的位置是LOC(L),则第二个元素存放的位置是LOC(L)+sizeof(L),第三个元素存放的位置是LOC(L)+2*sizeof(L)，以此类推。

顺序表的实现–静态分配

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

给各个数据元素分配连续的存储空间，大小为MaxSize*sizeof(ElemType)

具体实现：

#include<stdio.h>
#define MaxSize 10
typedef struct{
   	int data[MaxSize];  //用静态的”数组“存放数据元素
    int length;  //顺序表当前长度
}SqList;    //顺序表类型定义

// 基本操作--初始化一个顺序表
void InitList(SqList &L){
    L.length=0; //顺序表的厨师长度为0
}
int main(){
    SqList L;  //声明一个顺序表
    InitList(L); //初始化顺序表
    //尝试“违规”打印整个data数组
    for(int i=0,i<MaxSize;i++)
        printf("data[%d]=%d\n",i,L.data[i]);
    // 合法打印
    //循环的次数应该是L的长度，这样的话L表中已被赋值的元素就会正常显示，而未被赋值的元素就不会显示，这样在初始化时就可以不用对L.data数组进行赋初始值，避免了脏数据，同时也证明了L.length必须赋予初始值！若L.length未初始化，可能出现脏数据，造成循环异常。
    for(int i=0;i<L.length;i++)  
       printf("data[%d]=%d\n",i,L.data[i]); 
    return 0;
}

脏数据：当定义一个数组但未给予初始值时，输出数组可能输出奇怪的数据，这些数据可能是遗留在内存中的数据。在初始化顺序表时，如果不给予初始化L.length,可能导致出现脏数据。

使用静态分配的方法不可控制线性表的长度，线性表长度短可能不够用，线性表长度则造成内存空间浪费。所以我们可以采用动态分配的方式来创建一个线性表。

顺序表的实现–动态分配

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

**key：**动态申请和释放空间

malloc、free函数

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

malloc函数返回一个指针，需要强制转型你定义的数据元素类型指针

分配空间大小即ElemType大小×顺序表的初始长度

以下来具体实现：

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

//初始化
void InitList(SeqList &L){
    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;
    free(p);
}

int main(){
    SeqList L;
    InitList(L);
    IncreaseSize(L,5);
    return 0;
}

顺序表的特点

• 随机访问，即可以在O(1)时间内找到第i个元素
• 存储密度高，每个节点只存储数据元素，链表除了数据元素还要存指向下一个元素的指针
• 拓展容量不方便（即便采用动态分配的方式实现，拓展长度的时间复杂度也很高）
• 插入、删除操作不方便

顺序表的基本操作

插入

#define MaxSize 10
typedef struct{
   	int data[MaxSize];  //用静态的”数组“存放数据元素
    int length;  //顺序表当前长度
}SqList;    //顺序表类型定义
bool ListInsert(SqList &L,int i,int e){
    if(i<1||i>L.length+1)
        return false;
    if(L.length>=MaxSize)
        return false;
    for(int j=L.length;j>=i)
        L.data[j]=L.data[j-1]；
	L.data[i-1]=e;
    L.length++;
    return true;
}

时间复杂度：

最好情况：新元素插入到表尾，不需要移动元素，最好时间复杂度=O(1)

最坏情况：新元素插入到表头，所有元素都要移动，最坏时间复杂度=O(n)

平均情况：假设新元素插入到任何一个位置的概率相同，平均时间复杂度=O(n/2)=O(n)

删除

bool ListDelete(SqList &L,int i,int &e){
    if(i<1||i>L.length) //判断i的范围是否有效
        return false;
    e=L.data[i-1];   //将被删除元素给e，e使用引用，将e“带出去”
    for(int j=i;j<L.length;j++)
        L.data[j-1]=L.data[j];
    L.length--;
    return true;
}
int main(){
    SqList L;
    InitList(L);
    int e=-1;
    if(ListDelete(L,3,e))
        printf("已删除第3个元素，删除的元素值=%d\n",e);
    else:
    	printf("位序i不合法，删除失败\n");
    return 0;
}

时间复杂度：

最好情况：删除表尾元素，O(1)

最坏情况：删除表头元素，O(n)

平均情况：假设删除任何一个元素的概率相同，O(n)

查找

• 按位查找

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

由于顺序表的各个数据元素在内存中连续存放，因此可以根据起始地址和数据元素大小立即找到第i个元素–“随机存取“特性。

直接按照下标来查找

时间复杂度=O(1)

• 按值查找

LocateElem(SeqList L,ElemType e){
    for(int i=0;i<L.length)
        // 基本数据类型：int、char、double、float等可以直接用运算符”==“比较
        if(L.data[i]==e) 
            return i+1;
    return 0;
}

最好时间复杂度=O(1)(循环一次)

最坏时间复杂度=O(n)(循环n次)

平均时间复杂度=O(n)(平均循环次数=(n+1)/2)

链表

转笔记链表！