数据结构之线性表（二）——线性表的操作

顺序存储结构

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

示意图如下：

线性表的顺序存储结构

//存储空间初始分配量
#define MAXSIZE 20
//ElemType类型根据实际情况而定，这里假设为int
typedef int ElemType;

typedef struct {
	//数组存储数据元素，最大值为MAXSIZE
	ElemType data[MAXSIZE];
	//线性表当前长度
	int length;
}SqList;

描述顺序存储结构需要三个属性：

1.存储空间的起始位置：数组data，它的存储位置就是存储空间的存储位置；

2.线性表的最大存储容量：数组长度MaxSize;

3.线性表的当前长度：length。

获得元素操作

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

//Status 是函数的类型，其值是函数结果状态代码，如OK等
//初始条件：顺序线性表L已存在，1<=i<=ListLength(L)
typedef int Status;
//操作结果：用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;
}

插入元素操作

//操作结果：在L中第i个位置之前插入新的数据元素e,L的长度加1
Status ListInsert(SqList *L, int i, ElemType e) {
	int k = 0;
	//顺序线性表已经满
	if (L->length == MAXSIZE)
		return ERROR;
	//当i不在范围内时
	if (i<1 || i>L->length + 1) {
		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;
}

删除元素操作

//操作结果：删除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）。

线性表的顺序存储结构比较适合元素个数不太变化，而更多是数据的应用。

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

优点：无须为表示表中元素之间的逻辑关系而增加额外的存储空间；

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

缺点：插入和删除操作需要移动大量元素；

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

造成存储空间的“碎片”。

链式存储结构

我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称为指针或链。这俩部分信息组成数据元素ai的存储映像，称为结点（Node）。

n个结点（ai的存储映像）链结成一个链表，即为线性表（a1，a2，...，an）的链式存储结构，因为此链表的每个结点中只包含一个指针域，所以叫做单链表。

我们把链表中第一个结点的存储位置叫做头指针；我们规定，线性链表的最后一个结点指针为“空”（通常用NULL或“^”符号表示）如图所示：

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

头指针与头结点的异同

头指针：头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针；

头指针具有标识作用，所以常用头指针冠以链表的名字；

无论链表是否为空，头指针均不为空。头指针是链表的必要元素。

头结点：头结点是为了操作的统一和方便而设立的，放在第一元素的结点之前，其数据域一般无意义（也可存放链表的长度）；

有了头结点，对在第一元素结点前插入和删除第一结点，其操作与其他结点的操作就统一了

头结点不一定是链表必须要素。

线性表的链式存储结构

#include "stdafx.h"
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

//存储空间初始分配量
#define MAXSIZE 20

//Status 是函数的类型，其值是函数结果状态代码，如OK等
//初始条件：线性表L已存在，1<=i<=ListLength(L)
typedef int Status;
//ElemType类型根据实际情况而定，这里假设为int
typedef int ElemType;

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

获取元素操作

//操作结果：用e返回L中第i个数据元素的值
Status GetElem(LinkList L, int i, ElemType *e) {
	int j;
	//声明一结点p
	LinkList p;
	//让p指向链表L的第一个结点
	p = L->next;
	//j为计数器
	j = 1;
	//*p不为空或者计数器j还没有等于i时，循环继续
	while (p&&j < i){
		//让p指向下一个结点
		p = p->next;
		++j;
	}
	if (!p || j > i){
		//第i个元素不存在
		return ERROR;
	}
	//取第i个元素的数据
	*e = p->data;
	return OK;
}

插入元素操作

//操作结果：在L中第i个位置之前插入新的数据元素e
Status ListInsert(LinkList *L, int i, ElemType e) {
	int j;
	LinkList p, s;
	p = *L;
	j = 1;
	//寻找第i个结点
	while (p&&j < i) {
		p = p->next;
		++j;
	}
	if (!p || j > i) {
		//第i个元素不存在
		return ERROR;
	}
	//生成新结点
	s = (LinkList)malloc(sizeof(Node));
	s->data = e;
	//将p的后继结点赋值给s的后继
	s->next = p->next;
	//将s赋值给p的后继
	p->next = s;
	return OK;
}

删除元素操作

//操作结果：删除L的第i个数据元素，并用e返回其值
Status ListDelete(LinkList *L, int i, ElemType *e) {
	int j;
	LinkList p, q;
	p = *L;
	j = 1;
	//遍历寻找第i个元素
	while (p->next&&j < i) {
		p = p->next;
		++j;
	}
	if (!(p->next) || j > i)
		//第i个元素不存在
		return ERROR;
	q = p->next;
	//将q的后继赋值给p的后继
	p->next = q->next;
	//将q结点中的数据给e
	*e = q->data;
	free(q);
	return OK;
}

单链表的整表创建

头插法

//随机产生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));
		//随机生成100以内的数字
		p->data = rand() % 100 + 1;
		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为指向尾部的结点
	r = *L;
	for (i = 0; i < n; i++) {
		//生成新结点
		p = (Node*)malloc(sizeof(Node));
		//随机生成100以内的数字
		p->data = rand() % 100 + 1;
		//将表为终端结点的指针指向新结点
		r->next = p;
		//将当前的结点定义为表尾终端结点
		r = p;
	}
	//表示当前链表结束
	r->next = NULL;
}

单链表的整表删除

//操作结果：将L重置为空表
Status ClearList(LinkList *L) {
	LinkList p, q;
	//p指向第一个结点
	p = (*L)->next;
	while (p)
	{
		q = p->next;
		free(p);
		p = q;
	}
	//头结点指针域为空
	(*L)->next = NULL;
	return OK;
}

时间复杂度

对于在同一个位置插入多个元素，我们只需要在第一次时，找到第i个位置的指针，此时为O（n），接下来只是简单地通过赋值移动指针而已，时间复杂度都是O（1）。

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