链表
链表：结构定义
链表是由一串节点串联在一起的，链表的每个节点存储两个信息：数据+下一个节点的地址
分清楚两个概念：什么是内存内部，什么是程序内部
内存内部： 信息存储在内存空间里的
程序内部： 通过什么信息，去操作结构
如果想操作链表的话，我们依靠的是程序内部的信息，而不是内存内部的信息；所以在操作过程中，这些程序内部信息千万不能丢了，因为如果一旦丢了，那么对于内存内部的信息，就永远失去了访问的权限。
代码
结构定义
typedef struct Node{
int data;
struct Node *next;
} Node;
构造节点
Node * getNewNode(int val)
{
Node *p = (Node*)malloc(sizeof(Node));
p->data = val;
p->next = NULL; // 新的节点的下一个指向空
return p;
}
删除链表
循环遍历节点，先用一个指针p指向头节点，因为先需要移动到下一个节点，再销毁前一个指针，所以需要一个q指针来记录下一个节点，然后销毁当前节点指针p
void clear(Node *head)
{
if (head == NULL) return;
// 循环遍历链表中每个节点, 当遍历不为空，就一直向后走
for (Node *p = head, *q; p; p = q) // p是当前节点
{
q = p->next; // 先让q指向下一个节点
free(p); // 再销毁当前节点
}
return;
}
链表：插入元素
插入过程的操作顺序，直接影响了我们是否能正确插入一个元素
程序内部信息：head变量：指向整个链表的头地址，node变量：指向待插入的新节点
需要把4号节点插入到2节点后面
首先，需要一个指针p, 需要找到待插入位置的前一个元素，即1号节点，p指向1号元素
然后，让新的节点(4号节点)指向2号元素
然后，让1号元素指向新的节点(4号元素)：
此时，在逻辑结构上，就已经完成了插入操作：
代码
因为这是无头链表结构，在实现插入操作的时候，返回的是完成插入之后新链表的首地址
无头链表插入操作后链表的首地址是可能发生改变的。
第一种情况：链表为空，或者插入的位置是0位置（原来链表头的位置），就会导致整个链表的头地址发生改变 ，直接返回新节点
第二种情况： 链表不为空，且插入位置在0之后，就是一般的插入操作，返回原链表头节点指针
p指针是用来找到待插入指针的前一个元素
Node * insert(Node *head, int pos, int val)
{
if (pos == 0)
{
Node *node = getNewNode(val); // 先创建新节点
node->next = head; // 让新节点指向原来的头节点
return node; // 直接返回新节点
}
Node *p = head; // p找到待插入位置的前一个元素
for (int i = 1; i < pos; i++) p = p->next; // p走到待插入位置的前一个位置
Node *node = getNewNode(val); // 创建新节点
node->next = p->next; // 先让新节点的next指向待插入位置的节点，即p->next
p->next = node; // 再让p的next指向新节点
// 此时逻辑上已经完成了插入的操作
return head; // 返回原链表头节点
}
链表：错误插入
由于链表的插入很容易犯错，这里演示一个错误的插入操作
先找到待插入位置的前一个元素
正确的插入顺序是，让新的元素指向2号元素；错误的操作是，让1号元素（待插入元素的前一个元素）指向新的元素(4号元素)，那么就会发现2号元素的地址信息丢失了，也就是发生内存泄漏。
内存泄漏： 其实写的所有程序都占用内存空间，2号元素和3号元素，依然占用着我们的内存空间，但在程序中对这段信息没有办法进行操作。
对于中大型需要长期线上运行的系统，需要对内存泄漏的问题及其关注和避免的。
链表：无头链表
在头部是不存储信息的，所以在链表的头部存储的仅仅是一个指针。
链表：有头链表
在头部存储信息，在链表的头部存储的是一个节点。只不过这个节点有存储数据的区域，但我们不使用这个区域
虚拟头节点： 一般就是有头链表的头节点
代码演示
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
typedef struct Node{
int data;
struct Node *next;
} Node;
Node * getNewNode(int val)
{
Node *p = (Node*)malloc(sizeof(Node));
p->data = val;
p->next = NULL; // 新的节点的下一个指向空
return p;
}
Node *insert(Node *head, int pos, int val)
{
if (pos == 0)
{
Node *node = getNewNode(val); // 先创建新节点
node->next = head; // 让新节点指向原来的头节点
return node; // 直接返回新节点
}
Node *p = head; // p找到待插入位置的前一个元素
for (int i = 1; i < pos; i++) p = p->next; // p走到待插入位置的前一个位置
Node *node = getNewNode(val); // 创建新节点
node->next = p->next; // 先让新节点的next指向待插入位置的节点，即p->next
p->next = node; // 再让p的next指向新节点
// 此时逻辑上已经完成了插入的操作
return head; // 返回原链表头节点
}
void clear(Node *head)
{
if (head == NULL) return;
// 循环遍历链表中每个节点, 当遍历不为空，就一直向后走
for (Node *p = head, *q; p; p = q) // p是当前节点
{
q = p->next; // 先让q指向下一个节点
free(p); // 再销毁当前节点
}
return;
}
void output_linklist(Node *head)
{
// 0 1 2
// 22->33->55
int n = 0;
for (Node *p = head; p; p = p->next) n += 1; // 先求链表的长度n
// 打印第一行序号
for (int i = 0; i < n; i++)
{
printf("%3d", i);
printf(" "); // 对应链表的->两个字符
}
printf("\n");
// 打印第二行链表
for (Node *p = head; p; p = p->next)
{
printf("%3d", p->data);
printf("->");
}
printf("\n\n");
return;
}
int main()
{
srand(time(0));
#define MAX_OP 7
Node *head = NULL;
for (int i = 0; i < MAX_OP; i++)
{
int pos = rand() % (i + 1), val = rand() % 100; // 这里的第一个pos因为是随机数对1取余，永远都是0
printf("insert %d at %d to linklist\n", val, pos);
head = insert(head, pos, val);
output_linklist(head);
}
std::cin.get();
return 0;
}
输出：
链表：花式查找操作的实现
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
#define DL 3
#define STR(n) #n
#define DIGIT_LEN_STR(n) "%" STR(n) "d"
typedef struct Node{
int data;
struct Node *next;
} Node;
Node * getNewNode(int val)
{
Node *p = (Node*)malloc(sizeof(Node));
p->data = val;
p->next = NULL; // 新的节点的下一个指向空
return p;
}
Node *insert(Node *head, int pos, int val)
{
if (pos == 0)
{
Node *node = getNewNode(val); // 先创建新节点
node->next = head; // 让新节点指向原来的头节点
return node; // 直接返回新节点
}
Node *p = head; // p找到待插入位置的前一个元素
for (int i = 1; i < pos; i++) p = p->next; // p走到待插入位置的前一个位置
Node *node = getNewNode(val); // 创建新节点
node->next = p->next; // 先让新节点的next指向待插入位置的节点，即p->next
p->next = node; // 再让p的next指向新节点
// 此时逻辑上已经完成了插入的操作
return head; // 返回原链表头节点
}
void clear(Node *head)
{
if (head == NULL) return;
// 循环遍历链表中每个节点, 当遍历不为空，就一直向后走
for (Node *p = head, *q; p; p = q) // p是当前节点
{
q = p->next; // 先让q指向下一个节点
free(p); // 再销毁当前节点
}
return;
}
void output_linklist(Node *head, int flag = 0)
{
// 0 1 2
// 22->33->55
int n = 0;
for (Node *p = head; p; p = p->next) n += 1; // 先求链表的长度n
// 打印第一行序号
for (int i = 0; i < n; i++)
{
// printf("%3d", i);
printf(DIGIT_LEN_STR(DL), i);
printf(" "); // 对应链表的->两个字符
}
printf("\n");
// 打印第二行链表
for (Node *p = head; p; p = p->next)
{
// printf("%3d", p->data);
printf(DIGIT_LEN_STR(DL), p->data);
printf("->");
}
printf("\n");
if (flag == 0) printf("\n\n");
return;
}
int find(Node *head, int val)
{
// 查找，遍历链表的每个节点
Node *p = head; // 当前节点指针
int n = 0; // 用来记录输出元素个数
while (p)
{
if (p->data == val){
output_linklist(head, 1);
int len = n * (DL + 2); // 空字符个数
for (int i = 0; i < len; i++) printf(" "); // 输出前面的空格
printf("^\n");
for (int i = 0; i < len; i++) printf(" "); // 输出前面的空格
printf("|\n");
return 1;
}
n += 1;
p = p->next;
}
return 0;
}
int main()
{
srand(time(0));
#define MAX_OP 7
Node *head = NULL;
// 测试插入操作
for (int i = 0; i < MAX_OP; i++)
{
int pos = rand() % (i + 1), val = rand() % 100; // 这里的第一个pos因为是随机数对1取余，永远都是0
printf("insert %d at %d to linklist\n", val, pos);
head = insert(head, pos, val);
output_linklist(head);
}
// 测试查找操作
int val;
while (scanf_s("%d", &val)){
if (!find(head, val)) printf("not found\n");
}
std::cin.get();
return 0;
}
输出链表的生成：
输出查找操作
链表：用有头链表改写插入操作
定义一个虚拟头节点，然后定义一个指针p，指向虚拟头节点
让虚拟头节点的下一节点为原来的头指针，此时形成了一个有头链表
然后开始插入操作，一样的，先找到待插入位置的前一个元素位置，这时候因为在0位置前有一个虚拟头节点，所以对于pos=0的情况，就是虚拟头节点本身。
注意：虚拟头节点的下一个节点才是要返回的头节点
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
#define DL 3
#define STR(n) #n
#define DIGIT_LEN_STR(n) "%" STR(n) "d"
typedef struct Node{
int data;
struct Node *next;
} Node;
Node * getNewNode(int val)
{
Node *p = (Node*)malloc(sizeof(Node));
p->data = val;
p->next = NULL; // 新的节点的下一个指向空
return p;
}
// 有头链表的插入操作
Node *insert(Node *head, int pos, int val)
{
Node newhead, *p = &newhead;
newhead.next = head; // 让虚拟头节点的下一节点为head
// 此时已经构造了一个有头链表
for (int i = 0; i < pos; i++) p = p->next; // 先找到待插入位置的前一位
Node *node = getNewNode(val);
node->next = p->next;
p->next = node;
return newhead.next; // 虚拟头节点的下一个节点才是要返回的头节点
}
void clear(Node *head)
{
if (head == NULL) return;
// 循环遍历链表中每个节点, 当遍历不为空，就一直向后走
for (Node *p = head, *q; p; p = q) // p是当前节点
{
q = p->next; // 先让q指向下一个节点
free(p); // 再销毁当前节点
}
return;
}
void output_linklist(Node *head, int flag = 0)
{
// 0 1 2
// 22->33->55
int n = 0;
for (Node *p = head; p; p = p->next) n += 1; // 先求链表的长度n
// 打印第一行序号
for (int i = 0; i < n; i++)
{
// printf("%3d", i);
printf(DIGIT_LEN_STR(DL), i);
printf(" "); // 对应链表的->两个字符
}
printf("\n");
// 打印第二行链表
for (Node *p = head; p; p = p->next)
{
// printf("%3d", p->data);
printf(DIGIT_LEN_STR(DL), p->data);
printf("->");
}
printf("\n");
if (flag == 0) printf("\n\n");
return;
}
int find(Node *head, int val)
{
// 查找，遍历链表的每个节点
Node *p = head; // 当前节点指针
int n = 0; // 用来记录输出元素个数
while (p)
{
if (p->data == val){
output_linklist(head, 1);
int len = n * (DL + 2) + 1; // 空字符个数
for (int i = 0; i < len; i++) printf(" "); // 输出前面的空格
printf("^\n");
for (int i = 0; i < len; i++) printf(" "); // 输出前面的空格
printf("|\n");
return 1;
}
n += 1;
p = p->next;
}
return 0;
}
int main()
{
srand(time(0));
#define MAX_OP 7
Node *head = NULL;
// 测试插入操作
for (int i = 0; i < MAX_OP; i++)
{
int pos = rand() % (i + 1), val = rand() % 100; // 这里的第一个pos因为是随机数对1取余，永远都是0
printf("insert %d at %d to linklist\n", val, pos);
head = insert(head, pos, val);
output_linklist(head);
}
// 测试查找操作
int val;
while (scanf_s("%d", &val)){
if (!find(head, val)) printf("not found\n");
}
std::cin.get();
return 0;
}
链表：循环链表
单向循环链表
单向循环链表：在单向链表的基础上加一个循环结构，循环结构是指最后一个节点指向了第一个节点
注意： 在单向循环链表中的头指针head指向整个链表的最后一个节点
为什么要指向最后一个节点：因为最后一个节点充当着一个实实在在的链表中的节点，也充当着一个虚拟头节点。有了这个虚拟头节点之后，当需要插入节点到链表中时，插入到哪个位置就向后走几步即可
代码
结构定义
与单向链表的节点定义一样
typedef struct Node{
int data;
struct Node *next;
} Node;
构造循环
Node *ConstructLoop(Node *head) // 构造链表循环
{
if (head == NULL) return head;
Node *p = head;
while (p->next) p = p->next; // 找到链表的最后一个节点
p->next = head; //最后的节点的下一个节点指向头节点
head = p; // 头指针指向最后一个节点
return head; // 返回头指针
}
删除循环链表
与单向链表的删除一样
void clear(Node *head) // 删除单向链表
{
if (head == NULL) return;
// 循环遍历链表中每个节点, 当遍历不为空，就一直向后走
for (Node *p = head, *q; p; p = q) // p是当前节点
{
q = p->next; // 先让q指向下一个节点
free(p); // 再销毁当前节点
}
return;
}
单向循环链表：插入
如果头指针head指向的不是链表最后一个节点，而是第一个节点，那么在插入元素到index=0的位置时，是不是要先找到0位置节点的前一个节点，那就是链表的最后一个节点，也就是说，为了在0位置插入一个节点，还要先遍历完链表的全部节点才能进行插入操作，所以将头指针head设置为链表最后一个节点是合理。
插入在index=0位置后，不需要修改head指向的节点，保持指向为最后一个节点即可。
插入到链表的最后一个节点的后面，则需要在插入完成后修改head指向的节点
代码
Node *insertLoop(Node *head, int pos, int val)
{
int n = 1;
Node *q = head->next;
while (q != head) // 记录循环链表的长度
{
n += 1;
q = q->next;
}
Node *p = head; // 当前指针指向头节点，相当于单向链表的虚拟头节点
for (int i = 0; i < pos; i++) p = p->next; // 找到待插入位置的前一位
Node *node = getNewNode(val);
// 插入操作
if (pos < n)
{
node->next = p->next;
p->next = node;
return head; // 如果插入的位置不是在最后一个节点之后，返回原头指针
}
else
{
node->next = p->next;
p->next = node;
head = node; // 否则，头指针指向最后一个节点
return head;
}
}
链表：双向链表
双向链表： 除了有指向下一个节点的变量next指针之外，还有指向上一个节点的变量pre指针
第一个节点的pre指针指向空地址
最后一个节点的next指针指向空地址
代码
结构定义
typedef struct BiNode{
int data;
struct BiNode *next;
struct BiNode *pre;
} BiNode;
构造节点文章来源：https://www.toymoban.com/news/detail-435968.html
BiNode *getNewBiNode(int val)
{
BiNode *p = (BiNode*)malloc(sizeof(BiNode));
p->data = val;
p->next = NULL;
p->pre = NULL;
return p;
}
删除双向链表
与单向链表的删除一样文章来源地址https://www.toymoban.com/news/detail-435968.html
void clear(Node *head) // 删除单向链表
{
if (head == NULL) return;
// 循环遍历链表中每个节点, 当遍历不为空，就一直向后走
for (Node *p = head, *q; p; p = q) // p是当前节点
{
q = p->next; // 先让q指向下一个节点
free(p); // 再销毁当前节点
}
return;
}
到了这里，关于【算法与数据结构】链表的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
