链表--经典题

题目一：移除链表元素

示例 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 {
	int val;
	struct ListNode* next;
	
};
typedef struct ListNode ListNode;
ListNode* removeElements(ListNode* head, int val)
{
	ListNode* newhead = NULL;//定义新节点的头节点
	ListNode* newtail = NULL;//定义新节点的尾节点
	ListNode* pcur = head;
	while (pcur)//遍历整个链表
	{
		if (pcur->val != val)
		{
			if (pcur == NULL)
			{
				return head;//如果原链表为空的话直接返回
			}
			else
			{
				newtail->next = pcur;
				newtail = newtail->next;
			}
		}
		pcur = pcur->next;
	}
	if (newtail != NULL)
	{
		newtail->next = NULL;//将新链表尾节点指向空，不然会报错
	}
	return newhead;
}

这个题主要是将指点节点删除我们有两种思路,我采用的是思路2，本题需要特别注意的是当新链表尾插完成之后要将尾节点进行制空，不然程序会报错。

题目二：反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]

本题我们还是先画图来进行分析在进行代码的实现。

//将链表进行反置
struct ListNode {
	int val;
	struct ListNode* next;
	
};

typedef struct ListNode ListNode;
ListNode* reverseList(ListNode* head)
{
	//首先定义三个指针
	ListNode* n1 = NULL;
	ListNode* n2 = head;
	ListNode* n3 = n2->next;
	//要先判断链表是否为空，如果为空的话直接返回
	if (head == NULL)
	{
		return head;
	}

	while (n2 != NULL)
	{
		n1 = n2->next;
		n1 = n2;
		n2 = n3;
		if(n3!=NULL)
			n3 = n3->next;//这里要考虑当n3=NULL指针时n3->next就是错误代码程序会报错
	}
	return n1;//最后n1就是反转后链表的头节点直接返回n1就是反转后的链表
}

本题的解题思路我们可以通过画图进行求解，画图我们可以发现我们只需想办法将链表的指向进行反转，我们就可以通过这个思路进行敲代码进行实现。

题目三：链表的中间节点

给你单链表的头结点 head ，请你找出并返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

示例 1：
输入：head = [1,2,3,4,5]
输出：[3,4,5]
解释：链表只有一个中间结点，值为 3 。
示例 2：
输入：head = [1,2,3,4,5,6]
输出：[4,5,6]
解释：该链表有两个中间结点，值分别为 3 和 4 ，返回第二个结点。

本题要我们求链表的中间节点有两种情况，就是链表为节点个数为奇数和偶数两种情况，那我们怎么解决这个题呢？还是按照先画图在进行代码实现的方法。

struct ListNode {
	int val;
	struct ListNode* next;
	
};
typedef struct ListNode ListNode;
ListNode* middleNode(ListNode* head)
{
	ListNode* show = head;
	ListNode* fast = head;
	while (fast&&fast->next)
	{
		show = show->next;
		fast = fast->next->next;
	}
	return show;
}

本题当我们画图想出了快慢指针的方法是我们就可以很轻松的解决这道题。

题目四：合并两个有序链表

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：
输入：l1 = [], l2 = []
输出：[]
示例 3：
输入：l1 = [], l2 = [0]
输出：[0]

本题要求我们将两个链表进行升序合并，同样我们解决本题同样需要我们画图理清思路之后再来进行代码实现。

struct ListNode {
	int val;
	struct ListNode* next;
};
typedef struct ListNode* ListNode;
ListNode* mergeTwoLists(ListNode* list1,ListNode* list2) {
	//首先进行判空操作
	if (list1 == NULL)
	{
		return list2;
	}
	if (list2 == NULL)
	{
		return list1;
	}
	
	
	ListNode* l1 = list1;
	ListNode* l2 = list2;

	ListNode* newhead = NULL;
	ListNode* newtail = NULL;
	while (l1 && l2)
	{
		if(l1->val>l2->val)
		{ 
			//尾插l2
			if (newhead == NULL)
			{
				newhead = newtail = l2;
			}
			else
			{
				newtail->next = l2;
				newtail = newtail->next;
			}
			l2 = l2->next;
		}
		else
		{
			//尾插l1
			if (newhead == NULL)
			{
				newhead = newtail = l1;
			}
			else
			{
				newtail->next = l1;
				newtail = newtail->next;
			}
			l1 = l1->next;
		}
	}
	if (l2)
	{
		newtail->next = l2;
	}
	if (l1)
	{
		newtail->next = l1;
	}
	return newhead;
}

