数据结构笔记二——线性表

2.1线性表的定义和基本操作

2.1.1 线性表的定义

线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长，当n=0时，线性表是一个空表。若用L命名线性表，则其一般表示为：L=(a1,a2,……,an)

式中，a1是唯一的“第一个”数据元素，又称表头元素；an是“最后一个”数据元素，又称表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继（“直接”二字可以省略，无伤大雅）。

【线性表是一种线性有序的逻辑结构】

线性表特点如下：

• 表中元素的个数有限；

• 表中元素具有逻辑上的顺序性，表中元素有其先后顺序；

• 表中元素都是数据元素，每个元素都是单个元素；

• 表中元素的数据类型都相同，这意味着每个元素占有相同大小的存储空间；

• 表中元素具有抽象性，即仅讨论元素间的逻辑关系，而不考虑元素究竟表示什么内容。

（注：时刻要记住，线性表是逻辑结构，表示元素之间一对一的相邻关系；顺序表和链表是存储结构，勿混淆概念）

2.1.2 线性表的基本操作

【一个数据结构的基本操作是指其最核心、最基本的操作。其他较复杂的操作可通过调用其基本操作来实现】

• InitList(&L):初始化表，构造一个空的线性表；

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

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

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

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

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

• PrintList(L):输出操作，按前后顺序输出线性表L的所有元素值；

• Empty(L):判空操作，若L为空表，则返回true，否则返回false；

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

【助记小tip：其中对表L本身进行的更改（初始化、插入、删除、销毁）会涉及到“&”，往后学习的数据结构也有相同规律；删除值操作，将所需删除的值返回给了“e”，也用到“&”。】

2.2 线性表的顺序表示

2.2.1 顺序表的定义

线性表的顺序存储又称为顺序表（存储结构）。

它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理上也相邻。

第1个元素存储在顺序表的起始位置，第i个元素的存储位置后面紧接着存储第i+1个元素，称i为元素ai在顺序表中的位序。

【顺序表特点：表中元素的逻辑顺序与其存储的物理顺序相同。】

假设顺序表L存储的起始位置为LOC(A)，sizeof(ElemType)是每个数据元素所占用存储空间的大小，如同：

每个数据元素的存储位置和顺序表的起始位置相差一个和该数据元素的位序成正比的常数（即数据类型的单位空间），因此，顺序表中的任意一个数据元素都可以随机存取，所以线性表的顺序存储结构是一种随机存取的存储结构。

【随机存取：就是直接存取，可以通过下标直接访问该数据，而不需要经过前面的数据，直接对它操作。与其相对的就是顺序存取】

在高级程序设计语言中，线性表的顺序存储结构用数组实现。（线性表中元素位序从1开始，数组中元素下标是从0开始。）

假定线性表的元素类型为ElemType，则静态分配的顺序表存储结构描述为：

#define Maxsize 50              //定义线性表的最大长度
typedef struct{
    ElemType data[Maxsize];     //顺序表的元素
    int length;                 //顺序表的当前长度
}SqList;                        //顺序表的类型定义

【一维数组可以是静态分配，也可以是动态分配的。】

• 静态分配时，数组的大小和空间事先固定，一旦空间占满，再加入新数据会导致溢出，进而导致程序崩溃（一锤子买卖）；

• 动态分配时，存储数组的空间再程序执行过程中通过动态存储分配语句分配的，一旦数据空间占满，就另外开辟一块更大的存储空间，将原表中的元素都拷贝到新空间，再加入新元素，这样就达到了扩充数组存储空间的目的，不是一次性地划分所有空间。

动态分配的顺序存储结构：

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

//C语言初始动态分配语句为
L.data = (ElemType*)malloc(sizeof(ElemType)*InitSize);
//C++的初始化动态分配语句为
L.data = new ElemType[InitSize];

【注意！！！顺序表的动态分配并不是链式存储，它仍属于顺序存储结构，物理结构没有变化，依然满足随机存储方式，只是分配的空间大小可以在运行时动态决定。】

顺序表的主要优点：

• 可以随机访问：通过首地址和元素序号可以在O(1)时间内找到指定元素；

• 存储密度高：每个节点只存储数据元素。

顺序表的缺点：

• 元素的插入和删除需要移动大量的元素，插入操作平均需要移动n/2个元素，删除操作平均需要移动（n-1）/2个元素；

  【这是存取后的操作，并不可以否定随机存取的优越性^.^】

• 顺序存储分配需要一段联系的存储空间，灵活性较差。

2.2.2顺序表上部分基本操作的实现（伪代码）

1.顺序表的初始化

