第三章，线性表学习笔记-CFANZ编程社区

线性表（List）：零个或多个数据元素的有限序列。

定义:

ADT 线性表（List）

Data
    线性表的数据对象集合为{a_1,a_2,......,a_n},每个元素的类型均为DataType。其中，除第一个
元素a_1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素a_n外，每一个元素有且只有一个
直接后继元素。数据元素之间的关系是一对一的关系。

Operation    
	InitList(*L)	//初始化操作，构造一个空的线性表L
	DestroyList(*L)	//销毁线性表L
	ClearList(*L)	//将线性表L置为空表
	ListEmpty(L)	//判断线性表是否为空，若L为空，返回true
	ListLength(L)	//返回L中数据元素个数
	GetElem(L,i,*e)	//用e返回线性表L中第i个数据元素的值
	LocateElem(L,e)	//返回线性表L中第一个与e相同元素在表L中的位置
	PriorElem(L,cur_e,*pre_e)	//若cur_e是表L中的数据元素，且不是第一个数据元素，则用pre_e返回其前驱数据元素
	NextElem(L,cur_e,*next_e)	//若cur_e是表L中的数据元素，且不是最后一个数据元素，则用next_e返回其后继数据元素
	ListInsert(*L,i,e)	//在表L中第i个位置之前插入新数据元素e
	ListDelete(*L,i)	//在表L中第i个数据元素
	TraverseList(L)	//对表L进行遍历，对每个结点（数据元素）访问一次

endADT

顺序存储结构

顺序存储定义：线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素，示意图如下。

数组的长度是存放在线性表的存储空间的长度，存储分配后这个量是一般不表的。

线性表的长度是线性表中数据元素的个数，随着线性表插入和删除操作的进行，这个量是变化的。

线性表顺序存储结构元素插入算法的思路：

1、如果插入位置不合理，抛出异常。

2、如果线性表长度大于等于数组长度，则抛出异常或动态增加容量。

3、从最后一个元素开始向前遍历到第i个位置，分别将它们都向后移动一个位置；

4、将要插入元素填入位置i处。

5、表长加1。

/* 初始条件：顺序线性表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--)  /* 将要插入位置之后的数据元素向后移动一位 */
            L->data[k + 1] = L->data[k];
    }
    L->data[i - 1] = e;          /* 将新元素插入 */
    L->length++;

    return OK;
}

线性表顺序存储结构元素删除算法的思路：

1、如果删除位置不合理，抛出异常。

2、取出删除元素。

3、从删除元素位置开始遍历到最后一个元素位置，分别将它们都向前移动一个位置；

4、表长减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;
}

线性表顺序存储结构的插入和删除时间复杂度分析：

最好情况：插入元素到最后一个位置，或者删除最后一个元素，此时时间复杂度为O(1)；

最坏情况：插入元素到第一个位置，或者删除第一个元素，此时时间复杂度为O(n)；

平均情况：（n-1）/2。

平均时间复杂度还是O(n)。

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

线性表顺序存储结构优缺点
优点	缺点
无需为表示表中元素之间的逻辑关系而增加额外的存储空间	插入和删除操作需要移动大量元素
可以快速地存取表中任意位置元素	当线性表长度变化较大时，难以确定存储空间的容量
	造成存储空间的“碎片”

链式存储结构

线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。

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

n个结点（ $a_{i}$ 的存储映像）链结成一个链表，即为线性表（ $a_{1}$ ， $a_{2}$ ，...， $a_{n}$ ）的链式存储结构，因为此链表的每个结点中只包含一个指针域，所以叫做单链表。

链表中第一个结点的存储位置叫做头指针，线性链表的最后一个结点为“空”（用NULL或“^”表示）。

Sometimes，我们为了更加方便地对链表进行操作，会在单链表的第一个结点前附设一个结点，称为头结点。头结点的数据域可以不存储任何信息，也可以存储如线性表的长度等附加信息，头结点的指针域存储指向第一个结点的指针。

