数据结构解析——小白也能看懂的单链表
引言
单链表在数据结构中是很重要的一种线性结构，它是单向的，有着非常广泛的应用领域；虽然现在很多语言中都有封装好的链表类型可以直接使用，但是自己能写一个链表并实现基本操作是至关重要的；
接下来我将用代码展示单链表的创建和一些基本操作；
注：以下代码仅供参考，并不一定是最优代码，只是想让各位了解单链表如何进行的一些基本操作；
单链表的结构
单链表就是由一个一个节点组成，这个节点由一个数据域和指针域组成；
如图：
所以，我们需要先创建节点结构，然后才能依次组成单链表；
注：以下链表的数据域的数据类型都是int类型，实际情况可以修改为任意数据类型；
这里使用结构体来创建，代码如下：
// 单链表节点结构
typedef struct Node {
int data; // 数据域
struct Node* next; // 指针域
}NODE;
可以看到，指针域指向的其实就是该节点本身的数据类型，所以这一点一定要注意！
单链表的初始化和创建
有了基本组成单元，那么就要创建链表了，这里我分为两个函数来实现：
void initList(NODE*& head); // 初始化链表void creatList(NODE*& head); // 创建一个链表
初始化链表很简单，直接看代码：
// 初始化链表
void initList(NODE*& head) {
try {
head = new NODE;
}
catch (bad_alloc& e) {
cout << "内存分配失败！！" << endl;
cout << e.what() << endl; // 输出异常信息
} // 捕获异常
head->data = 0;
head->next = NULL;
return;
}
这里还有一点值得一提：
当链表内存分配失败时，我是用的是try…catch捕获的异常，这个使用于现在的大部分新版的编译器，因为新版编译器在内存分配失败的情况下将不再会返回NULL；老版的编译器入VC++6.0等就会返回NULL，所以一定要注意对内存分配失败的处理；
接下来就是创建一个单链表了，这里使用的是尾插法；
为什么使用尾插法呢？因为头插法输出的链表和输入的顺序是相反的，所以最好使用尾插法来创建链表；
这里创建的链表也需要注意：
该链表创建时会有一个没有什么实际意义的头节点，它的数据域存放的是链表的长度，当然创建头节点的目的也是为了方便对链表的操作；
代码如下：
void creatList(NODE*& head) {
// 1，确定创建链表长度
int len;
cout << "请输入创建链表长度：" << endl;
cin >> len;
// 链表长度不应该为0和负数
if (len <= 0) {
cout << "创建链表长度不能是0或负数" << endl;
return;
}
head->data = len; // 头节点数据域存放链表长度
// 2，创建一个尾节点
NODE* tail = head; // 定义一个节点为尾节点，指向头节点，它将代替头节点移动
tail->next = NULL;
// 3，循环创建新的节点
for (int i = 0; i < len; ++i) {
cout << "请输入第" << i + 1 << "个数据" << endl;
int val;
cin >> val;
NODE* newNode = NULL;// 创建一个新节点作为临时节点
try {
newNode = new NODE;
}
catch (bad_alloc& e) {
cout << "内存分配失败！！" << endl;
cout << e.what() << endl;
} // 捕获异常
newNode->data = val; // 新节点数据域赋值
tail->next = newNode; // 将新节点挂在尾节点后面
newNode->next = NULL; // 新节点指针域为空
tail = newNode; // 尾节点为新的节点
}
return;
}
这一步的操作一定要学会，因为只有创建出来链表后你才能对链表进行其他操作；
遍历输出链表和链表长度
下面的操作是遍历链表并输出和返回链表的长度；
为什么把这两个函数放一起？因为它们的操作可以说是一模一样，只是有很小的改动；
当然对链表遍历也是非常简单，所以不需要有太大的心理负担；
遍历输出链表代码如下：
void traverseList(NODE* head) {
NODE* p = head->next; // 临时节点p指向头节点的下一个节点
while (p) {
cout << p->data << " ";
p = p->next; // p移向下一个节点
}
cout << endl;
return;
}
虽然简单，但是还是需要注意一点：
临时节点不要忘记，因为头节点是没有什么实际意义的节点，所以输出头节点并没有什么意义；
获取链表长度代码如下：
int listLength(NODE* head) {
NODE* p = head->next; // 临时节点p指向头节点的下一个节点
int len = 0; // 链表长度
while (p) {
++len; // 长度加一
p = p->next; // p移向下一个节点
}
return len;
}
是不是很简单，只是只需要修改关键的一句代码即可求得链表长度；
排序操作
有时我们可能会遇到一些情况需要对链表进行排序，链表是线性存储结构，那么该如何排序呢？
其实也很简单，只需要将数据域的内容进行交换排序即可，也就是只对数据域进行操作，并不改变链表结构；
这里是顺序排序；
代码如下：
void sortList(NODE*& head) {
int t;
NODE* p;
NODE* q;
for (p = head->next; p != NULL; p = p->next) {
for (q = p->next; q != NULL; q = q->next) {
// 交换数据域的内容
if (p->data > q->data) {
t = p->data;
p->data = q->data;
q->data = t;
}
}
}
}
这个排序算法并不是最优的，但是非常好理解，所以先学会一种方法再去突破吧！
插入操作和删除操作
单链表和数组都是线性存储结构，数组的优点是：可以实现快速查询；链表的的优点是：可以快速的实现插入和删除操作；
所以，插入和删除操作在单链表中是非常非常非常重要的！！
对于链表的插入和删除操作，只需要记住一点：插入/删除哪个位置，一定要找到该位置的前一个位置；
还是画个图吧：
我来描述一下这张图：
- 想要在data3的位置插入新节点节点s，首先需要找到data3的前一个位置：data2的位置，也就是p指针指向的位置；
- 接下来就是插入操作了
- 第一步1：先把新节点s挂到data3上；（即让s节点指向data3节点）
- 第二步2：断开p节点和data3节点的联系；
- 第三步3：让p节点指向s节点；（即p节点指针域存放s节点地址）
下面就来看一下代码：
void insertListByPostion(NODE*& head, int data, int pos) {
int i = 1;
NODE* p = head;
while (p && i < pos) {
++i;
p = p->next;
}
if (!p || i > pos) {
cout << "插入位置不存在！！" << endl;
return;
}
NODE* newNode = NULL;
try {
newNode = new NODE;
}
catch (bad_alloc& e) {
cout << "内存分配失败！！" << endl;
cout << e.what() << endl;
} // 捕获异常
newNode->data = data;
newNode->next = p->next;
p->next = newNode;
head->data++;
cout << "插入成功！！" << endl;
}
需要注意：插入节点位置必须存在，即首部尾部和中间，所以前面需要先判断插入位置是否存在；
删除操作更简单，如图：
同样描述一下该图：
- 想要删除q节点，所以先找到q节点前一个位置：p节点；
- 接下来是删除操作：
- 第一步：让p节点指向r节点
- 第二步：释放q节点内存空间
是不是很简单；
来看一下代码如何实现：
void deleteListByPostion(NODE*& head, int pos) {
int i = 1;
NODE* p = head;
while (p->next && i < pos) {
p = p->next;
++i;
}
if (!p->next || i > pos) {
cout << "删除位置不存在！！" << endl;
return;
}
NODE* q = p->next;
p->next = q->next;
cout << "删除成功！！删除元素为：" << q->data << endl;
delete q;
head->data--;
}
同样需要注意：删除节点位置必须存在，所以需要先判断插入位置是否存在，因为删除只能删除节点只能删除存在的节点，所以判断条件和插入节点有些不同，不理解可以画个图细细品味；
按顺序合并两个有序链表
这个操作其实已经不算是单链表的基本操作了，它是将两个顺序的链表合并为一个顺序的链表，并且使用O(1)的空间复杂度，既不能使用额外空间，但是考研时经常会出现，所以就来实现一下；
其实力扣上有原题，可以看看我的这篇文章：21. 合并两个有序链表(C语言)，这里就不再写解析了；
代码如下：
void mergeTwoLists(NODE*& l1, NODE*& l2, NODE*& list) {
list->data = l1->data + l2->data; // 头节点数据域为两个链表个数之和
NODE* p = list;
NODE* list1 = l1->next; // list1为l1头节点下一个节点
NODE* list2 = l2->next; // list2为l2头节点下一个节点
// 要对没有头节点的链表进行操作，一定不能带上头节点进行比较
while (list1 && list2) {
if (list1->data < list2->data) {
p->next = list1;
list1 = list1->next;
}
else {
p->next = list2;
list2 = list2->next;
}
p = p->next;
}
p->next = list1 ? list1 : list2;
return;
}
其实这里还是需要注意一点：
力扣上的测试链表是没有头指针的，所以我们的链表不能直接去使用力扣上的代码，需要进行一些小改动，但是基本的算法思想还是一样的；
逆序链表
这个操作是将链表逆置，且同样不能使用额外内存空间；这个力扣上也有原题，解析可以看看我的这篇文章：剑指 Offer 24. 反转链表(C语言)
这个操作其实非常简单，就是一个双指针操作；
代码如下：
void reverseList(NODE*& head, NODE*& list) {
// 双指针
list = head; // 先把头节点连接到新的链表上
NODE* fast = head->next;
NODE* slow = NULL;
while (fast) {
NODE* node = fast->next;
fast->next = slow;
slow = fast;
fast = node;
}
list->next = slow;
}
同样需要注意：
力扣上的测试链表是没有头指针的，所以我们的链表不能直接去使用力扣上的代码，需要进行一些小改动，但是基本的算法思想还是一样的；
总结
链表的操作其实是非常多的，这里只是为你开一个头，不管你是刚学习数据结构的小白，还是有经验的老手，都希望这篇文章可以给你带来一些启发；
数据结构的学习并不一定会让你瞬间感觉到编程能力的提升，这也是很多人学完数据结构感觉没什么用的原因；但是正是数据结构描述了我们生活抽象的事物，让它们变成了代码展示出来，数据结构在你的编程路上是要一直学习和理解的，只有对底层有更深入的了解，你的编程之路才能走的更顺更远！！！
希望我们一起进步！！
欢迎大家的点评！