C 语言实现抽象数据类型（ADT）之链表
1 什么是链表？(懂跳)
C 语言本身自带了很多基本数据类型，每种基本数据类型的变量总是代表着某个数据，比如：我们通常用整型变量来计数，用浮点型变量来保存价格这样的数据……
int count;
double price;
而有时候我们需要表示的数据很复杂，比如我们想要保存一件商品的价格的同时，也能够保存这件商品的名称，这个时候结构体就派上用场了。
struct Book {
char bookName[100];
double bookPrice;
}
而像这样的多元数据，往往不止一个，我们通常的做法是使用结构体数组。
struct Book books[100];
但结构体数组的元素个数是有上限的，而且数组开辟的内存空间是连续的，这样内存利用率不高。在实际开发过程中，数据个数通常都是不确定的，都是动态变化的。
所以可以使用C 语言的动态内存分配在程序运行期间，动态的为每个这样的数据开辟空间。
(struct Book*)malloc(sizeof(struct Book));
但这样又有一个问题，就是每为一个数据开辟内存空间，就需要使用一个指针变量来保存它的地址，而如果使用数组来保存这些指针，虽说指针数组占用空间比较小，但显然又回到了最初的问题，就是数据的个数是有上限的。
而如果也使用动态内存分配的方式存储指针，那么存储这些指针的内存空间又需要新的指针“跟踪”。
于是就有了链表。
我们可以在每为一个数据开辟空间的时候，把这个数据的内存地址保存在上一个数据中，这样一来，只有第一个数据的指针需要另外保存，这个指针叫做头指针。
struct Book {
char bookName[100];
double bookPrice;
struct Book* next;
}
//每一个块数据中都存储着下一个数据的内存地址
//如果是最后一个，把其中“下一个”的指针赋为NULL即可
struct Book* head; //只需要一个头指针定位整条链表的头即可
这样一来，通过动态内存分配为每一个数据分配的内存空间，都被巧妙的链接了起来，于是把这种数据结构称为链表。把其中的每一块内存空间又形象的称为一个节点。
2 数据的封装
为了提高代码的复用性，我们在创建链表之前，应该对元数据进行封装。
我们可以将元数据的定义放在一个头文件中。
/*MyType.h*/
#pragma once
struct MyType {
/*......*/
};
typedef struct MyType Item;
这样元数据就被封装成了Item类型。后面如果我们想要修改元数据类型，只需要需改此文件中的定义即可。
然后分别通过LinkedList.h和LinkedList.c两个文件来实现链表。
/*LinkedList.h*/
#pragma once
#include "MyType" //包含Item的定义
#include <stdbool.h> //使用bool
//封装节点
typedef struct listNode {
Item item;
struct listNode* next;
}Node;
//抽象：链表类型，用于存储链表头指针和其他信息
typedef struct linkedList {
Node* head; //头指针，必须，不仅定位头节点，也定位整个链表
Node* tail; //尾指针：为了方便在链表末尾追加节点，不是必须
bool isNull; //存储一个链表是否为空的布尔值
unsigned nodeCount; //存储链表中的节点数
}List;
如此一来，就完成了从元数据到链表的封装，封装不是必须的。
3 实现接口API
为什么要把链表封装成一种抽象数据类型（ADT）？在开发中，数据结构就像是，在造汽车中的轮胎一样，几乎是开发过程中必然会使用的工具，我们为了追求开发效率，必然不可能每次开发都去“造轮子”，所以把链表封装成一种抽象数据类型（ADT）可以大大简化后续的开发工作。
所以我们把对链表的所有操作都抽象得封装成函数，即把它当成一种数据类型，就如同C语言的内置类型一样。
每一种数据类型，都有属性和相关操作这两个特征，比如int类型的属性就是表示一个整数，相关操作有加减乘除等。
而链表的属性就是表示多个、内存空间不连续的相同类型的数据。和数组的概念类似（数组也是一种数据结构），只不过链表要比数据灵活，将其抽象封装的一个目的，就是能像使用数组那样简单而高效的使用链表这种数据结构。
链表的操作和数组有所不同，它更加复杂。它所有的操作都需要借助函数来完成。
- 初始化链表
void initList(List* const pList);//const 表示这个函数不会改变plist的值
- 判断一个链表是否为空
bool isListEmpty(const List* const pList);//const分别表示不会改变*pList和pList的值
- 获取一个链表中元数据的数量（节点数）
unsigned itemsCountOfList(const List* const pList);
- 在链表末尾添加一个元素
bool appendItemToList(List* const pList, const Item* const pItem);
- 清空一个链表
void clearList(List* const pList);
- 对链表中的每一项都执行某个函数（遍历链表）
void traverseList(const List* const pList, void(*pfun)(Item* pItem));
由于元数据的不同，所以不涉及任何对元数据的操作，这必须由实现元数据的人来写，或者说与元数据的定义写在一起。
等等……
关于链表的操作不止这些，这里只演示这些。
将这些接口函数的声明写在LinkedList.h中，然后在LinkedList.c中实现。这样做的好处是，隐藏具体实现，将接口对外公开；后续使用链表时，只需查看头文件即可一目了然。
/*LinkedList.c*/
#include "LinkedList.h"
#include <stdlib.h>
#include <stdbool.h>
void initList(List* const pList) {
if (pList != NULL) { //防止访问空指针
pList->head = NULL;
pList->tail = NULL;
pList->isNull = true;
pList->nodeCount = 0;
}
}
bool isListEmpty(const List* const pList) {
return pList->isNull;
}
unsigned itemsCountOfList(const List* const pList) {
return pList->nodeCount;
}
bool appendItemToList(List* const pList, const Item* const pNewItem) {
if (pList != NULL) {
Node* pNewNode = (Node*)malloc(sizeof(Node));
if (pNewNode != NULL) {
pNewNode->item = *pNewItem;
pNewNode->next = NULL;
if (pList->head == NULL) {
pList->head = pNewNode;
pList->isNull = false;
} else {
pList->tail->next = pNewNode;
}
pList->tail = pNewNode;
pList->nodeCount++;
return true;
}
}
return false;
}
void traverseList(const List* const pList, void(*pfun)(Item* item)) {
Node* pNode = pList->head;
while (pNode != NULL) {
pfun(&pNode->item);
pNode = pNode->next;
}
}
void clearList(List* const pList) {
if (pList != NULL) {
Node* pNode = pList->head;
while (pList->head != NULL) {
pList->head = pNode->next;
free(pNode);
pNode = pList->head;
}
}
}