
struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* cur = NULL;
    struct ListNode* prev = head;
 
    while (prev)
    {
        struct ListNode* tmp = prev->next;
        prev->next = cur;
        cur = prev;
        prev = tmp;
    }
    return cur;
}

我们先创建一个空指针用于接收反转后的头结点，也就是原链表的第一个节点；然后使用头插法，在使用头插法的时候需要先创建一个临时指针变量来保留原来链表的第二个结点的地址，也就是tmp指针。紧接着我们就可以使用头插的方法来依次将原链表的结点，链入反转后的链表。

下图就死第一步的反转操作和最后一步的反转操作。

方法二：将链表的指向反转

为了要反向指针，我们需要有三个指针变量来记录要反转的节点的地址；要反转的结点的下一个结点的地址；以及反转后链接的原先之前的地址。

这种方法相当于尾插法，将n1指向NULL，然后一次向后尾插。我们要注意的就是尾插到最后n3，需要注意越界问题；尾插结束的条件；和头指针为NULL时的情况。


struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* n1 = NULL;
    struct ListNode* n2 = head;
    if (head == NULL)
        return NULL;
    struct ListNode* n3 = n2->next;
    while (n2)
    {
        n2->next = n1;
        n1 = n2;
        n2 = n3;
        if (n3)
            n3 = n3->next;
    }
    return n1;
 
}

203. 移除链表元素https://leetcode.cn/problems/remove-linked-list-elements/

2、给你一个链表的头节点 `head` 和一个整数 `val` ，请你删除链表中所有满足 `Node.val == val` 的节点，并返回新的头节点。

方法一：使用不带哨兵位的尾插


struct ListNode* removeElements(struct ListNode* head, int val) {
	struct ListNode* newnode = NULL;
	struct ListNode* tail = newnode;	
	struct ListNode* cur = head;
 
	while (cur)
	{
		if (cur->val != val)
		{
			if (tail == NULL)
			{
				newnode = tail = cur;
			}
			else
			{
				tail->next = cur;
				tail = tail->next;
			}
			cur = cur->next;
		}
		else
		{
			struct ListNode* tmp = cur->next;
			free(cur);
			cur = tmp;
		}
	}
	if (tail)
		tail->next = NULL;
	return newnode;
}

方法二：带着哨兵位


//尾插法 - 带哨兵位
struct ListNode* removeElements(struct ListNode* head, int val) {
	struct ListNode* guard = (struct ListNode*)malloc(sizeof(struct ListNode));
	guard->next = NULL;
	//struct ListNode* cur = head;
	struct ListNode* tmp = guard;
	while (head)
	{
		if (head->val != val)
		{
			struct ListNode* cur = head->next;
			tmp->next = head;
			head = cur;
			tmp = tmp->next;
		}
		else
		{
			struct ListNode* cur = head->next;
			free(head);
			head = cur;
		}
	}
	if (tmp)
		tmp->next = NULL;
	struct ListNode* ret = guard->next;
	free(guard);
	return ret;
}

21. 合并两个有序链表https://leetcode.cn/problems/merge-two-sorted-lists/

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

这一题与上一题使用的方法一致都是尾插的两种方法

方法一：使用不带哨兵位的尾插


struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    struct ListNode* head1 = list1;
    struct ListNode* head2 = list2;
    struct ListNode* newnode = NULL;
    struct ListNode* tail = newnode;
 
    if (head1 == NULL)
        return head2;
    if (head2 == NULL)
        return head1; 
    while (head1 && head2)
    {
        if (head1->val < head2->val)
        {
            if (tail == NULL)
            {
                newnode = tail = head1;
                head1 = head1->next;
            }
            else
            {
                struct ListNode* tmp = head1->next;
                tail->next = head1;
                tail = tail->next;
                head1 = tmp;
            }
        }
        else
        {
            if (tail == NULL)
            {
                newnode = tail = head2;
                head2 = head2->next;
            }
            else
            {
                struct ListNode* tmp = head2->next;
                tail->next = head2;
                tail = tail->next;
                head2 = tmp;
            }
        }
    }
    if (head1 == NULL)
    tail->next = head2;
    else
    tail->next = head1;
 
    return newnode;
}