本题我们可以通过比较两个原链表将较小的那一个节点尾插到新链表中。

题目五：分割链表

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有小于 x 的节点都出现在 大于或等于 x 的节点之前。

你不需要保留每个分区中各节点的初始相对位置。

示例 1：
输入：head = [1,4,3,2,5,2], x = 3
输出：[1,2,2,4,3,5]
示例 2：
输入：head = [2,1], x = 2
输出：[1,t

本题要求我们分割链表将大于x的节点放在后面将小于x的链表放在前面，我们先画图理清思路在进行代码实现。

struct ListNode {
	int val;
	struct ListNode* next;
};
typedef struct ListNode ListNode;
struct ListNode* partition(struct ListNode* head, int x) {
    if (head == NULL)
    {
        return head;
    }
    ListNode* lesshead, * lesstail;
    ListNode* greaterhead, * greatertail;
    //创建新的大小链表
    lesshead = lesstail = (ListNode*)malloc(sizeof(ListNode));
    greaterhead = greatertail = (ListNode*)malloc(sizeof(ListNode));
    ListNode* pcur = head;
    while (pcur)
    {
        if (pcur->val < x)
        {
            lesstail->next = pcur;
            lesstail = lesstail->next;
        }
        else
        {
            greatertail->next = pcur;
            greatertail = greatertail->next;
        }
        pcur = pcur->next;
    }
    lesstail->next = greaterhead->next;//将大小链表进行首尾相连
    greatertail->next = NULL;//如果不加这一行程序将会报错
    ListNode* ret = lesshead->next;
    free(lesshead);
    free(greaterhead);
    lesshead = greaterhead = NULL;
    return ret;
}

题目六：环形链表的约瑟夫问题

描述

编号为 1 到 n 的 n 个人围成一圈。从编号为 1 的人开始报数，报到 m 的人离开。

下一个人继续从 1 开始报数。

n-1 轮结束以后，只剩下一个人，问最后留下的这个人编号是多少？

数据范围： 1≤n,m≤100001≤n,m≤10000

进阶：空间复杂度 O(1)，时间复杂度 O(n)

示例1

输入：
5,2     
返回值：
3    
说明：
开始5个人 1，2，3，4，5 ，从1开始报数，1->1，2->2编号为2的人离开
1，3，4，5，从3开始报数，3->1，4->2编号为4的人离开
1，3，5，从5开始报数，5->1，1->2编号为1的人离开
3，5，从3开始报数，3->1，5->2编号为5的人离开
最后留下人的编号是3      
示例2

输入：
1,1
返回值：
1

本题我们一样要先进行画图分析之后才能求解。

typedef struct ListNode ListNode;
 ListNode* buyNode(int x)
 {
    ListNode* node=(ListNode*)malloc(sizeof(ListNode));
    if(node==NULL)
    {
        exit(1);
    }
    node->val=x;
    node->next=NULL;
    return node;
 }
 ListNode* creatCircle(int n)
 {
    ListNode* phead=buyNode(1);
    ListNode* ptail=phead;
    for(int i=2;i<=n;i++)
    {
        ptail->next=buyNode(i);
        ptail=ptail->next;
    }
    ptail->next=phead;
    return ptail;
 }
int ysf(int n, int m ) {
    ListNode* prev=creatCircle(n);
    ListNode* pcur=prev->next;
    int count=1;
    while(pcur->next!=pcur)
    {
        if(count==m)
        {
            prev->next=pcur->next;
            free(pcur);
            pcur=prev->next;
            count=1;
        }
        else {
        {
            prev=pcur;
            pcur=pcur->next;
            count++;
        }
        }
    }
    return pcur->val;
}