开发环境
window10
visual studio 2019
c
1 线性表的特点
（1）表中元素个数有限
（2）表中元素具有逻辑上的顺序性，表中元素有其先后次序
（3）表中元素都是数据元素，每个元素都是单个元素
（4）表中元素的数据类型都相同，这意味着每个元素占有相同大小的存储空间
（5）表中元素具有抽象性，即仅讨论元素见的逻辑关系，而不考虑元素究竟表示什么内容
2 线性表的存储结构
#define MAXSIZE 50 //定义线性表的最大长度
#define true 1
#define false 0
2.1 顺序存储
2.1.1 静态分配存储空间
typedef struct {
ElemType data[MAXSIZE]; //顺序表的元素
int length; //顺序表的当前长度
}SqList; //顺序表的类型定义
2.1.2 动态分配存储空间
typedef struct {
ElemType* data; //顺序表的元素
int Maxsize; //顺序表的最大容量
int length; //顺序表的当前长度
}SeqList;
2.1.3 顺序表的基本操作
对动态分配空间的线性表进行操作定义
void InitList(SeqList* L);
int Length(SeqList L);
int LocateElem(SeqList L,ElemType e);
int GetElem(SeqList L,int i);
_Bool ListInsert(SeqList* L, int i, ElemType e);
_Bool ListDelete(SeqList* L, int i, ElemType* e);
void PrintList(SeqList L);
_Bool Empty(SeqList L);
_Bool DestroyList(SeqList* L);
void main() {
SeqList* L = (SeqList*)malloc(sizeof(SeqList) * MAXSIZE); //解决error:C4700错误，初始化局部变量
InitList(L);
······
}
（1） 初始化表
构造一个空的线性表
void InitList(SeqList* L){
L->data = (ElemType*)malloc(sizeof(ElemType) * MAXSIZE);
L->Maxsize = MAXSIZE;
L->length = 0;
}
（2） 求表长
返回线性表L的长度，即L中数据元素的个数
int Length(SeqList L) {
return L.length;
}
（3） 按值查找操作
按值查找操作。在表L中查找具有给定关键字值的元素
int LocateElem(SeqList L,ElemType e) {
int i;
for (i = 0; i < L.length; i++)
if (L.data[i] == e)
return i+1; //下标为i的元素值等于e，返回其位序i+1
return false; //退出循环，说明查找失败
}
（4） 按位查找操作
按位查找操作。获取表L中得第i个位置的元素的值
int GetElem(SeqList L,int i) {
if (i < 1 || i > L.length)
return false;
return L.data[i];
}
（5） 插入操作
在表L中的第i个位置(1<=i<=L.length+1)上插入指定元素e
_Bool ListInsert(SeqList* L, int i, ElemType e) {
//判断合法性
if (i < 1 || i > L->length + 1)
return false; //判断i的范围是否有效
if (L->length >= L->Maxsize)
return false; //当前存储空间已满，不能插入
//插入元素
int j;
for (j = L->length; j >= i; j--)
L->data[j] = L->data[j - 1]; //将第i个元素及之后的元素后移
L->data[i - 1] = e; //在位置i处放入e
L->length++; //线性表长度+1
return true;
}
（6） 删除操作
删除表L中的第i个(1<=i<=L.length)位置的元素，并用e返回删除元素的值
_Bool ListDelete(SeqList* L, int i, ElemType* e) {
//判断合法性
if (i < 1 || i > L->length)
return false; //判断i的范围是否有效
e = L->data[i-1]; //将被删除的元素赋值给e
//删除元素
int j;
for (j = i; j < L->length; j++)
L->data[j - 1] = L->data[j]; //将第i个位置后的元素前移
L->length--; //线性表长度-1
return false;
}
（7） 输出操作
按前后顺序输出线性表L的所有元素值
void PrintList(SeqList L) {
int i;
for (i = 0; i < L.length; i++)
printf("%d\t", L.data[i]);
printf("\n");
}
（8） 判空操作
若L为空表，则返回true，否则返回false
_Bool Empty(SeqList L) {
if (L.length <= 0)
return true;
return false;
}
（9） 销毁操作
销毁线性表，并释放线性表L所占用的内存空间
_Bool DestroyList(SeqList* L) {
if (L != NULL)
free(L);
else
return false;
L = NULL;
return true;
}
2.2 链式存储
2.2.1 单链表及其基本操作
#define MAXSIZE 50 //定义线性表的最大长度
#define true 1
#define false 0
typedef int ElemType; //定义线性表的元素类型
typedef struct LNode {
//定义单链表结点类型
ElemType data; //数据域
struct LNode* next; //指针域
}LNode, * LinkList;
LinkList List_HeadInsert(LinkList L);
LinkList List_TailInsert(LinkList L);
LNode* GetElem(LinkList L, int i);
LNode* LocateElem(LinkList L, ElemType e);
_Bool ListInsertAfter(LinkList L, int i, ElemType e);
_Bool ListInsertFront(LinkList L, int i, ElemType e);
_Bool ListDeletePos(LinkList L, int i, ElemType e);
_Bool ListDeleteNode(LinkList L, LNode* p, ElemType e);
void PrintList(LinkList L);
_Bool DestroyList(LinkList L);
_Bool Empty(LinkList L);
void main() {
LinkList L = NULL;
······;
}
（1）建立单链表
（1.1）头插法建立单链表
从一个空表开始，生成新结点，并将读取到的数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头，即头结点之后。
LinkList List_HeadInsert(LinkList L) {
//头插法，逆向建立单链表
LNode* s;
ElemType x;
L = (LinkList)malloc(sizeof(LNode)); //创建链表/头结点
L->next = NULL; //初始为空
scanf_s("%d", &x); //引用：取地址
while (x != 9999) {
//输入9999表示结束
s = (LNode*)malloc(sizeof(LNode)); //创建新结点
s->data = x;
s->next = L->next;
L->next = s; //将新结点插入表中，L为头指针
scanf_s("%d",&x);
}
return L;
}
（1.2）尾插法建立单链表
将新结点插入到当前链表的表尾，为此必须增加一个尾指针tail，使其始终指向当前链表的尾结点。
LinkList List_TailInsert(LinkList L) {
//尾插法，正向建立单链表
LNode* s;
ElemType x;
L = (LinkList)malloc(sizeof(LNode)); //创建链表
LNode* tail = L; //创建尾结点
scanf_s("%d", &x); //引用：取地址
while (x != 9999) {
//输入9999表示结束
s = (LNode*)malloc(sizeof(LNode)); //创建新结点
s->data = x;
tail->next = s;
tail = s; //将新结点插入表中，L为头指针
scanf_s("%d", &x);
}
tail->next = NULL; //为空
return L;
}
（2）查找结点值
（2.1）按序号
从第一个结点出发，顺指针next域逐个往下搜索，直到找到第i个结点为止，否则放回最后一个结点指针域NULL。
LNode* GetElem(LinkList L, int i) {
int count = 1; //计数，初始为1
LNode* p = L->next; //头结点指针赋给p
if (i == 0)
return L; //若i等于0，则返回头结点
if (i < 1)
return NULL; //若i无效，则返回NULL
while (p && count < i) {
//从第1个结点开始找，查找第i个结点
p = p->next;
count++;
}
return p; //返回第i个结点的指针，若i大于表长则返回NULL
}
（2.1）按值
从第一个结点开始，由前往后依次比较表中各结点数据域的值，若某结点数据域的值等于给定值e，则返回该结点的指针；若整个表中没有这样的结点，则返回NULL。
LNode* LocateElem(LinkList L, ElemType e) {
LNode* p = L->next;
while (p != NULL && p->data != e) //从第1个结点开始查找data域为e的结点
p = p->next;
return p; //找到后返回该结点指针，否则返回NULL
}
（3）插入结点操作
（3.1）后插
将值为x的新结点插入到单链表的第i个位置上
_Bool ListInsertAfter(LinkList L, int i, ElemType e) {
LNode* s;
LNode* p;
if (!(p = GetElem(L, i - 1))) //查找插入位置的前驱结点
return false;
s = (LNode*)malloc(sizeof(LNode)); //创建新结点
s->data = e;
s->next = p->next;
p->next = s;
return true;
}
（3.2）前插
将值为x的新结点插入到单链表的第i个位置结点的前面
_Bool ListInsertFront(LinkList L, int i, ElemType e) {
LNode* s;
LNode* p;
ElemType temp;
if (!(p = GetElem(L, i - 1)))
return false;
s = (LNode*)malloc(sizeof(LNode)); //创建新结点
s->data = e;
s->next = p->next;
p->next = s;
/*交换数据域*/
temp = p->data;
p->data = s->data;
s->data = temp;
return true;
}
（4）删除结点操作
（4.1）按位置
将单链表的第i个结点删除
_Bool ListDeletePos(LinkList L, int i, ElemType e) {
LNode* p;
LNode* q;
if (!(p = GetElem(L, i - 1))) //查找删除位置的前驱结点
return false;
q = p->next; //令q指向被删除结点
p->next = q->next; //将*q结点从链中“断开”
e = q->data;
free(q); //释放结点的存储空间
return true;
}
（4.2）按结点
将单链表的指定结点删除
_Bool ListDeleteNode(LinkList L, LNode* p, ElemType e) {
if (p == NULL)
return false;
LNode* q;
q = p->next; //令q指向*p的后继结点
e = q->data;
p->data = q->data; //和后继结点交换数据域
p->next = q->next; //将*q结点从链中“断开”
free(q); //释放后继结点的存储空间
return true;
}
（5）求表长操作
int Length(LinkList L) {
int count = 0;
LNode* p = L;
while (p->next != NULL) {
count++;
p = p->next;
}
return count;
}
（6）打印表操作
void PrintList(LinkList L) {
LNode* p = L;
p = p->next;
while (p != NULL) {
printf("%d ", p->data);
p = p->next;
}
printf("\n");
printf("链表长度：%d\n", Length(L));
}
（7）销毁表操作
_Bool DestroyList(LinkList L) {
if (!L)
return false;
while (L) {
LNode* p;
p = L;
L = L->next;
free(p);
}
return true;
}
（8）判空操作
_Bool Empty(LinkList L) {
if (!L)
return true;
return false;
}
2.2.2 双链表
（1）双链表定义
typedef struct DNode {
//定义双链表结点类型
ElemType data; //数据域
struct DNode* prior, * next; //前驱和后继指针
}DNode,* DLinkList;
（2）插入
在结点p后插入结点s
s->next = p->next;
s->prior = p;
p->next->prior = s;
p->next = s;
（3）删除
删除结点s，p指向结点s的前驱结点
p = s->prior;
p->next = s->next;
s->next->prior = p;
free(s);
2.2.3 循环链表
（1）循环单链表
尾结点甩回头结点。
（2）循环双链表
尾结点后继指针甩回头结点，头结点前驱指针指向尾结点。
2.2.4 静态链表
typedef struct{
//静态链表结构类型的定义
ElemType data; //存储数据元素
int next; //下一个元素的数组下标
}SLinkList[MAXSIZE];
3 参考
王道，侵删