数据结构理论基础-2—线性表

若将线性表记为（ $a_{1},...,a_{i-1}, a_{i}, a_{i+1},..., a_{n}$ ），称 $a_{i-1}$ 是 $a_{i}$ 的直接前驱元素， $a_{i+1}$ 是 $a_{i}$ 的直接后继元素。当 $i = 1, 2,...,n-1$ 时， $a_{i}$ 有且仅有一个直接后继，当 $i = 2, 3, ...,n$ 时， $a_{i}$ 有且仅有一个直接前驱。

线性表的抽象数据类型如下：

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）:在线性表的第 i 个位置插入元素 e

ListDelete（*L, i, *e）:删除线性表 L 中第 i 个位置元素，并用 e 返回其值

ListLength（L）:返回线性表 L 的元素个数

线性表的顺序存储结构

线性表的顺序存储结构：指的是用一段地址连续的存储单元依次存储线性表的数据元素（可以用C语言中的一维数组实现）

# define MAXSIAE 20        /*存储空间初始分配量*/
typedef int ElemType;      /*ElemType类型根据实际情况而定，这里假设为int*/
type struct{
    Elemtype data[MAXSIZE];/*数组存储数据元素，最大值为MAXSIZE*/
    int length;            /*线性表当前长度*/
}SqList;

获得元素操作

（实现 GetElem（L, i, *e） 操作，时间复杂度为O(1) ）

# define OK  1
# define ERROR 0
# define TURE 1
# define FALSE 0
typedef int Status;

/*操作结果：用e返回L中第i个数据元素的值，i从1开始，与数组序号相差一个，下同*/
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;
}

插入操作

（实现 ListInsert（*L, i, e） 操作，时间复杂度为O(n) ）

插入操作思路：

如果插入位置不合理，抛出异常
若线性表长度大于数组长度，抛出异常或动态增加容量
从最后一个元素向前遍历到第 i 个位置，分别将它们向后移动一个位置
将要插入的元素 e 填入到位置 i 处
表长加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--)
			L->data[k+1] = L->data[k];
	}
	L->data[i-1] = e;
	L->length++;
	return OK;
}

删除操作

（实现ListDelete（*L, i, *e） 操作，时间复杂度为O(n) ）

删除操作的思路：

如果删除位置不合理，抛出异常
取出删除元素
从删除元素位置开始遍历到最后一个元素位置，分别将它们向前移动一个位置
表长减1

/*操作结果：删除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;
}

线性表顺序存储结构优缺点

优点：

无需为表示表中元素之间的逻辑关系而增加额外的存储空间

可以快速存取表中任一位置的元素

缺点：

插入和删除操作需要移动大量元素

当线性表长度变化较大时，难以确定存储空间的容量

造成存储空间的“碎片”

线性表的链式存储结构

顺序存储结构的最大缺点是：插入和删除时需要移动大量元素，原因就在于：顺序存储结构中的相邻元素，它们的存储位置也是相邻的，解决办法就是：让存储位置不再具有任何关系性。

线性表的链式存储结构的特点就是：线性表中的数据元素可在存储在内存未被占用的任意位置，这些存储单元可以是连续的，也可以是不连续的。

为了表述数据元素 $a_{i}$ 和其直接后继元素 $a_{i+1}$ 之间的逻辑关系，对 $a_{i}$ 来说，除了存储其本身的信息外，还要存储直接后继 $a_{i+1}$ 的存储位置。我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域，指针域中存储的信息称为指针或链，数据域和指针域组成元素 $a_{i}$ 的存储映像，称为结点（Node）

n个结点链结成一个链表，即为线性表的链式存储结构，因为此链表的每个结点只包含一个指针域，所以叫单链表

单链表正是通过每个结点的指针域将线性表的数据元素按其逻辑次序链接在一起

/*线性表的单链表存储结构*/
typedef struct Node
{
	ElemType data;
	struct Node *next;
}Node;
typedef struct Node *LinkList

从这个结构定义中可知，结点由存放数据元素的数据域和存放后继结点地址的指针域组成

假设 p 是指向线性表第 i 个元素的指针，则：

单链表的读取操作

（实现 GetElem（L, i, *e） 操作，时间复杂度为O(n) ）

读取操作思路：

声明一个结点 p 指向链表第一个结点，初始化 j 从1开始
当 j < i 时，就遍历链表，让 p 的指针向后移动，j++
若到链表末尾 p 为空，则说明第 i 个元素不存在
否则查找成功，返回结点 p 的数据

