数据结构学习笔记——线性表
目录
- （一）线性表的定义
- （二）线性表的基本操作
- （三）线性表的顺序存储结构(数组)
- 1、顺序存储结构的插入与删除实现
- 2、顺序存储结构的时间复杂度及优缺点
- （四）线性表的链式存储结构(链表）
- 1、单链表的读取、插入与删除实现
- 1、单链表的创建与删除
- （三）静态链表(用数组描述的链表）
- （四）循环链表
- （五）双向链表
ps：此文章只是为了总结学习数据结构笔记，便于以后忘记查阅，因此部分图片会借用书上的图片，望理解。
（一）线性表的定义
线性表（List）：零个或多个数据元素的有限序列。
首先线性表是一个序列，即元素之间是有序的若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他元素有且只有一个前驱和后继。其次，线性表强调是有限的。举个例子，例如一年中的生肖列表就是线性表，鼠开头，猪结尾，中间元素有且只有一个前驱和后继，并且此表有限。
（二）线性表的基本操作
ADT 线性表(List)
Data
···
Operation
InitList(*L)： 初始化操作，建立一个空的线性表L。
ListEmpty(L)： 若线性表为空，返回true，否则返回false。
ClearList(*L)： 将线性表清空。
GetElem(L，i,*e): 将线性表L中的第I个位置的元素返回给e。
LocateElem(L,e): 在线性表L中查找与给定值e相等的元素，如果查找成功，则返回该元素在表中序号表示成功；
否则，返回0表示失败。
ListInsert(*L,i,e): 在线性表L中的第i个位置插入新元素e。
ListDelete(*L，i，*e)：删除线性表L中第i个未知元素，并用e返回其值。
ListLength(L)： 返回线性表L的元素个数。
ednADT
（三）线性表的顺序存储结构(数组)
线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。举个例子，如果你要帮同学占座，一定会优先占连续的一串座位。c语言中最典型的就是用一维数组来实现顺序存储结构。
顺序存储结构代码：
#define MAXSIZE 20 //存储空间初始量分配
typedef int ElemType; //ElemType类型根据实际而定，在这里为int
typedef struct
{
ElemType data[MAXSIZE]; //数组存储数据元素，最大值为MAXSIZE
int length; //线性表的长度（要小于等于数组长度）
}SqList;
从上述代码我们会发现描述顺序存储结构的三个属性：
- 存储空间起始位置：数组data，他的存储位置就是存储空间的存储位置。
- 线性表的最大存储容量：数组长度MaxSize。
- 线性表的当前长度：length。
数据元素的序号和存放他数组下标之间的对应关系如下：
假设占用c个存储单元，则线性表中第i+1个数据元素的存储位置和第i个数据元素的存储位置满足下列关系：（LOC为获取存储位置的函数）
由第i+1个数据元素ai的存储位置可以由a1的位置推算：
上面的公式可以通过下图理解：
通过公式我们可随时算出线性表中任意位置的地址，不管是第一个还是最后一个，用时间复杂度来衡量，他的存取时间性能为O（1），我们通常把具有这一特点的存储结构称为随机存储结构。
1、顺序存储结构的插入与删除实现
获得元素操作：对于线性表顺序存储结构来说实现GetElem操作，即将线性表L中的第i个位置元素值返回，即 i 的数值在数组下标范围内，就是将数组的第 i-1 下标的值返回，示例代码：
#define OK 1
#define ERROR 0
#define TRUE 1
#define false 0
typedef int Status；
//初始条件：顺序线性表已存在，1≤i≤ListLength(L)
//操作结果：用e作为返回L中第i个元素的值
Status GetElem(SqList L, int i, ElemType *e)
{
if (L.length == 0 || i<1 || i>L.length)
return ERROR;
*e = L.data[i-1];
return OK;
}
插入操作：对于线性表顺序存储结构如何实现LisInsert（*L, i, e)，即在线性表L中的第 i 个位置插入新元素e：
- 如果位置不合理，抛出异常；
- 如果线性表长度大于等于数组长度，抛出异常或动态增加容量；
- 从最后一个元素开始向前遍历到第 i 个位置，分别将他们都向后移动一个位置；
- 将要插入元素填入位置 i ；
- 表长加一。
示例代码：
//初始条件：顺序线性表L已经存在，1≤i≤ListLength(L)
//操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
Status ListInsert(SqList *L, int i, ElemType e)
{
int k;
if ( L->length == MAXSIZE ) //顺序线性表已满
return ERROR;
if ( i<1 || i>L->length+1 ) //当i不在范围内
return ERROR;
if ( i<=L->length ) //插入数据位置不在表位
{
for ( k = L->length-1; k>=i-1; k--) //将要插入位置后数据元素向后移1位
L->data[k+1] = L->data[k];
}
L->data[i-1] = e; //将元素插入
L->length++;
return OK;
删除操作：
- 如果删除位置不合理，抛出异常；
- 去除删除元素；
- 从删除位置开始遍历到最后一个元素位置，分别将他们向前移动一个位置；
- 表长减1。
示例代码：
// 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
// 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(SqList *L,int i,ElemType *e)
{
int k;
if (L->length==0) /* 线性表为空 */
return ERROR;
if (i<1 || i>L->length) /* 删除位置不正确 */
return ERROR;
*e=L->data[i-1];
if (i<L->length) /* 如果删除不是最后位置 */
{
for(k=i;k<L->length;k++)/* 将删除位置后继元素前移 */
L->data[k-1]=L->data[k];
}
L->length--;
return OK;
}
2、顺序存储结构的时间复杂度及优缺点
插入和删除的时间复杂度：前面说过线性表的顺序存储结构，在存、读取数据时，不管哪个位置，时间复杂度都为O（1）；而插入或删除时，时间复杂度都为O（N）。（至于为啥，你品，你细品···）
优点：
- 无须为表示表中元素之间的逻辑关系而增加额外的存储空
- 可以快速地取表中任意位置的元素。
缺点： - 插入和删除操作需要移动大量元素
- 当线性表长度变化较大时，难以确定存储空间容量
- 造成存储空间的”碎片“
（四）线性表的链式存储结构(链表）
为了表示每个数据元素 ai 与其直接后继数据元素 ai+1 之间的逻辑关系，对数据元素 ai 来说，除了存储器本身的信息外，还需存储一个指示其直接后继的信息。我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称做指针或链。两部分信息组成数据元素 ai 的存储映像，称为结点（Node）。
n个结点链成一个链表，即为线性表的链式存储结构，因为此链表的每个节点中只包含一个指针域，所以为单链表。其结构如下图所示：
我们将链表中第一个结点的存储位置叫做头指针，之后的每一个结点就是上一个的后继指针指向的位置，线性链表的最后一个结点指针位”空“（NULL）。
通常我们会在单链表的第一个结点前附近设一个结点称为头结点，其不存储任何信息，其指针域存储指向第一个结点的指针。如下图所示：
头指针
- 头指针是指向链表指向的第一个结点的指针，若链表有头结点，则是指向头结点的指针
- 头指针具有标识作用，所以在常用头指针冠以链表的名字
- 不论链表是否为空，头指针均不为空。头指针是链表的必要元素
头结点
- 头结点是为了操作和统一的方便而设立，放在第一元素的结点之前，其数据域一般无意义
- 有了头结点，对在第一元素结点前插入结点和删除第一结点，其操作与其他节点的操作就统一了
- 头结点不一定是链表的必要元素
单链表中，我们可以用结构指针来描述：
typedef struct Node
{
ElemType data;
struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定义LinkList */
从这个结构定义中可以知道结点由存放数据元素的数据域和存放后继节点地址的指针域构成。假设p指向线性表第i个元素，该结点 ai 的数据域可用 p->data 来表示，其值是一个数据元素，结点 ai 的指针域可用 p->next 来表示。如下图所示：
1、单链表的读取、插入与删除实现
获取链表第 i 个数据的算法思路：
- 声明一个结点 p 指向链表的第一个结点，初始话 j 从1开始；
- 当 j
- 若到聊表末尾 p 为空，则说明第 i 个元素不存在；
- 否则查找成功，返回结点 p 的数据。
示例代码：
// 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
// 操作结果：用e返回L中第i个数据元素的值
Status GetElem(LinkList L,int i,ElemType *e)
{
int j;
LinkList p; /* 声明一结点p */
p = L->next; /* 让p指向链表L的第一个结点 */
j = 1; /* j为计数器 */
while (p && j<i) /* p不为空或者计数器j还没有等于i时，循环继续 */
{
p = p->next; /* 让p指向下一个结点 */
++j;
}
if ( !p || j>i )
return ERROR; /* 第i个元素不存在 */
*e = p->data; /* 取第i个元素的数据 */
return OK;
}
核心思想 ” 工作指针后移 “ 。
单链表第 i 个数据插入结点的算法思路：
- 声明一结点 p 指向链表第一个结点，初始化 j 从 1 开始；
- 当 j
- 若到链表末尾 p 为空，则说明第 i 个元素不存在；
- 否则查找成功，在系统中生成一个空结点 s;
- 将数据元萦素e 赋值给 s->data ;
- 单链表的插入标准语旬 s->next=p->next; . p->next=s;
- 返回成功。
示例代码如下：
/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{
int j;
LinkList p,s;
p = *L;
j = 1;
while (p && j < i) /* 寻找第i个结点 */
{
p = p->next;
++j;
}
if (!p || j > i)
return ERROR; /* 第i个元素不存在 */
s = (LinkList)malloc(sizeof(Node)); /* 生成新结点(C语言标准函数) */
s->data = e;
s->next = p->next; /* 将p的后继结点赋值给s的后继 */
p->next = s; /* 将s赋值给p的后继 */
return OK;
}
单链表第 i 个数据删除结点的算法思路:
- 声明一结点 p 指向链表第一个结点 ，初始化 j 从 1 开始;
- 当 j
- 若到链表末尾 p 为空，则说明第 i 个元素不存在;
- 否则查找成功，将欲删除的结点 p->next 赋值给 q;
- 单链表的删除标准语句 p->next=q->next;
- 将 q 结点中的数据赋值给 e， 作为返回;
- 释放 q 结点;
- 返回成功。
示例代码如下：
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e)
{
int j;
LinkList p,q;
p = *L;
j = 1;
while (p->next && j < i) /* 遍历寻找第i个元素 */
{
p = p->next;
++j;
}
if (!(p->next) || j > i)
return ERROR; /* 第i个元素不存在 */
q = p->next;
p->next = q->next; /* 将q的后继赋值给p的后继 */
*e = q->data; /* 将q结点中的数据给e */
free(q); /* 让系统回收此结点，释放内存 */
return OK;
}
对于上面的操作，他们的时间复杂度都是 O(n)。单链表，我们只需要在第一次时，找到第 i 个位置的指针，此时为 O(n），接下来只是简单地通过赋值移动指针而已，时间复杂度都是 O(1)。显然，对于插入或删除数据越频繁的操作，单链表的效率优势就越是明显。
1、单链表的创建与删除
单链表整表创建的算法思路:
- .声明一结点 p 和计数器变量 i ;
- 初始化一空链表 L;
- 让 L 的头结点的指针指向 NULL，即建立一个带头结点的单链表；
- 循环：
1）生成一新结点赋值给 p;
2）随机生成一数字赋值给 p 的数据域 p->data;
3）将 p 插入到头结点与前一新结点之间。
示例代码：
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L, int n)
{
LinkList p;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node));
(*L)->next = NULL; /* 先建立一个带头结点的单链表 */
for (i=0; i<n; i++)
{
p = (LinkList)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
p->next = (*L)->next;
(*L)->next = p; /* 插入到表头 */
}
}
单链表整表删除的算法思路:
- 声明一结点 p和 q;
- 将第一个结点赋值给 p;
- 循环:
1)将下一结点赋值给 q;
2)释放 p;
3)将 q 赋值给 p。
示例代码：
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n)
{
LinkList p,r;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */
r=*L; /* r为指向尾部的结点 */
for (i=0; i<n; i++)
{
p = (Node *)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
r->next=p; /* 将表尾终端结点的指针指向新结点 */
r = p; /* 将当前的新结点定义为表尾终端结点 */
}
r->next = NULL; /* 表示当前链表结束 */
}
（三）静态链表(用数组描述的链表）
让数组的元素都是由两个数据域组成，data 和 cur。也就是说，数组的每 个下标都对应一个 data 和一个 cur。 数据域data，用来存放数据元素， 也就是通常我们要处理的数据;而游标 cur 相当于单链表中的 next 指针，存放该元素的后继在数组中的下标。
线性表的静态链表存储结构：
/* 线性表的静态链表存储结构 */
#define MAXSIZE 1000
typedef struct
{
ElemType data;
int cur; /* 游标(Cursor) ，为0时表示无指向 */
} Component,StaticLinkList[MAXSIZE];
- 优点：再插入和删除操作时，只需修改游标，，不需要移动元素，从而改进 了在顺序存储结构中的插人和删除操作需要移 动大量元素的缺点
- 缺点：没有解决连续存储分配带来的表长难以确定的问题，失去了顺序存储结构随机存取的特性。
（四）循环链表
将单链表中终端结点的指针端自空指针改为指向头结点，就使整个单链表形成一个环，这种头尾相接的单链表称为单循环链表，简称循环链表 (circular linked list) 。
（五）双向链表
双向链表 (double linked List) 是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。
/*线性求的双向链表存储结构*/
typedef struct DulNode
{
ElemType data;
struct DuLNode *prior; /*直接前驱指针*/
struct DuLNode *next; /*直接后继指针*/
} DulNode, * DuLinkList;
双向链表插入操作：
s -> prior = P; // 把p赋值给s的前驱，如下图中的1
s -> next = p -> prior; //把p->next赋值给s的后继，如下图中2
p -> next -> prior = s; //把s赋值给p->next的前驱，如下图中3
p -> next = s; //把s赋值给p的后继，如下图中4
双向链表删除操作：
p->prior->next = p->next; //把p->next赋值给p->prior的后继如下图1
p->next->prior = p->prior; //把p->prior赋值给p->next的前驱，如下图2
free(p) //释放结点
参考书籍：《大话数据结构》