第 2 章 线性表 （线性表的单链表存储结构实现）
1. 背景说明
2. 示例代码
1) status.h
/* DataStructure 预定义常量和类型头文件 */
#ifndef STATUS_H
#define STATUS_H
#define CHECK_NULL(pointer) if (!(pointer)) { \
printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ERR_NULL_PTR); \
return NULL; \
}
#define CHECK_RET(ret) if (ret != RET_OK) { \
printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ret); \
return ret; \
}
#define CHECK_VALUE(value, ERR_CODE) if (value) { \
printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ERR_CODE); \
return ERR_CODE; \
}
#define CHECK_FALSE(value, ERR_CODE) if (!(value)) { \
printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ERR_CODE); \
return FALSE; \
}
/* 函数结果状态码 */
#define TRUE 1 /* 返回值为真 */
#define FALSE 0 /* 返回值为假 */
#define RET_OK 0 /* 返回值正确 */
#define INFEASIABLE 2 /* 返回值未知 */
#define ERR_MEMORY 3 /* 访问内存错 */
#define ERR_NULL_PTR 4 /* 空指针错误 */
#define ERR_MEMORY_ALLOCATE 5 /* 内存分配错 */
#define ERR_NULL_STACK 6 /* 栈元素为空 */
#define ERR_PARA 7 /* 函数参数错 */
#define ERR_OPEN_FILE 8 /* 打开文件错 */
#define ERR_NULL_QUEUE 9 /* 队列为空错 */
#define ERR_FULL_QUEUE 10 /* 队列为满错 */
#define ERR_NOT_FOUND 11 /* 表项不存在 */
typedef int Status; /* Status 是函数的类型,其值是函数结果状态代码，如 RET_OK 等 */
typedef int Bollean; /* Boolean 是布尔类型,其值是 TRUE 或 FALSE */
#endif // !STATUS_H2) singleLinkList.h
/* 线性表的单链表存储结构头文件 */
#ifndef SINGLELINKLIST_H
#define SINGLELINKLIST_H
#include "status.h"
typedef int ElemType;
typedef struct LNode {
ElemType data;
struct LNode *next;
} *LinkList;
/* 辅助函数，创建一个新的节点 */
LinkList MakeNewLNode(ElemType e);
/* 操作结果：构造一个空的线性表 L */
Status InitList(LinkList *L);
/* 初始条件：线性表 L 已存在。操作结果：销毁线性表 L */
Status DestroyList(LinkList *L);
/* 初始条件：线性表 L 已存在。操作结果：将 L 重置为空表 */
Status ClearList(LinkList L);
/* 初始条件：线性表 L 已存在。操作结果：若 L 为空表，则返回 TRUE，否则返回 FALSE */
Status ListEmpty(LinkList L);
/* 初始条件：线性表 L 已存在。操作结果：返回 L 中数据元素个数 */
int ListLength(LinkList L);
/* 算法 2.8，L 为带头结点的单链表的头指针。当第 i 个元素存在时, 其值赋给 e 并返回 OK,否则返回 ERROR */
Status GetElem(LinkList L, int i, ElemType *e);
/* 初始条件: 线性表 L 已存在, compare() 是数据元素判定函数(满足为 1,否则为 0)
操作结果: 返回 L 中第 1 个与 e 满足关系 compare() 的数据元素的位序。
若这样的数据元素不存在,则返回值为 0 */
int LocateElem(LinkList L, ElemType e, Bollean(*compare)(ElemType, ElemType));
/* 初始条件: 线性表 L 已存在
操作结果: 若 cur_e 是 L 的数据元素,且不是第一个,则用 pre_e 返回它的前驱
函数返回 OK;否则操作失败, pre_e 无定义, 返回 INFEASIBLE */
Status PriorElem(LinkList L, ElemType cur_e, ElemType *pre_e);
/* 初始条件：线性表 L 已存在
操作结果：若 cur_e 是 L 的数据元素，且不是最后一个，则用 next_e 返回它的后继
函数返回 OK;否则操作失败，next_e无定义，返回 INFEASIBLE */
Status NextElem(LinkList L, ElemType cur_e, ElemType *next_e);
/* 算法 2.9，在带头结点的单链线性表 L 中第 i 个位置之前插入元素 e */
Status ListInsert(LinkList L, int i, ElemType e);
/* 算法 2.10，在带头结点的单链线性表 L 中，删除第 i 个元素,并由 e 返回其值 */
Status ListDelete(LinkList L, int i, ElemType *e);
/* 初始条件：线性表 L 已存在
操作结果:依次对 L 的每个数据元素调用函数 vi()。一旦 vi() 失败,则操作失败 */
Status ListTraverse(LinkList L, void(*vi)(ElemType));
#endif3) singleLinkList.c
/* 线性表的单链表存储结构源文件实现 */
#include "singleLinkList.h"
#include
#include
#include
/* 辅助函数，创建一个新的节点 */
LinkList MakeNewLNode(ElemType e)
{
LinkList newLNode = (LinkList)malloc(sizeof(struct LNode));
if (!newLNode) {
printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ERR_MEMORY_ALLOCATE);
return NULL;
}
newLNode->data = e;
newLNode->next = NULL;
return newLNode;
}
/* 操作结果：构造一个空的线性表 L */
Status InitList(LinkList *L)
{
*L = (LinkList)malloc(sizeof(struct LNode));
if (!(*L)) {
printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ERR_MEMORY_ALLOCATE);
return ERR_MEMORY_ALLOCATE;
}
(*L)->next = NULL;
return RET_OK;
}
/* 初始条件：线性表 L 已存在。操作结果：销毁线性表 L */
Status DestroyList(LinkList *L)
{
LinkList q;
while (*L) {
q = (*L)->next;
free(*L);
*L = q;
}
return RET_OK;
}
/* 初始条件：线性表 L 已存在。操作结果：将 L 重置为空表 */
Status ClearList(LinkList L)
{
LinkList p, q;
p = L->next;
while (p) {
q = p->next;
free(p);
p = q;
}
L->next = NULL;
return RET_OK;
}
/* 初始条件：线性表 L 已存在。操作结果：若 L 为空表，则返回 TRUE，否则返回 FALSE */
Status ListEmpty(LinkList L)
{
if (L->next) {
return FALSE;
}
return TRUE;
}
/* 初始条件：线性表 L 已存在。操作结果：返回 L 中数据元素个数 */
int ListLength(LinkList L)
{
int count = 0;
LinkList p = L->next;
while (p) {
++count;
p = p->next;
}
return count;
}
/* 算法 2.8，L 为带头结点的单链表的头指针。当第 i 个元素存在时, 其值赋给 e 并返回 RET_OK,否则返回 ERROR */
Status GetElem(LinkList L, int i, ElemType *e)
{
int j = 1;
LinkList p = L->next;
while (p && j < i) {
p = p->next;
++j;
}
if (!p || j > i) { /* j > i 适用于 i < 1 时，如 i = 0 */
printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ERR_PARA);
return ERR_PARA;
}
*e = p->data;
return RET_OK;
}
/* 初始条件: 线性表 L 已存在, compare() 是数据元素判定函数(满足为 1,否则为 0)
操作结果: 返回 L 中第 1 个与 e 满足关系 compare() 的数据元素的位序。
若这样的数据元素不存在,则返回值为 0 */
int LocateElem(LinkList L, ElemType e, Bollean(*compare)(ElemType, ElemType))
{
int i = 0;
LinkList p = L->next;
while (p) {
++i;
if (compare(p->data, e)) {
return i;
}
p = p->next;
}
return 0;
}
/* 初始条件: 线性表 L 已存在
操作结果: 若 cur_e 是 L 的数据元素,且不是第一个,则用 pre_e 返回它的前驱
函数返回 RET_OK;否则操作失败, pre_e 无定义, 返回 INFEASIBLE */
Status PriorElem(LinkList L, ElemType cur_e, ElemType *pre_e)
{
LinkList q, p = L->next;
while (p->next) {
q = p->next;
if (q->data == cur_e) {
*pre_e = p->data;
return RET_OK;
}
p = q;
}
return INFEASIABLE;
}
/* 初始条件：线性表 L 已存在
操作结果：若 cur_e 是 L 的数据元素，且不是最后一个，则用 next_e 返回它的后继
函数返回 RET_OK;否则操作失败，next_e无定义，返回 INFEASIBLE */
Status NextElem(LinkList L, ElemType cur_e, ElemType *next_e)
{
LinkList p = L->next;
while (p->next) {
if (p->data == cur_e) {
*next_e = p->next->data;
return RET_OK;
}
p = p->next;
}
return INFEASIABLE;
}
/* 算法 2.9，在带头结点的单链线性表 L 中第 i 个位置之前插入元素 e */
Status ListInsert(LinkList L, int i, ElemType e)
{
int j = 0;
LinkList p = L;
while (p && j < i - 1) {
++j;
p = p->next;
}
if (!p || j > i - 1) { /* 超出表长或者 i < 1 */
printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ERR_PARA);
return ERR_PARA;
}
LinkList newLNode = MakeNewLNode(e);
if (!newLNode) {
printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ERR_MEMORY_ALLOCATE);
return ERR_MEMORY_ALLOCATE;
}
newLNode->next = p->next;
p->next = newLNode;
return RET_OK;
}
/* 算法 2.10，在带头结点的单链线性表 L 中，删除第 i 个元素,并由 e 返回其值 */
Status ListDelete(LinkList L, int i, ElemType *e)
{
int j = 0;
LinkList p = L;
while (p->next && j < i - 1) {
++j;
p = p->next;
}
if (!p->next || j > i - 1) { /* 理论上 j 最多只能等于 i - 1, 但此处当参数不合法时可用， 建议单独判断参数合法性 */
printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ERR_PARA);
return ERR_PARA;
}
LinkList q = p->next;
p->next = q->next;
*e = q->data;
free(q);
return RET_OK;
}
/* 初始条件：线性表 L 已存在
操作结果:依次对 L 的每个数据元素调用函数 vi()。一旦 vi() 失败,则操作失败 */
Status ListTraverse(LinkList L, void(*vi)(ElemType))
{
LinkList p = L->next;
while (p) {
vi(p->data);
p = p->next;
}
return RET_OK;
} 4) algorithm.h
/* 算法定义头文件 */
#ifndef ALGORITHM_H
#define ALGORITHM_H
#include "singleLinkList.h"
/* 算法 2.11，逆位序(插在表头)输入 n 个元素的值，建立带表头结构的单链线性表 L */
void CreateList(LinkList *L, int n);
/* 正位序(插在表尾)输入 n 个元素的值，建立带表头结构的单链线性表 */
void CreateList2(LinkList *L, int n);
/* 算法 2.12，已知单链线性表 La 和 Lb 的元素按值非递减排列
归并 La 和 Lb 得到新的单链线性表 Lc，Lc 的元素也按值非递减排列
此处需要释放 Lb 头节点故需要传入 Lb 指针变量 */
void MergeList(LinkList La, LinkList *Lb, LinkList *Lc);
/* 算法 2.1 其他实现，将所有在线性表 Lb 中但不在 La 中的数据元素插入到 La 中 */
void Union(LinkList La, LinkList Lb);
#endif // !ALGORITHM_H5) algorithm.c
/* 算法实现源文件 */
#include "algorithm.h"
#include "auxiliary.h"
#include
#include
/* 算法 2.11，逆位序(插在表头)输入 n 个元素的值，建立带表头结构的单链线性表 L */
void CreateList(LinkList *L, int n)
{
(void)InitList(L);
printf("Please input %d integers: ", n);
int num;
LinkList p;
for (int i = 0; i < n; ++i) {
scanf_s("%d", &num);
p = MakeNewLNode(num);
p->next = (*L)->next;
(*L)->next = p;
}
}
/* 正位序(插在表尾)输入 n 个元素的值，建立带表头结构的单链线性表 */
void CreateList2(LinkList *L, int n)
{
(void)InitList(L);
LinkList q = *L, p;
int num;
printf("Please input %d integers: ", n);
for (int i = 0; i < n; ++i) {
scanf_s("%d", &num);
p = MakeNewLNode(num);
q->next = p;
q = p;
}
}
/* 算法 2.12，已知单链线性表 La 和 Lb 的元素按值非递减排列
归并 La 和 Lb 得到新的单链线性表 Lc，Lc 的元素也按值非递减排列
此处需要释放 Lb 头节点故需要传入 Lb 指针变量 */
void MergeList(LinkList La, LinkList *Lb, LinkList *Lc)
{
LinkList pa = La->next, pb = (*Lb)->next, pc = NULL;
*Lc = pc = La;
while (pa && pb) {
if (pa->data <= pb->data) {
pc->next = pa;
pc = pa;
pa = pa->next;
}
else {
pc->next = pb;
pc = pb;
pb = pb->next;
}
}
pc->next = pa ? pa : pb;
free(*Lb);
}
/* 算法 2.1 其他实现，将所有在线性表 Lb 中但不在 La 中的数据元素插入到 La 中 */
void Union(LinkList La, LinkList Lb)
{
int lengthLa = ListLength(La);
int lengthLb = ListLength(Lb);
ElemType e;
for (int i = 0; i < lengthLb; ++i) {
GetElem(Lb, i + 1, &e);
if (!LocateElem(La, e, Equal)) {
ListInsert(La, ++lengthLa, e);
}
}
} 6) auxiliary.h
/* 辅助函数定义头文件 */
#ifndef AUXILIARY_H
#define AUXILIARY_H
#include "singleLinkList.h"
void Visit(ElemType e);
Bollean Equal(ElemType e1, ElemType e2);
void ShowList(char str[], LinkList L);
#endif // !AUXILIARY_H
7) auxiliary.c
/* 辅助函数实现源文件 */
#include "auxiliary.h"
#include
void Visit(ElemType e)
{
printf("%d ", e);
}
Bollean Equal(ElemType e1, ElemType e2)
{
return (e1 == e2) ? TRUE : FALSE;
}
void ShowList(char str[], LinkList L)
{
printf("%s", str);
ListTraverse(L, Visit);
putchar('\n');
} 8) main.c
/* 主函数入口源文件 */
#include "singleLinkList.h"
#include "algorithm.h"
#include "auxiliary.h"
#include
int main(void)
{
int n = 5;
LinkList La;
CreateList(&La, n);
ShowList("La is: ", La);
LinkList Lb;
CreateList2(&Lb, n);
ShowList("Lb is: ", Lb);
LinkList Lc;
MergeList(La, &Lb, &Lc);
ShowList("Lc is: ", Lc);
int ret = DestroyList(&Lc);
CHECK_RET(ret);
/* free() 的作用：仅仅是释放堆内存，不将指针置空 */
printf("After Destroy list Lc, the address of Lc is %p\n", Lc);
/* 算法 2.1 其他实现测试 */
LinkList LA, LB;
CreateList2(&LA, 5);
CreateList2(&LB, 5);
ShowList("LA is: ", LA);
ShowList("LB is: ", LB);
Union(LA, LB);
ShowList("LA is: ", LA);
ShowList("LB is: ", LB);
DestroyList(&LA);
DestroyList(&LB);
return 0;
} 3. 运行示例
