链表内指定区间反转 C语言解析

一、前言

以问题深入解析：

将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)，空间复杂度 O(1)。
例如：
给出的链表为 1→2→3→4→5→NULL, m=2,n=4,
返回 1→4→3→2→5→NULL.
 

数据范围： 链表长度 0<size≤1000，0<m≤n≤size，链表中每个节点的值足 |val| ≤ 1000

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

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

二、解法 

        这一问题的核心部分，我们要先找到了第m个位置才能开始反转链表，而反转地部分就是从第m个位置到第n个位置，那我们就需要知道链表整体是如何反转的：

    struct ListNode* newcode=NULL;
    while(cur)
    {
        //将下一个位置指向进行暂存
        struct ListNode* next=cur->next;
        //当前的next指向newcode前一个新的开头
        cur->next=newcode;
        //前一个开头更新为当前
        newcode = cur;
        //当前更新为刚刚记录的后一个
        cur=next;
    }

知道了链表整体是如何反转的之后，我们就可以开始将链表指定区间进行反转

具体做法：

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

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

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

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

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

图解：

三、相关代码

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;
}

当进行两次位置转化之后，就能将链表 1→2→3→4→5→NULL 转化为 1→4→3→2→5→NULL