头指针与头结点异同

头指针与头结点异同
头指针	头结点
头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针。	头结点是为了操作的统一和方便而设立的，放在第一个元素的结点之前，其数据域一般无意义（也可存放链表的长度）
头指针具有标识作用，所以常用头指针冠以链表的名字。	有了头结点，对在第一元素结点前插入结点和删除第一结点，其操作与其它结点的操作就统一了。
无论链表是否为空，头指针均不为空。头指针是链表的必要元素。	头结点不一定是链表必须元素

C语言中用结构指针描述

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

单链表的读取

获得链表第i个数据的算法思路

1、声明一个结点p指向链表第一个结点，初始化j从1开始；

2、当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累计加1；

3、若到链表末尾p为空，则说明第i个元素不存在；

4、否则查找成功，返回结点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个数据插入结点的算法思路：

1、声明一结点p指向链表第一个结点，初始化j从1开始；

2、当j<i时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1；

3、若到链表末尾p为空，则说明第i个元素不存在;

4、否则查找成功，在系统中生成一个空结点s;

5、将数据元素e赋值给s->data;

6、单链表的插入标准语句s->next = p->next; p->next=s;

7、返回成功。

单链表的删除

单链表第i个数据删除结点的算法思路：

1、声明一结点p指向链表第一个结点，初始化j从1开始。

2、当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1；

3、若到链表末尾p为空，则说明第i个元素不存在；

4、否则查找成功，将欲删除的结点p->next赋值给q；

5、单链表的删除标准语句p->next=q->next;

6、将q结点中的数据赋值给e，作为返回；

7、释放q结点；

8、返回成功；

实现代码算法如下：


/* 初始条件：链式线性表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;
}

对于插入或删除数据越频繁的操作，单链表的效率优势越是明显。

单链表整表的创建：

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

1、声明一结点p和计算器变量i；

2、初始化一空链表L;

3、让L的头结点的指针指向NULL，即建立一个带头结点的单链表；

4、循环：

4.1、生成一新结点赋值给p；

4.2、随机生成一数字赋值给p的数据域p->data；

4.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;						/*  插入到表头 */
	}
}


/*  随机产生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;                       /* 表示当前链表结束 */
}

单链表整表的删除：

释放内存

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

1、声明一结点p和q；

2、将第一个结点赋值给p；

3、循环：

3.1、将下一个结点赋值给q；

3.2、释放p；

3.3、将q赋值给p。

实现算法：

/* 初始条件：链式线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{ 
	LinkList p,q;
	p=(*L)->next;           /*  p指向第一个结点 */
	while(p)                /*  没到表尾 */
	{
		q=p->next;
		free(p);
		p=q;
	}
	(*L)->next=NULL;        /* 头结点指针域为空 */
	return OK;
}

单链表结构与顺序存储结构优缺点：

存储分配方式

时间性能

空间性能

顺序存储结构用一段连续的存储单元依次存储线性表的数据元素。

查找：

顺序存储结构O(1)

单链表O(n)

顺序存储结构需要预分配存储空间，分大了，浪费，分小了易发生上溢。

单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素

插入与删除：

顺序存储结构需要平均移动表长一半的元素，时间为O(n)

单链表在线出某位置的指针后，插入和删除时间仅为O(1)

单链表不需要分配存储空间，只要有就可以分配，元素个数不受限制。

静态链表

数组描述的链表叫静态链表。

静态链表优缺点
优点	缺点
在插入和删除操作时，只需要修改游标，不需要移动元素，从而改进了在顺序存储结构中的插入和删除操作需要移动大量元素的缺点	没有解决连续存储分配带来的表长难以确定的问题
	失去了顺序存储结构随机存取的特性

总的来说，静态链表其实是为了给没有指针的高级语言设计的一种实现单链表能力的方法。