#define InitSize 10 //定义最⼤长度
typedef struct {
 int data[InitList];
 int length;
}SqlList;//静态分配
​
typedef struct {
 int *data;
 int length; //当前长度
 int MaxSize;//最⼤长度
}SqlList;//动态分配

静态：静态分配在声明一个顺序表时，就已经为其分配了数组空间，因此初始化时只需要将顺序表的当前长度设为0；

//Sqlist L;//声明一个顺序表
void InitList(SqList &L){
    L.length = 0;//顺序表初始长度为0
}

动态：动态分配的初始化为顺序表分配一个预定义大小的数组空间，并将顺序表的当前长度设为0，MaxSize指示顺序表当前分配的存储空间大小，一旦因插入元素而空间不足，就再进行分配。

void InitList(SeqList &L){
//分配存储空间
    L.data = (ElemType *)malloc(MaxSize * sizeof(ElemType));
    L.length = 0;
    L.MaxSize = InitSize;
}

2.插入操作

再顺序表L的第i个位置插入新元素e。考虑其健壮性，当i输入不合法，返回false，表示插入失败；输入合法时，第i个元素及其后面元素一次向后移动一位，将位置i空间插入新元素，同时表长加1，返回true表示插入成功。

bool ListInsert(SqList &L,int i,ElemType e){
    if(i<1||i>L.length+1)
    {
        return false;
    }
    if(L.length>=MaxSize)
        return false;
    for(int j=L.length;j>=i;j--)
        L.data[j]=L.data[j-1];
    L.data[i-1]=e;//注意数组下标与位置的区别
    L.length++;
    return true;
}

分析：

• 最好情况：在表尾插入（i=n+1）,元素后移语句不需要执行，时间复杂度为O(1);

• 最坏情况：表头插入（i=1），后移语句执行n次，时间复杂度O(n);

• 平均情况：平均移动次数为n/2（参杂概率的计算问题），时间复杂度O(n)。

总结，插入操作时间复杂度O(n)

3.删除操作

删除第i个位置元素，将其返回到引用变量e中。同插入操作，也对非法输出进行return false；合法输入，元素前移，同时表长减1，return true.

bool ListDelete(SqList &L,int i,ElemType &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;
}

分析：

• 最好情况：删除表尾元素,元素前移语句不需要执行，时间复杂度为O(1);

• 最坏情况：删除表头元素，前移语句执行n-1次，时间复杂度O(n);

• 平均情况：平均移动次数为（n-1）/2（参杂概率的计算问题），时间复杂度O(n)。

总结，插入操作时间复杂度O(n)

4.按值查找（顺序查找）

在顺序表L中查找第一个元素等于e的元素，并返回其位序。

int LocateElem(SqList L,ElemType e){
    int i;
    for(i=0;i<L.length;i++)
        if(L.data[i]=e)
            return i+1;
    return 0;
}

分析：

• 最好情况：表头就是，仅仅比较一次，O(1)；

• 最坏情况：在表尾或不存在，比较n次，O(n)；

• 平均情况：平均移动次数为（n+1）/2（参杂概率的计算问题），时间复杂度O(n)。

总结，插入操作时间复杂度O(n)

2.3 线性表的链式表示

2.3.1 单链表的定义

线性表的链式存储又称为单链表，它是通过一组任意的存储单元来存储线性表中的数据元素。为了建立数据元素之间的线性关系，对每个单链表结点，除存放元素自身信息之外，还需要存放一个指向其后继的指针。

结点结构：

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

利用单链表可以解决顺序需要大量连续存储单元的缺点，但附加的指针域也存在浪费存储空间的缺点。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构（即不能直接找到表中的指定节点），查找指定节点需要从头开始遍历。

通常用头指针L（或head）来标识一个单链表，指出链表的起始地址，头指针为NULL时表示一个空表。为了操作方便，可在单链表第一个数据结点之前附加一个结点，称为头结点；不带头结点，头指针L指向第一个数据结点。表尾指针域为NULL。

头结点与头指针的关系：

无论是否带有头结点，头指针始终指向链表的第一个结点，而头结点是带头结点的链表中的第一个结点，结点内通常不存储信息。

引入头结点的两个优点：

• 带有头结点就可以将第一个数据结点的信息放在头结点的指针域中，因此链表的第一个位置上的操作和其他位置操作相同，不需进行特殊处理；

• 无论链表是否为空，其头指针都是指向头结点的非空指针（空表中头结点的指针域为空），因此空表和非空表的处理也就得到统一。

2.3.2 单链表上的基本操作

1）单链表的初始化

bool InitList(LinkList &L)//带头结点
{
    L=(LNode*)malloc(sizeof(LNode));//创建头结点
    L->next = NULL;
    return true;
}
bool InitList(LinkList &L)//不带头结点
{
    L = NULL;
    return true;
}

