前言
记录数据结构与算法学习，内附详细实现方法，方便后续回顾。
一、线性表基础概念
线性表存储方式包括：顺序存储和链表存储。
顺序存储方式：顺序表。
链表存储方式：单链表、循环链表、双向链表、双向循环链表。
-
线性表的特点
对于非空的线性表和线性结构,其特点如下:
- 存在唯⼀的一个被称作 “第一个” 的数据元素
- 存在唯⼀的一个被称作 “最后一个” 的数据元素
- 除了第⼀个之外，结构中的每个数据元素均有⼀个前驱
- 除了最后一个之外，结构中的每个数据元素都有一个后继
-
线性表的类型定义
线性表是一个相当灵活的数据结构，其长度可根据需要来增长或缩短，对线性表的数据元素不仅可以进行访问查询，而且可以对其进行插入和删除等操作。
ADT List {
/*
1. Data: 线性表的数据对象集合为{a1,a2,......an}，每个元素的类型均为DataType。
2. 其中，除了第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每个元素有且只有一个直接后继元素。
3. 数据元素之间的关系是一对一的关系。
*/
Operation
// 操作结果: 初始化操作，建立一个空的线性表L
InitList(&L)
// 初始条件: 线性表L已存在
// 操作结果: 销毁线性表L
DestroyList(&L)
// 初始条件: 线性表L已存在
// 操作结果: 将L重置为空表
ClearList(&L)
// 初始条件: 线性表L已存在
// 操作结果: 若L为空表，则返回true，否则返回false
ListEmpty(L)
// 初始条件: 线性表L已存在
// 操作结果: 返回L中数据元素的个数
ListLength(L)
// 初始条件: 线性表L已存在，且1<=i<ListLength(L)
// 操作结果: 用e返回L中第i个数据元素的值
GetElem(L,i,&e)
// 初始条件: 线性表L已存在
// 操作结果: 返回L中第1个值与e相同的元素在L中的位置，若数据不存在则返回0
LocateElem(L,e)
// 初始条件: 线性表L已存在
// 操作结果: 若cur_e是L的数据元素，且不是第一个，则用pre_e返回其前驱,否则操作失败
PriorElem(L,cur_e,&pre_e);
// 初始条件: 线性表L已存在
// 操作结果: 若cur_e是L的数据元素，且不是最后一个，则用next_e返回其后继,否则操作失败
NextElem(L,cur_e,&next_e);
// 初始条件: 线性表L已存在，且1<=i<=listLength(L)
// 操作结果: 在L中第i个位置之前插入新的数据元素e，L长度加1
ListInsert(L,i,e);
// 初始条件: 线性表L已存在，且1<=i<=listLength(L)
// 操作结果: 删除L的第i个元素，L的长度减1
ListDelete(L,i);
// 初始条件: 线性表L已存在
// 操作结果: 对线性表L进行遍历，在遍历的过程中对L的每个结点访问1次
TraverseList(L);
} ADT List
二、顺序存储：
1. 顺序表
线性表的顺序存储指的是一组地址连续的存储单元依次存储线性表的数据元素，这种表示也称为线性表的顺序存储或顺序映像。通常称这种存储结构的线性表为顺序表(Sequential List)。
特点：逻辑相邻的数据元素，其物理存储地址也相邻。
- 准备：
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
/* ElemType类型根据实际情况而定，这里假设为int */
typedef int ElemType;
/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Status;
- 顺序表结构设计:
/*顺序表结构设计*/
typedef struct {
ElemType *data;
int length;
}Sqlist;
- 初始化
Status InitList(Sqlist *L) { // *L 传指针地址，以便修改
// 为顺序表申请一个大小为MAXSIZE个数据元素的空间
L->data = malloc(sizeof(ElemType) * MAXSIZE);
// 如果存储分配失败退出
if(!L->data) exit(ERROR);
// 空表长度为0
L->length = 0;
return OK;
}
- 插入
/*
初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
操作结果：在L中第i个位置之前插入新的数据元素e，L的长度length加1
*/
Status ListInsert(Sqlist *L,int i,ElemType e){
/* i值不合法判断
因为顺序表应该是连续的，此判断是为了顺序连续插入，而不是间隔插入。
*/
if((i<1) || (i>L->length+1)) return ERROR;
// 存储空间已满
if(L->length == MAXSIZE) return ERROR;
// 插入数据不在表尾，则先移动出空余位置
if(i <= L->length){
for(int j=L->length-1; j>=i-1; j--){
// 插入位置以及之后的位置后移动1位
L->data[j+1] = L->data[j];
}
}
// 将新元素e 放入第i个位置上
L->data[i-1] = e;
// 长度+1
++L->length;
return OK;
}
- 删除
// 顺序存储的删除就是把空间占据掉，后边移动把前边覆盖
/*
初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
操作结果: 删除L的第i个数据元素,L的长度减1
*/
Status ListDelete(Sqlist *L,int i){
// 线性表为空
if(L->length == 0) return ERROR;
// i值不合法判断
if((i<1) || (i>L->length+1)) return ERROR;
for(int j = i; j < L->length;j++){
// 被删除元素之后的元素向前移动
L->data[j-1] = L->data[j];
}
//表长度-1;
L->length --;
return OK;
}
- 清空列表
/*
初始条件：顺序线性表L已存在。
操作结果：将L重置为空表
*/
Status ClearList(Sqlist *L)
{
L->length=0;
return OK;
}
- 查询取值
Status GetElem(Sqlist L,int i, ElemType *e){
//判断i值是否合理，若不合理，返回ERROR
if(i<1 || i > L.length) return ERROR;
//data[i-1]单元存储第i个数据元素.
*e = L.data[i-1];
return OK;
}
- 判断顺序表清空
/*
初始条件：顺序线性表L已存在
操作结果：若L为空表，则返回TRUE，否则返回FALSE
*/
Status ListEmpty(Sqlist L)
{
if(L.length==0)
return TRUE;
else
return FALSE;
}
- 获取顺序表长度：元素个数
int ListLength(Sqlist L)
{
return L.length;
}
- 顺序输出List
/*
初始条件：顺序线性表L已存在
操作结果：依次对L的每个数据元素输出
*/
Status TraverseList(Sqlist L)
{
int i;
for(i=0;i<L.length;i++)
printf("%d, ",L.data[i]);
printf("\n");
return OK;
}
- 顺序表查找元素并返回位置
/*
初始条件：顺序线性表L已存在
操作结果：返回L中第1个与e满足关系的数据元素的位序；
若这样的数据元素不存在，则返回值为0
*/
int LocateElem(Sqlist L,ElemType e)
{
int i;
if (L.length==0) return 0;
for(i=0;i<L.length;i++)
{
if (L.data[i]==e)
break;
}
if(i>=L.length) return 0;
return i+1;
}
- 主函数调用
int main(int argc, const char * argv[]) {
// insert code here...
printf("Hello, Data Structure!\n");
Sqlist L;
Sqlist Lb;
ElemType e;
Status iStatus;
// 顺序表初始化
iStatus = InitList(&L);
printf("初始化L后: L.Length = %d\n", L.length);
// 顺序表数据插入
for(int j=1; j <= 5;j++){
iStatus = ListInsert(&L, 1, j);
}
printf("插入数据L长度: %d\n",L.length);
// 顺序表删除第2个元素
ListDelete(&L, 2);
printf("顺序表删除第%d元素,长度为%d\n",2,L.length);
// 清空顺序表
iStatus = ClearList(&L);
printf("清空后,L.length = %d\n",L.length);
// 顺序表取值
GetElem(L, 5, &e);
printf("顺序表L第5个元素的值为:%d\n",e);
// 判断List是否为空
iStatus=ListEmpty(L);
printf("L是否空：i=%d(1:是 0:否)\n",iStatus);
// TraverseList
for(int j=1; j <= 5;j++){
iStatus = ListInsert(&L, 1, j);
}
TraverseList(L);
return 0;
}
/*
打印：
初始化L后: L.Length = 0
插入数据L长度: 5
顺序表删除第2元素,长度为4
清空后,L.length = 0
顺序表L第5个元素的值为:0
L是否空：i=1(1:是 0:否)
5, 4, 3, 2, 1,
*/
哨兵：C语言中一般会使用哨兵，来减少查找判断，即平时数据放在a[0] ~ a[n]中，使用了哨兵后，放在a[1] ~ a[n]中，a[0]是没有意义的值。
例如从整数数组arr中，查找有没有整数num：
没有哨兵，从i=0开始for循环，需要两条判断i<=n和if (a[i] == key)
使用哨兵，从i=1开始for循环只要一条判断if (a[i] == key)，不会产生越界所以无需判断 i<=n
