一、前言

基于牛客网中的链表在线编程题目，对链表相关的题目进行C语言解析

二、链表反转

题目：

给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

数据范围： 0≤n≤1000

要求：空间复杂度 O(1) ，时间复杂度 O(n) 。

如当输入链表{1,2,3}时，

经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。

以上转换过程如下图所示：

 相关代码：

struct ListNode* ReverseList(struct ListNode* head ) {
     struct ListNode* newcode = NULL,*cur = head;
     while(cur)
     {
         struct ListNode* next=cur->next;
         cur->next=newcode;
         newcode = cur;
         cur=next;
     }
     return newcode;
}

使用三个指针newcode，cur，next来进行迭代地将链表中的节点依次反转，newcode指向已反转的部分链表的头节点，cur指向待反转的节点，next用于保存cur的下一个节点。 

在迭代过程中，先用next对cur的下一个节点进行暂存，防止cur的下一个节点丢失，然后将cur的下一个节点指向newcode，再将newcode指向cur，cur再指向下一个节点next，进行下一个节点的反转。

当迭代完成后，newcode就成了新链表的头节点，将其返回即可得到反转的链表。

三、链表内指定区间反转

题目:

将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)，空间复杂度 O(1)。

例如：

给出的链表为 1→2→3→4→5→NULL, m=2,n=4,

返回 1→4→3→2→5→NULL.

 

数据范围： 链表长度 0

要求：时间复杂度 O(n) ，空间复杂度 O(n)

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

相关代码：

typedef struct TestList
{
	int Date;
	struct TestList* next;
}TestList;
TestList* reverseBetween(TestList* head, int m, int n)
{
	TestList* newcode = (TestList*)malloc(sizeof(TestList));
	int i = 0;
	int c = n - m;
	if (c <= 0 || head == NULL)
	{
		return head;
	}
	newcode->next = head;
	TestList* prev = newcode;
	for (i = 0; i < m - 1; i++)
	{
		prev = prev->next;
	}
	TestList* cur = prev->next;
	TestList* tmp = NULL;
	while (c)
	{
		tmp = cur->next; //对当前进行暂存
		cur->next = tmp->next; //将当前的下一个指向下一个的下一个
		tmp->next = prev->next; //将暂存的放到前一个的下一个上，
		prev->next = tmp;//进行位置转换
		c--;
	}
	TestList* List = (TestList*)malloc(sizeof(TestList));
	List = newcode->next;
	free(newcode);
	return List;
}

step1：我们可以在链表前加一个哨兵位，在最后返回时对其进行释放，因为如果要从链表头的位置开始反转，在多了一个表头的情况下就能保证第一个节点永远不会反转，不会到后面去。

step2：使用两个结构体指针，一个指向当前节点，一个指向前序节点。

step3：依次遍历链表，到第m个的位置。

step4：对于从m到n这些个位置的节点，依次断掉指向后续的指针，反转指针方向。

step5：返回时释放我们添加的哨兵位。

                       

四、合并两个排序的数组

 题目：

输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。

数据范围： 0≤n≤1000，−1000≤节点值≤1000

要求：空间复杂度 O(1)，时间复杂度 O(n)

如输入{1,3,5},{2,4,6}时，合并后的链表为{1,2,3,4,5,6}，所以对应的输出为{1,2,3,4,5,6}，转换过程如下图所示：

           

相关代码： 

TestList* mergeTwoLists(TestList* list1, TestList* list2)
{
	//如果其中一个链表为空，就返回另一个
	if (list1 == NULL)
	{
		return list2;
	}
	if (list2 == NULL)
	{
		return list1;
	}
    
    //创建新链表的头和节点
	TestList* head = NULL, * tail = NULL;
	head = tail = (TestList*)malloc(sizeof(TestList));
    
	while (list1 && list2)
	{
		if (list1->Date < list2->Date)
		{
			head = tail = list1;
			tail = tail->next;
			list1 = list1->next;
		}
		else
		{
			head = tail = list2;
			tail = tail->next;
			list2 = list2->next;
		}
	}
	//如果有一个链表为空，将其连接为新链表的后面
	if (list1)
	{
		tail->next = list1;
	}
	if (list2)
	{
		tail->next = list2;
	}
	TestList* List = head->next;
	free(head);
	return List;
}

因为是两个有序链表，所以将两个链表的第一个值进行比较，如果第一个值中 链表1 < 链表2 说明新链表中的第一个值为链表1中的第一个值，head = tail = list1

将较小值的链表tail指向下一个节点，tail = tail ->next，之后继续进行迭代

进行迭代完成之后，如果两个链表长度不相等，说明有一个链表已经为空，另一个链表的值肯定大于第一个链表，就将其链接到新链表后面

                                                   

五、判断链表的中间节点

题目： 给定一个链表，返回该链表的中间节点，如果中间节点有两个，则返回第二个中间节点

1➡2➡3➡4➡5          中间节点为3

1➡2➡3➡4➡5➡6     中间节点为4

要求只能遍历链表一次

相关代码：

//判断链表的中间节点
TestList* middleNode(TestList* head)
{
	TestList* slow = head, * fast = head;
	while (fast && fast->next)
	{
		slow = slow->next;
		fast = fast->next->next;
	}
	return slow;
}

使用快慢指针的方法进行中间节点的返回。

定义两个指针，一个叫fast，一个叫slow，在进行迭代的过程中，慢指针一次走一步，快指针一次走两步，当快指针走到尾时，慢指针恰好走到中间

当链表长度为奇数时，fast走到链表尾，当链表长度为偶数时，fast走到链表尾的下一个，所以迭代的条件为：当fast 和 fast->next 不为空时，迭代继续。

 六、将链表分割，将小于x的排序到链表前，大于x的排序到链表后

 题目：给出链表 2➡3➡5➡1➡6➡4  给定x=3，将小于x的排序到链表前，大于x的排序到链表后，要求不能改变原链表的数据结构，并返回新链表的头指针

返回的链表应该为：1➡2➡3➡4➡5➡6

相关代码：

//链表分割，将小于x的排序到链表前，大于x排序到链表后
TestList* partition(TestList* head, int x)
{
	TestList* lesshead, * lesstail, * greaterhead, * greatertail;
	//设置哨兵位
	lesshead = lesstail = (TestList*)malloc(sizeof(TestList*));
	lesstail->next = NULL;
	greaterhead = greatertail = (TestList*)malloc(sizeof(TestList*));
	greatertail->next = NULL;
	//防止链表头还要使用
	TestList* cur = head;
	while (cur)
	{
		//小的就放到小链表，大的就放到新链表
		if (cur->Date < x)
		{
			lesstail->next = cur;
			lesstail = cur;
		}
		else
		{
			greatertail->next = cur;
			greatertail = cur;
		}		
		cur = cur->next;
	}		
	lesstail->next = greaterhead->next;
	greatertail->next = NULL;	
	TestList* List = lesshead->next;
	free(lesshead);
	free(greaterhead);
	return List;
}

 创建两个新链表并设置哨兵位和标志位，将原链表的数据与x进行比较，当比x小时，放到lesshead  所在的链表，当比x大时，放到  greaterhead  所在的链表，当迭代完成后，再将greaterhead 链表链接到  lesshead  链表后面去。