方法二：带哨兵位的尾插法


struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    struct ListNode* head1 = list1;
    struct ListNode* head2 = list2;
    struct ListNode* guard = (struct ListNode*)malloc(sizeof(struct ListNode));
    guard->next = NULL;
    struct ListNode* cur = guard;
    if (list1 == NULL)
    {
        return list2; 
    }
        if (list2 == NULL)
    {
        return list1;
    }
    while ((head1) && (head2))
    {
        if (head1->val <= head2->val)
        {
            struct ListNode* tmp = head1->next;
            cur->next = head1;
            cur = cur->next;
            head1 = tmp;
        }
        else
        {
            struct ListNode* tmp = head2->next;
            cur->next = head2;
            cur = cur->next;
            head2 = tmp;
        }
    }
    if (head1 == NULL)
        cur->next = head2;
    else
        cur->next = head1;
        cur = guard->next;
        free(guard);
        return cur;
}

876. 链表的中间结点https://leetcode.cn/problems/middle-of-the-linked-list/

4、给定一个头结点为 `head` 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

方法一：找到结点的个数分奇偶进行寻找


struct ListNode* middleNode(struct ListNode* head){
    int point = 1;
    struct ListNode* cur = head;
    //找得到该链表一共有多少个节点
    while (cur)
    {
        cur = cur->next;
        point++;
    }
    cur = head;
    //辨别出是奇数个节点还是偶数个节点
    //奇数个节点
    if (point % 2 == 0)
    {
        point = point / 2 ;
        while (point > 1)
        {
            cur = cur->next;
            point--;
        }
    }
    //偶数个节点
    else
    {
        point = point / 2 ;
        while (point >= 1)
        {
            cur = cur->next;
            point--;
        }
    }
    return cur;
}

方法二：要求只遍历一遍（快慢指针）

当快指针走两步，慢指针走一步那么在遍历结束的时候,正好慢指针就会走完一半。

这样只需要遍历一遍。


struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* slow = head;
    struct ListNode* fast = head;
 
    while (fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

在链表的个数为奇数个时，如果我们需要的值是前面的而不是后面的，我们就可以定义一个变量来记录slow之前的位置。


struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* slow = head;
    struct ListNode* fast = head;
    struct ListNode* prev = NULL;
 
    while (fast->next && fast)
    {
        prev = slow;
        slow = slow->next;
        fast = fast->next->next;
    }
    return prev;
}

链表中倒数第k个结点_牛客题霸_牛客网

5、链表中倒数第k个节点

方法一：遍历计数


struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    int point = 0;
    struct ListNode* cur = pListHead;
    struct ListNode* head = pListHead;
 
    while (cur)
    {
        cur = cur->next;
        point++;
    }
    
    if (point<k)
    {
        return NULL;
    }
    else
    {
        int pos = point - k + 1;
        while (pos > 1)
        {
            head = head->next;
            pos--;
        }
        return head;
    }

方法二：快慢指针


struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    int point = 0;
    struct ListNode* fast = pListHead;
    struct ListNode* slow = pListHead;
 
    //fast先走K步
    while (k--)//k--共执行k次；--k执行k-1次
    {
        if (fast == NULL)//链表可能没有空步长
 
        {
            return NULL;
        }
        else
        {
            fast = fast->next;
        }
    }
    
    while (fast)
    {
        fast = fast->next;
        slow = slow->next;
    }
    return slow;
}

链表分割_牛客题霸_牛客网

6、现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。

方法一：分成两个链表，再将两个链表链接起来（带哨兵位的头结点）


class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) {
        struct ListNode* head1 = (struct ListNode*)malloc(sizeof(struct ListNode));
        head1->next = NULL;
        struct ListNode* head2 = (struct ListNode*)malloc(sizeof(struct ListNode));
        head2->next = NULL;
 
        struct ListNode*cur = pHead;
        struct ListNode*tail1 = head1;
        struct ListNode*tail2 = head2;
 