注：对于结构体指针和结构体变量的使用浅析

• p->data与 (*p).data等价，“->”左边是结构体变量，“.”左边是结构体指针；

• (*p).next可以得到下一个结点的指针，所以与p->next->data的等价形式为 ( *( *p).next).data.

#include<iostream>
#include<algorithm>
using namespace std;
typedef struct LNode {
    int data;
    struct LNode* next;
}LNode, *LinkList;
​
//struct LNode* == LinkList
//强调节点 ⽤LNode
//强调链表 ⽤LinkList
​
//按位查找，返回第i个元素（带头节点）:从头结点开始沿着next指针域遍历，直至找到第i个结点为止，返回该结点的指针；若i大于表长，返回NULL。
LNode* GetElem(LinkList L, int i) 
{
    if (i < 0) return NULL;
    int j = 0;
    LNode* p = L;
    while (p && j < i) 
    {
        p = p->next;
        j++;
    }
    return p;
}//时间复杂度O(n).
​
//按值查找，找到数据域等于e的节点：从头结点开始遍历，依次比较数据域值，找到则返回指针，没有返回NULL。
LNode* LocateElem(LinkList L, int e) 
{
    LNode* p = L->next;
    while (p && p->data!=e) 
    {
        p = p->next;
    }
    return p;
}//时间复杂度O(n).
​
​
//统计单链表的长度：表长就是单链表中数据结点的个数，从第一个结点开始遍历访问，因此需设置一个计数变量，访问到空结点为止。
int Length(LinkList L) 
{
    int len = 0;
    LNode* p = L;
    while (p->next) 
    {
    len++;
    p = p->next;
}
    return len;
}//时间复杂度O(n).
​
//后插操作，在节点p之后插⼊元素e
bool InsertNextNode(LNode *p, int e) 
{
    if (!p) 
    return false;
    LNode* s = (LNode*)malloc(sizeof(LNode));
    if (!s) 
    return false;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}
​
//带头节点的插⼊操作，在第i个位置插⼊元素e：将值为e的新结点插入到单链表的第i个位置.先要检测插入位置的合法性，然后找到该位置前驱（i-1）个结点，更改指针域。
bool ListInsert(LinkList& L, int i, int e)
{
    if (i < 1) 
    return false;
    LNode* p = GetElem(L, i - 1);
    if (!p) 
    return false;
    return InsertNextNode(p, e);
}//时间复杂度O(n)
​
//不带头节点的插⼊操作，在第i个位置插⼊元素e
bool NoHead_ListInsert(LinkList& L, int i, int e) 
{
    if (i < 1) 
    return false;
    if (i == 1) 
    {
    LNode* s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = L;
    L = s;
    return true;
    }
    LNode* p;
    p = L;
    int j = 1; //当前p指向的是第⼏个节点，没有头节点，所以从1开始
    while (p && j < i - 1) 
    {
        p = p->next;
    j++;
    }
    if (!p) 
    return false;
    return InsertNextNode(p, e);
}
​
//前插操作，在p节点前插⼊元素e
bool InsertPriorNode(LNode* p, int e) 
{
    if (!p) 
    return false;
    LNode* s = (LNode*)malloc(sizeof(LNode));
    if (!s)
    return false;
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return true;
}
​
//前插操作，在节点p之前插⼊节点s
bool InsertPriorNode(LNode* p, LNode* s)
{
    if ( !p || !s )
    return false;
    if ( !p || !s )
    return false;
    s->next = p->next;
    p->next = s;
    swap(s->data , p->data);
    return true;
}
​
//删除位序i的节点，e是i节点的值
bool ListDelete(LinkList& L, int i, int& e)
{
    if (i < 1)
    return false;
    LNode* p = GetElem(L, i - 1);
    if (!p || !(p->next)) 
    return false;
    LNode* q = p->next;
    e = q->data;
    p->next = q->next;
    free(q);
    return true;
}
​
//删除指定节点P：思路是将后续结点的值向前移动一位
bool DeleteNode(LNode* p)
{
    if (p->next == NULL) 
    return false;
    //下⾯这段代码有bug，不能删除最后⼀个节点，因此要是删除最后⼀个节点的话要重新进⾏操作
    LNode* q = p->next;
    p->data = q->data;
    p->next = q->next;
    free(q);
    return true;
}//时间复杂度O(n)
//删除结点的另一思路是从该结点本身进行操作，释放它的空间，将后继与前驱直接连续起来，充分体现指针域的灵活性。
bool ListDelete(LinkList &L,int i,ElemType e)
{
    LNode *p=L;
    int j = 0;
    while(p!=NULL&&j<i-1)
    {
        p=p->next;
        j++;
    }
    if(p==NULL||p->next==NULL)
        return false;
    LNode *q=p->next;
    e=q->data;
    p->next=q->next;
    free(q);
    return true;
}
​
bool InitList(LinkList& L)
{
    L = (LNode* )malloc(sizeof(LNode));//分配⼀个头节点
    if (!L) 
    return false;
    L->next = NULL;
    return true;
}
​
//尾插法，带头结点
LinkList List_TailInsert(LinkList& L) 
{
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    LNode* s, * r = L; //r表⽰表尾指针
    int x;
    while (cin >> x) 
    {
    s = (LNode*)malloc(sizeof(LNode));
    s->data = x;
    r->next = s;
    r = s;
    }
    r->next = NULL;
    return L;
}
​
//头插法，带头结点
LinkList List_HeadInsert(LinkList& L) 
{
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    LNode* s;
    int x;
    while (cin >> x) 
    {
    s = (LNode*)malloc(sizeof(LNode));
    s->data = x;
    s->next = L->next;
    L->next = s;
    }
    return L;
    return L;
}
​
void print(LinkList L)
{
    LNode* s = L;
    while (s->next!=NULL) 
    {
    s = s->next;
    cout << s->data << " ";
    }
    cout << endl;
}
​