/*操作结果：用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; 
		j++;
	}
	if(!p || j>i)
		return ERROR;
	*e = p->data;
	return OK;
}

单链表的插入

由图可知，根本不用移动其他结点，只需要：

s -> next = p -> next; p -> next = s; （注意，两句不能颠倒！！）

既是：让 p 的原后继结点改成为 s 的后继结点，再把 s 结点变成 p 的新后继结点

插入操作（实现 ListInsert（*L, i, e） 操作，时间复杂度为O(n) ）

插入操作思路：

声明一个结点 p 指向链表第一个结点，初始化 j 从1开始
当 j < i 时，就遍历链表，让 p 的指针向后移动，j++
若到链表末尾 p 为空，则说明第 i 个元素不存在
否则查找成功，在系统中生成一个空结点s
将数据元素 e 赋值给 s->data
单链表的插入标准语句 s -> next = p -> next; p -> next = s;
返回成功

/*操作结果：在 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语言中的 malloc 函数作用是生成一个新的结点，其类型                                                
                              和 Node 一致，实质就是在内存中找一块空地，用来存放 e 数据 s 结点*/
        s->data = e;
        s->next = p->next;
        p->next = s;
	return OK;
}

单链表的删除

实际上就是一步，p->next = p->next->next （也就是让 p 的后继的后继结点改成 p 的后继结点）：

如果用 q 来取代 p->next，则

q = p->next; p->next = q->next;

删除操作（实现 ListDelete（*L, i, *e） 操作，时间复杂度为O(n) ）

删除操作思路：

声明一个结点 p 指向链表第一个结点，初始化 j 从1开始
当 j < i 时，就遍历链表，让 p 的指针向后移动，j++
若到链表末尾 p 为空，则说明第 i 个元素不存在
否则查找成功，将欲删除的结点 p-next 赋值给 q
单链表的删除标准语句 p -> next = q -> next;
将 q 结点中的数据赋值给 e
释放 q 结点
返回成功

/*操作结果：删除 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;
        free(q);
	return OK;
}

分析可发现，单链表的插入和删除操作看起来并不比顺序存储结构简单，复杂度也都是 O(n)。其实不然，当我们想从第 i 个位置插入10个元素时，对顺序存储结构来说，每次插入都要移动 n-i 个元素，每次都是O(n)，而单链表只需要找到第 i 个位置的指针（复杂度为O(n) ），之后插入的操作都是O(1)。对于插入或删除数据越频繁的操作，单链表的优势越明显。

单链表的整表创建

对于每个链表来说，它所占用的空间大小和位置是不需要预先分配的，所以创建单链表的过程就是一个动态生成链表的过程，即从“空表”的初始状态起，依次建立各元素结点，并逐个插入链表。

单链表整表创建的算法思路：

声明一结点 p 和计数器变量 i
初始化一空链表 L
让 L 的头节点的指针指向NULL，即创建一个带头结点的单链表
循环：

生成一新结点赋值给 p;

随机生成一数字赋值给 p->data

将 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;
    }
}

上述这段代码，其实用的是插队的办法，始终让新结点在第一的位置，简称为头插法，如下图所示

还有一种方法称为尾插法 ，就是把新结点放在最后。

/* 随机产生 n 个元素的值，建立带表头结点的单链表线性表L（尾插法）*/
void CreateListTail(LinkList *L, int n)
{
    LinkList p, r;
    int i;
    srand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;  /* r 为指向尾部的结点 */
    for(i=0; i<n; i++)
    {
        p = (Node *)malloc(sizeof(Node));
        p->data = rand() % 100 + 1;
        r->next = p;  /* 将表尾终端结点的指针指向新结点 */
        r = p;  /* 将当前的新结点定义为表尾终端结点 */
    }
    r->next = NULL;  /* 表示当前链表结束 */
}

单链表的整表删除

单链表整表删除的算法思路：

声明一结点 p 和 q
将第一个结点赋值给 p
循环：

将下一结点赋值给 q;

释放 p

将 q 赋值给 p

/* 将 L 重置为空表*/
void ClearList(LinkList *L)
{
    LinkList p, q;
    p = (*L)->next;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = NULL;  /*头节点指针域为空*/
    return OK;
}

静态链表

静态链表是指当某种语言没有指针能力的时候，人们想用数组来代替指针，来描述链表。让数组的元素由两个数据域 data 和 cur 组成，数据域 data 用来存放数据元素，游标 cur 相当于 next 指针，存放该元素的后继在数组中的下标。

/* 线性表的静态链表存储结构 */
#define MAXSIZE 1000  /* 假设链表的最大长度是1000 */
typedef struct
{
    ElemType data;
    int cur;  /* 游标（cursor）为 0 时表示无指向 */
}Component, StaticLinkList[MAXSIZE];

如上图所示，我们对数组的第一个和最后一个元素作为特殊元素处理，不存放数据。数组第一个元素的 cur 存放备用链表（未被使用的数据元素）的第一个结点的下标，数组最后一个元素的 cur 存放第一个有数值的元素的下标。代码如下：