        while (cur)
        {
            if (cur->val < x)
            {
                tail1->next = cur;
                tail1 = tail1->next;
            }
            else
            {
                tail2->next = cur;
                tail2 = tail2->next;
            }
            cur = cur->next;
        }
            tail1->next = head2->next;
            tail2->next = NULL;
            pHead = head1->next;
            free(head1);
            free(head2);
            return pHead;
 
    }
};

链表的回文结构_牛客题霸_牛客网【牛客题霸】收集各企业高频校招笔面试题目，配有官方题解，在线进行百度阿里腾讯网易等互联网名企笔试面试模拟考试练习,和牛人一起讨论经典试题,全面提升你的技术能力https://www.nowcoder.com/practice/d281619e4b3e4a60a2cc66ea32855bfa

7、对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。

这道题比较的有难度，下面的这种方法运用了上面的反转链表与快慢指针求解链表的中间元素的思想。


struct ListNode* middleNode(struct ListNode* head)
{
    struct ListNode* slow = head;
    struct ListNode* fast = head;
 
    while (fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next;
    }
    return slow;
}
 
struct ListNode* reverseList(struct ListNode* head)
{
    struct ListNode* rehead = NULL;
    struct ListNode* cur = head;
 
    while (cur)
    {
        struct ListNode* next = cur->next;
        cur->next = rehead;
        rehead = cur;
        cur = next;
    }
    return rehead;    
 
}
 
class PalindromeList {
public:
    bool chkPalindrome(ListNode* A) {
 
    //使用快慢指针找到链表中的中间节点
    struct ListNode* rehead = middleNode(A);
 
    //将找到的中间节点后面的链表反转
    struct ListNode* cmp = reverseList(rehead);
 
    //将原链表反转前面的数值与反转后的数值进行比较
    while (A && cmp)
    {
        if (A->val != cmp->val)
            return false;
        A = A->next;
        cmp = cmp->next;
    }
    return true;
 
    }
};

160. 相交链表https://leetcode.cn/problems/intersection-of-two-linked-lists/

8、给你两个单链表的头节点 `headA` 和 `headB` ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 `null` 。

如果给我们的两个链表是等长的，那么我们就可以进行一一的比较然后得到最后的相交的结点，但是现在A与B不是等长的，因此需要想办法让其变为等长的链表。可以先统计两个链表的长度，然后让较长的那个的头结点先往后移，直至链表等长。在求链表长度的时候我们可以得到两链表是否有交点这个结论，如果两个链表时有交点的，那么在最后的尾结点一定是地址相同的。


struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode* cur1 = headA;
    struct ListNode* cur2 = headB;
    
    int countA = 0;
    int countB = 0;
 
    while (cur1->next != NULL)
    {
        countA++;
        cur1 = cur1->next;
    }
    while (cur2->next != NULL)
    {
        countB++;
        cur2 = cur2->next;
    }
 
    //走完两个链表之后如果有相交的结点，地址一定会相同
    if (cur1 != cur2)
        return NULL;
 
    //计算两个链表之间的个数差
    int ret = abs(countA - countB);
 
    //使用假设的方法先假设A链表比较小，然后在进行修正
    struct ListNode* shortList = headA;
    struct ListNode* longList = headB;
    if (countA > countB)
    {
        shortList = headB;
        longList = headA;
    }
    while (ret--)
    {
        longList = longList->next;
    }
    while (longList != shortList)
    {
        longList = longList->next;
        shortList = shortList->next;
    }
    return shortList;
}

141. 环形链表https://leetcode.cn/problems/linked-list-cycle/

9、给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递。仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。否则，返回 false 。

我们可以将上图进行化简得到如下的简图。定义两个指针slow与fast，slow每次移动一位，fast每次移动两位，假设链表有环，当slow运动到环开始的结点时，它和fast的距离假设为N，而fast每次比slow运动的快一个节点，那么最后fast一定会追上slow。


bool hasCycle(struct ListNode *head) {
    struct ListNode* slow = head;
    struct ListNode* fast = head;
    
    //分奇偶结点个数来区分链表
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if (fast == slow)
            return true;
    }
    return false;
}

142. 环形链表 IIhttps://leetcode.cn/problems/linked-list-cycle-ii/

