写在开头
学完链表，我们就要适当做一些题目来巩固知识，下面的一些精选题难度适中，很适合初学者练手。
做题之前我们来了解一点概念，就是链表调用传参时，我们什么时候使用一级指针，什么时候使用二级指针？
作用：
使用一级指针时，传递的是链表中的一个结点的地址，可以修改该节点的内容，但不能更改链表的结构；
使用二级指针时，传递的是链表的地址，可以修改链表的结构，例如插入或删除结点。
typedef struct Node
{
int data;
struct Node* next;
}Node,*LinkList;
Node* head_1;//p是节点
LinkList head_2;//head是头指针
Node* temp1=head;
LinkList* temp2=head;
/*
这样看来，head_1和head_2都为一级指针，指向头结点；
temp1是一级指针，是head的一份拷贝，对指针temp1修改对head无影响
temp2是二级指针，存放head的地址，对指针temp2的修改，可以通过head的地址影响到head;
*/我们有如下总结：
二级指针和一级指针的使用要分情况，一级指针可以用二级指针代替，若要对head的指向做出修改，必须使用二级指针
当然用二级指针也可以实现一级指针的功能（也就是说传一级指针的函数都可以用二级指针代替，但是有一定的风险，毕竟二级指针可以对链表头节点进行直接修改）
而力扣中的题目解答只要求写一个接口函数，一般不允许修改原链表，所以使用一级指针即可
写在中间
203. 移除链表元素 - 力扣（LeetCode）
用意：旨在帮助大家复习链表的删除操作
题意：删除链表中等于给定值 val 的所有节点。
示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：
输入：head = [], val = 1
输出：[]
示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]
法一：附设头结点
struct ListNode* removeElements(struct ListNode* head, int val)
{
//创建头结点
struct ListNode *p;
p = (struct ListNode *)malloc(sizeof(struct ListNode));
p->next = head;
struct ListNode *q = p;
while(q->next != NULL)
{
if (q->next->val == val)
{
struct ListNode *temp = q->next;
q->next = q->next->next;
free(temp);
}
else
{
q = q->next;
}
}
head = p->next;
free(p);
return head;
}
/*你看题中附带的图可知,题目事先并没有设置头结点,所以head这里指的是第一个结点
有个很棘手的事情是，没有附设头结点，为了和习惯相同，我们就自己附设一个头结点
1.先创建一个p，放在头结点之前，设置一个q指向头结点p
2. 如果第一个结点就为空，那么直接返回head
如果不为空，那么就判断是否相等
相等，删除结点，使q指向下一个结点，注意此时head所指向的空间被释放了，结尾就不能return head了
如果不相等，q指向下一个结点
3.当然这只是前几步，我们要做的就是不断的重复操作，遍历到最后一个结点，此时p->next为空
4.还记得2中相等的情况吗！head所指向的空间被释放了，需要重新给head赋值
*/法二：不附设头结点
struct ListNode* removeElements(struct ListNode* head, int val){
struct ListNode* temp;
// 当头结点存在并且头结点的值等于val时
while(head && head->val == val) {
temp = head;
// 将新的头结点设置为head->next并删除原来的头结点
head = head->next;
free(temp);
}
struct ListNode *p = head;
while(p && (temp = p->next))
{
if(temp->val == val)
{
// 将cur->next设置为cur->next->next并删除cur->next
p->next = temp->next;
free(temp);
}
// 若cur->next不等于val，则将cur后移一位
else
p = p->next;
}
return head;
}
/*如果不附设头结点的情况的话,第一个就删除的话，容易丢失后面的数据
1.我们优先处理这种情况，第一个就相同的话，用临时变量记录，再head=head->next,之后释放head
2. 如果第一个结点就为空，就返回head
如果不为空，那么就从第二个结点开始判断是否相等
相等，p的指针域指向第三个结点，释放第二个结点
不相等，就让p指向下一个结点
3.之后不断重复第二步，直到最后一个结点
*/707. 设计链表 - 力扣（LeetCode）
用意：旨在帮助大家复习链表的增删改查操作
在链表类中实现这些功能：
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链3表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
做这道题之前，强烈要求大家去官网看清题目，0 <= index, val <= 1000，index是从0开始的，链表的第1个元素对应的index是0，可以结合下面的调用来理解
MyLinkedList linkedList = new MyLinkedList();//创建链表
linkedList.addAtHead(1); //链表变为0bj-> 1
linkedList.addAtTail(3); //链表变为obj-> 1-> 3
linkedList.addAtIndex(1,2); //链表变为obj-> 1-> 2-> 3
linkedList.get(1); //返回2
linkedList.deleteAtIndex(1); //现在链表是obj-> 1-> 3
linkedList.get(1); //返回3单链表
//注意本题index是从0开始计数的
typedef struct Node
{
int val;
struct Node* next;
}MyLinkedList;
//链表的初始化
MyLinkedList* myLinkedListCreate()
{
MyLinkedList* obj = (MyLinkedList*)malloc(sizeof(MyLinkedList));
obj->next = NULL;
return obj;
}
void CreateListHead(MyLinkedList* L, int n)
{
//声明一个指针p和一个计数器i
MyLinkedList* p;
int i, k = 0;
//先建立一个带头结点的单链表,头结点指向NULL
L = (MyLinkedList*)malloc(sizeof(MyLinkedList));
L->next = NULL;
for (i = 0; i < n; i++)
{
scanf("%d", &k);
p = (MyLinkedList*)malloc(sizeof(MyLinkedList));
p->val = k;
//插到头结点与新结点之间的表头
p->next = L->next;
L->next = p;
}
}
//查找
int myLinkedListGet(MyLinkedList* obj, int index)
{
MyLinkedList* p = obj->next;
int j = 1;
while (p && j < index + 1)
{
p = p->next;
j++;
}
if (!p || j > index+1)
return -1;
//此时p指向第index个元素
return p->val;
}
//头插
void myLinkedListAddAtHead(MyLinkedList* obj, int val)
{
MyLinkedList* p = (MyLinkedList*)malloc(sizeof(MyLinkedList));
p->next = obj->next;
obj->next = p;
//赋值
p->val = val;
}
//尾插
void myLinkedListAddAtTail(MyLinkedList* obj, int val)
{
MyLinkedList* q = (MyLinkedList*)malloc(sizeof(MyLinkedList));
MyLinkedList* p = obj;
while (p->next)
{
p = p->next;
}
q->next = NULL;
q->val = val;
p->next = q;
}
void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val)
{
MyLinkedList* p = obj;
int j = 1;
while (p && j < index + 1)
{
p=p->next;
j++;
}
if (!p || j > index+1)
{
return;
}
MyLinkedList* q = (MyLinkedList*)malloc(sizeof(MyLinkedList));
q->next = p->next;
p->next = q;
q->val = val;
}
void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index)
{
int j = 1;
MyLinkedList* p = obj;
MyLinkedList* q;
while (p->next && j < index + 1)
{
p = p->next;
j++;
}
if (!(p->next) || j > index + 1)
{
return;
}
q = p->next;
p->next = q->next;
free(q);
}
void myLinkedListFree(MyLinkedList* obj)
{
MyLinkedList* p, * q;
p = obj->next;
while (p)
{
q = p->next;
free(p);
p = q;
}
}
/*
//如果要调试，可以写出来main函数和一个链表打印函数
//打印链表元素
void PrintLinkList(MyLinkedList* obj, char* s)
{
MyLinkedList* p;
p = obj->next;
if (p == NULL)
{
printf("ERROR");
return 0;
}
printf("%s", s);
while (p != NULL)
{
printf("%d -", p->val);
p = p->next;
}
printf("\n");
return 1;
}
int main()
{
MyLinkedList* L=myLinkedListCreate();;
myLinkedListAddAtHead(L, 1);
myLinkedListAddAtTail(L, 3);
PrintLinkList(L, (char*)"链表为：");
myLinkedListAddAtIndex(L,1,2);
PrintLinkList(L, (char*)"链表为：");
int ret = myLinkedListGet(L, 1);
printf("查找元素：%d \n", ret);
myLinkedListGet(L, 1);
myLinkedListDeleteAtIndex(L, 1);
PrintLinkList(L, (char*)"链表为：");
ret=myLinkedListGet(L, 1);
printf("查找元素：%d \n", ret);
return 0;
}
*/206. 反转链表 - 力扣（LeetCode）
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]//指针法：
struct ListNode* reverseList(struct ListNode* head)
{
struct ListNode* p=NULL;
struct ListNode* q=head;
struct ListNode* temp;
while(q)
{
temp=q->next;
q->next=p;
p=q;
q=temp;
}
return p;
}
//递归法
struct ListNode* reverse(struct ListNode* p, struct ListNode* q)
{
if(!q)
return p;
struct ListNode* temp = q->next;
q->next = p;
return reverse(q, temp);
}
struct ListNode* reverseList(struct ListNode* head)
{
//p赋空，q赋head
return reverse(NULL, head);
}24. 两两交换链表中的节点 - 力扣（LeetCode）
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
输入：head = [1,2,3,4]
输出：[2,1,4,3]
输入：head = []
输出：[]
输入：head = [1]
输出：[1]
//画个图解释一切
struct ListNode* swapPairs(struct ListNode* head)
{
struct ListNode *p=(struct ListNode*)malloc(sizeof(struct ListNode));
p->next=head;
struct ListNode*left,*right;
left=p;
right=head;
//应对，空结点，单结点，双结点
while( right && right->next)
{
left->next=right->next;
right->next=right->next->next;
left->next->next=right;
left=right;
right=right->next;
}
return p->next;
}19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例1
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]示例 2：
输入：head = [1], n = 1
输出：[]struct ListNode* removeNthFromEnd(struct ListNode* head, int n)
{
//p是虚拟头结点
struct ListNode *p=(struct ListNode*)malloc(sizeof(struct ListNode));
p->next=head;
struct ListNode *temp=head;//身兼两职
struct ListNode *q=p;
//得到链表长度
int i=0;
while(temp)
{
i++;
temp=temp->next;
}
//找到要删除的结点的前一个结点
int j=1;
while(p&&j<i-n+1)
{
p=p->next;
j++;
}
if(!p||j>i)
{
return head;
}
//一顿操作
temp=p->next;
p->next=temp->next;
free(temp);
return q->next;
}面试题 02.07. 链表相交 - 力扣（LeetCode）
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
此方法虽然简单，但时间复杂度O(m*n)，特别是没有交集的时候，时间复杂度大
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB)
{
struct ListNode* p=headA;
struct ListNode* q=headB;
while(p!=q)
{
if(p==NULL)
{
p=headA;
}
else
{
p=p->next;
}
if(q==NULL)
{
q=headB;
}
else
{
q=q->next;
}
}
return p;
}//调换一下顺序就能实现O(m+n)的时间复杂度
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB)
{
struct ListNode* p=headA;
struct ListNode* q=headB;
while(p!=q)
{
if(p==NULL)
{
p=headB;
}
else
{
p=p->next;
}
if(q==NULL)
{
q=headA;
}
else
{
q=q->next;
}
}
return p;
}142. 环形链表 II - 力扣（LeetCode）
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表
struct ListNode *detectCycle(struct ListNode *head)
{
struct ListNode *fast=head;
struct ListNode *slow=head;
while(fast&&fast->next)
{
//慢指针一次走一个，快指针一次走两个
slow=slow->next;
fast=fast->next->next;
//快慢指针相遇证明有环
if(slow==fast)
{
//数学知识，详看力扣最高阅读量的那个解析
struct ListNode *index1=fast;
struct ListNode *index2=head;
while(index1!=index2)
{
index1=index1->next;
index2=index2->next;
}
return index1;//p和q相同
}
}
return NULL;
}写在最后
总结一下，这些题十分经典，多看看其他人的解法，选择最适合自己的解法,上面题的解析，我已经用和前文相似的代码风格进行解答。
👍🏻 点赞，你的认可是我创作的动力！
⭐ 收藏，你的青睐是我努力的方向！
✏️ 评论，你的意见是我进步的财富！