Status InitList(StaticLinkList space)
{
    int i;
    for(i=0; i<MAXSIZE-1; i++)
        space[i].cur = i+1;
    space[MAXSIZE-1].cur = 0;
    return OK;
}

假设把甲乙丁等数据存入静态链表的话，则如下图所示：

静态链表的插入操作

静态链表中要解决的是：如何用静态模拟动态链表结构的存储空间的分配，需要时申请（malloc（）函数），无用时释放（free（）函数）

为了辨明数组中哪些分量未被使用，解决的办法是将所有未被使用过的及已被删除的分量用游标链成一个备用的链表，每当进行插入时，便可以从备用链表上取得第一个结点作为待插入的新结点。

int Malloc_SLL(StaticLinkList space)
{
    int i = space[0].cur;  /* i 就是第一个备用空闲的下标 */
    if(space[0].cur)
        space[0].cur = space[i].cur;  /* 由于拿出一个分量来使用了，所以就得把它的下一个分量用来 
                                         做备用 */
    return i;
}

这段代码，拿上图甲乙丁的例子来说，下标为7的分量准备要使用了，就得有接替者，所以就把分量 7 的 cur 值赋值给头元素，也就是把 8 给 space[0].cur，实现类似malloc（）函数的使用。

那么如何把丙存放在乙和丁中间？

如图所示，只需要把乙放在空闲分量7的位置，把原来的乙.cur = 3 改为丙.cur = 3，乙.cur = 7.

/* 在 L 中第 i 个元素之前插入新的数据元素 e */
Status ListInsert(StaticLinkList L, int i, ElemType e)
{
    int j, k, l;
    k = MAXSIZE - 1;
    if(i<1 || i>ListLength(L) + 1)
        return ERROR;
    j = Malloc_SSL(L);  /* 获得空闲分量的下标 */
    if(j)
    {
        L[j].data = e;  /* 将数据赋值给此分量的data */
        for(l=1; l<i-1; l++)  /* 找到第 i 个元素之前的位置 */
            k = L[k].cur;
        L[j].cur = L[k].cur;  /* 把第 i 个元素之前的 cur 赋值给新元素的cur,即 丙.cur=3 */
        l[k].cur = j;  /* 把新元素的下标赋值给第 i 个元素之前元素的cur,即 乙.cur=7 */
        return OK;
    }
}

静态链表的删除操作

如何删除链表中的 “甲”？

意思就是，删除了甲之后，位置空了出来，如果之后有插入操作的话，优先考虑这里

/* 删除在L中第 i 个数据元素 e */
Status ListDelete(StaticLinkList L, int i)
{
    int j, k;
    if(i<1 || i>ListLength(L))
        return ERROR;
    k = MAXSIZE - 1;
    for(j=1; j<i-1; j++)
        k = L[k].cur;
    j = L[k].cur;
    L[k].cur = L[j].cur;
    Free_SSL(L, j);
    return OK;
}

/* 将下标为 k 的空闲结点回收到备用链表 */
void Free_SSL(StaticLinkList space, int k)
{
    space[k].cur = space[0].cur;  /* 把第一个元素 cur 值赋给要删除的分量cur */
    space[0].cur = k;  /* 把要删除的分量下标赋值给第一个元素的cur */
}

Free_SLL()函数中的两句，也就是 space[1].cur = space[0].cur = 8; space[0].cur = k = 1;看删除前后两张图的变化就能理解。

静态列表用的较少，优缺点如下：

优点：

在插入和删除操作时，只需要修改游标，不需要移动元素。

缺点：

没有解决连续存储分配带来的表长难以确定的问题

失去了顺序存储结构随机存取的特性

循环链表

循环链表：将单链表中终端结点的指针端由空指针改为指向头结点，就使整个单链表形成一个环，这种头尾相接的单链表称为单循环链表

循环列表解决了一个很麻烦的问题：如何从当中一个结点出发，访问到链表的全部结点

双向链表

双向链表：是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。

/* 线性表的双向链表存储结构 */
typedef struct DulNode
{
    ElemType data;
    struct DulNode *prior;  /* 直接前驱指针 */
    struct DulNode *next;  /* 直接后继指针 */
}DulNode *DuLinkList;

双向链表的插入和删除操作并不复杂，只是顺序比较重要。

/* 插入顺序 */
s -> prior = p;            /* 把 p 赋值给 s 的前驱 */
s -> next = p -> next;     /* 把 p->next 赋值给 s 的后继 */   
p ->next -> prior = s;    /* 把 s 赋值给 p->next 的前驱 */
p -> next = s;            /* 把 s 赋值给 p 的后继 */

/* 删除顺序 */
p -> prior ->next = p -> next;    /* 把 p->next 赋值给 p->prior的后继 */
p -> next -> prior = p -> prior;  /* 把 p->prior 赋值给 p->next的前驱 */   
free(p);