1.链表反转
typedef struct ListNode listnode;
struct ListNode* reverseList(struct ListNode* head)
{
if(head == NULL)
{
return head;
}
listnode* p1 = NULL;
listnode* p2 = head;
listnode* p3 = head->next;
while(p2)
{
p2->next = p1;
p1 = p2;
p2 = p3;
if(p3)
p3 = p3->next;
}
return p1;
}
核心思想：定义三个指针，第一个只想为空，第二个指向头节点，第三个指向头节点的下一个节点。之后让头节点的next指针反转180°，三个指针依次往后走。循环这一过程，直到p2为空。
要注意的是p3为空时不能解引用，否则编译器会报错。
2.移除链表元素
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* removeElements(struct ListNode* head, int val)
{
struct ListNode* phead = NULL;
struct ListNode* ptail = NULL;
struct ListNode* pcur = head;
while(pcur)
{
if(pcur->val != val)
{
if(phead == NULL)
{
phead = ptail = pcur;
}
else
{
ptail->next = pcur;
ptail = ptail->next;
}
}
pcur = pcur->next;
}
if(ptail)
ptail->next = NULL;
return phead;
}
核心思想： 遍历链表，把pcur->val = val的节点跳过。最后尾节点的next指针指向空。
3.链表的中间节点
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
typedef struct ListNode listnode;
struct ListNode* middleNode(struct ListNode* head)
{
listnode* man = head;
listnode* kuai = head;
while(kuai && kuai->next)
{
man = man->next;
kuai = kuai->next->next;
}
return man;
}
核心思想：快慢指针
快指针每次移动两个单位，慢指针每次移动一个单位。这样，快指针指向空或者快指针的next指针指向空时。满指针指向的节点即为中间节点。
4.合并两个有序链表
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
ListNode* l1 = list1;
ListNode* l2 = list2;
if(l1 == NULL)
return l2;
if(l2 == NULL)
return l1;
ListNode* newhead = NULL;
ListNode* newtail = NULL;
while(l1 && l2)
{
if(l1->val > l2->val)
{
if(newhead == NULL)
{
newhead = newtail = l2;
}
else
{
newtail->next = l2;
newtail = newtail->next;
}
l2 = l2->next;
}
else
{
if(newhead == NULL)
{
newhead = newtail = l1;
}
else
{
newtail->next = l1;
newtail = newtail->next;
}
l1 = l1->next;
}
}
if(l1)
newtail->next = l1;
if(l2)
newtail->next = l2;
return newhead;
}
核心思想： 遍历两个链表，比较两链表节点的val值大小，将尾节点的next指针指向较小的节点，直到l1或者l2有一个为空时跳出循环。最后将没有走到空的链表尾插进来。
5.环形链表的约瑟夫问题
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
struct ListNode
{
int val;
struct ListNode* next;
};
typedef struct ListNode ListNode;
ListNode* ByNode(int x)
{
ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
if (newnode == NULL)
{
perror("malloc");
exit(1);
}
newnode->val = x;
newnode->next = NULL;
return newnode;
}
ListNode* List(int n)
{
ListNode* phead = ByNode(1);
ListNode* ptail = phead;
for (int i = 2; i <= n; i++)
{
ptail->next = ByNode(i);
ptail = ptail->next;
}
ptail->next = phead;
return ptail;
}
int ysf(int m, int n)
{
ListNode* perv = List(n);
ListNode* pcur = perv->next;
int count = 1;
while (pcur->next != pcur)
{
if (count != m)
{
perv = pcur;
pcur = pcur->next;
count++;
}
else
{
perv->next = pcur->next;
free(pcur);
pcur = perv->next;
count = 1;
}
}
return pcur->val;
}
int main()
{
int m, n;
scanf("%d%d", &n, &m);
int ret = ysf(m, n);
printf("%d", ret);
return 0;
}
主要思路：首先需要创建一个环形链表，然会创建一个指针pcur指向头节点，用pcur来遍历链表，如果count的值等于m，就需要把该节点释放，释放之前要将perv的next指针指向pcur的下一个节点。随后pcur向后移动，count重新置1。如果count的值不等于m，则不需要释放节点，只需把perv和pcur向后移动即可。同时count++。