10、给定一个链表的头节点 `head` ，返回链表开始入环的第一个节点。如果链表无环，则返回 `null`。

方法一：简单算法


struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode* slow = head;
    struct ListNode* fast = head;
    
    //分奇偶结点个数来区分链表
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if (fast == slow)
        {
            struct ListNode* meet = fast;
            while (head != meet)
            {
                head = head->next;
                meet = meet->next;
            }
            return meet;
        }
    }
    return NULL;
}

结论：当head结点与meet结点同时运动时，若两者相等那么相等的位置就是环形的开始。

我们假设头结点到环形开始的结点长度为L，slow与fast地址相同的结点到环形开始的结点距离为N，整个环形的长度为C。

由于fast的速度是slow的两倍，那么当slow进入环中后在一圈以内的距离内fast一定会追上slow，因为假设slow运动了C/2的长度，fast就会走C的长度，而整个环形的长度只有C。

当fast结点追上slow结点时，slow结点一共走了L+N的长度，fast一共走了L+ k * C+N。

slow经过距离的两倍与fast经过的距离应该是相等的：(L+ k * C+N) = (L + N) * 2

0 = k * C - L - N，在经过化简得L = (k-1)*C + C - N，这样正好是meet结点到环形起始位置的长度，因此的证。

方法二：使用第8题与相交结点有关的知识


struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode* cur1 = headA;
    struct ListNode* cur2 = headB;
    
    int countA = 0;
    int countB = 0;
 
    while (cur1->next != NULL)
    {
        countA++;
        cur1 = cur1->next;
    }
    while (cur2->next != NULL)
    {
        countB++;
        cur2 = cur2->next;
    }
 
    //走完两个链表之后如果有相交的结点，地址一定会相同
    if (cur1 != cur2)
        return NULL;
 
    //计算两个链表之间的个数差
    int ret = abs(countA - countB);
 
    //使用假设的方法先假设A链表比较小，然后在进行修正
    struct ListNode* shortList = headA;
    struct ListNode* longList = headB;
    if (countA > countB)
    {
        shortList = headB;
        longList = headA;
    }
    while (ret--)
    {
        longList = longList->next;
    }
    while (longList != shortList)
    {
        longList = longList->next;
        shortList = shortList->next;
    }
    return shortList;
}
 
 
struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode* slow = head;
    struct ListNode* fast = head;
    
    //分奇偶结点个数来区分链表
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if (fast == slow)
        {
            struct ListNode* meet = fast;
            struct ListNode* otherhead = meet->next;
            meet->next = NULL;
            return getIntersectionNode(head,otherhead);
        }
    }
    return NULL;
}

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/528584

数据结构——Leetcode&牛客网（链表）_现有一链表的头指针listnode *phead

单链表

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

方法一：使用头插的方法

方法二 ：将链表的指向反转

2、给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

方法一：使用不带哨兵位的尾插

方法二：带着哨兵位

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

方法一：使用不带哨兵位的尾插

方法二：带哨兵位的尾插法

4、 给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

方法一：找到结点的个数分奇偶进行寻找

方法二：要求只遍历一遍（快慢指针）

链表中倒数第k个结点_牛客题霸_牛客网

5、链表中倒数第k个节点

方法一：遍历计数

方法二：快慢指针

6、现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。

方法一：分成两个链表，再将两个链表链接起来（带哨兵位的头结点）

7、对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。

8、给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

9、 给你一个链表的头节点 head ，判断链表中是否有环。

10、给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

方法一：简单算法

方法二：使用第8题与相交结点有关的知识

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

方法二：将链表的指向反转

2、给你一个链表的头节点 `head` 和一个整数 `val` ，请你删除链表中所有满足 `Node.val == val` 的节点，并返回新的头节点。

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

4、给定一个头结点为 `head` 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

8、给你两个单链表的头节点 `headA` 和 `headB` ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 `null` 。

9、给你一个链表的头节点 head ，判断链表中是否有环。

10、给定一个链表的头节点 `head` ，返回链表开始入环的第一个节点。如果链表无环，则返回 `null`。