2.3.3 双链表

单链表结点中只有一个指向其后继的指针，使得单链表只能从前往后遍历。要访问其前驱只能从头遍历，时间复杂度为O(n)。于是双链表出现了，双链表的结点中有两个指针 prior和next，分别指向其前驱和后继。（其中头结点的prior域和尾结点的next域都是NULL）。

typedef struct DNode{
    ElemType data;
    struct DNode *prior,*next;
}DNode,*DLinklist;

双链表本质上只是在单链表基础上加入了prior域，所以双链表的按值查找和按位查找与单链表并无不同，但是插入和删除操作的实现有较大不同（关键是要保证操作过程中不断链）。由于双链表找其前驱很方便，因此插入和删除的时间复杂度仅为O(1).

插入操作(在P指针所指结点后插入结点*S)

s->next = p->next;//1
p->next->prior = s;//2
s->next = p;//3
p->next = s;//4

注：语句1必须在语句4之前，否则会造成原*P后继结点的指针就会丢失。

删除操作（删除双链表中的结点* P的后继结点* q）

p->next = q->next;
q->next->prior = p;
free(q);

2.3.4 循环链表

顾名思义，就是通过指针将尾结点与头结点联系起来，将其变为一个环

循环单链表：

与单链表的区别在于，表中最后一个结点的指针不是NULL，改为指向头结点。

判空条件：尾结点指针是否等于头指针L。

循环双链表：

循环双链表的改动相对于双链表就是尾结点next指向头结点，头结点prior指向尾结点。

判空条件：头指针的prior和next都指向L。

2.3.5 静态链表

静态链表是用数组来描述线性表的链式存储结构，结点结构与单链表相同（data+next），不同点在于这里的指针是结点在数组中的相对地址（数组下标），又称游标。和顺序表一样，静态链表也要预先分配一块连续的内存空间。

#define MaxSize 50
typedef struct{
    ElemType data;
    int next;
}SLinkList[MaxSize]

静态链表的结束标志是：next == -1。

静态链表的插入、删除操作与动态链表相同，只需要修改指针。静态链表的方便性较差，但是在不支持指针的高级语言中是一种非常巧妙的设计。

2.3.6 顺序表和链表的比较

1.存取方式（即读写）

• 顺序表：可以进行顺序存取和随机存取；

• 链表：只能从头开始依次存取。

2.逻辑结构与物理结构

• 顺序表：逻辑上相邻的元素物理位置也相邻；

• 链表：逻辑上相邻元素物理位置不一定相邻。

3.查找、插入和删除操作

• 顺序表：按值查找可以通过不同的算法达到不同的时间复杂度，按位查找时间复杂度仅为O(1)【随机存取的优越性】，插入和删除操作需要移动平均半个表的元素，T(n)=O(n)。

• 链表：查找T(n)=O(n)，插入和删除只需要修改相关结点指针T(n)=O(n)。

4.空间分配

• 顺序表（连续地址）：静态分配空间需预分配，是固定不可变的，会造成浪费后面空间和溢出的问题；动态分配可以扩容，但是扩容后需要移动全部元素。

• 链表（地址不需要连续）：只要内存有空间就可以分配，操作灵活、高效，但是由于指针域的存在，存储密度不够大。