十道经典的链表OJ题目

最新推荐文章于 2024-10-10 09:51:07 发布

全貌

最新推荐文章于 2024-10-10 09:51:07 发布

阅读量1.1k

点赞数 18

文章标签：链表数据结构

本文链接：https://blog.csdn.net/qq_64105689/article/details/142150194

版权

1. 删除链表中等于给定值 val 的所有结点。

2. 反转一个单链表。

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

4. 输入一个链表，输出该链表中倒数第k个结点。

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

6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前。

7. 链表的回文结构。

8. 输入两个链表，找出它们的第一个公共结点。

9. 给定一个链表，判断链表中是否有环。

10. 给定一个链表，返回链表开始入环的第一个结点。如果链表无环，则返回 NULL

11. 给定一个链表，每个结点包含一个额外增加的随机指针，该指针可以指向链表中的任何结点或空结点。要求返回这个链表的深度拷贝。

1. 删除链表中等于给定值 val 的所有结点。

203. 移除链表元素 - 力扣（LeetCode）

1.判断链表是否为空

2.找到新链表的头节点若有头节点则初始化没有则为空

3.遍历链表保留前结点当前结点为val时则前结点的next等于当前结点的next 删除当前结点

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

2. 反转一个单链表。

206. 反转链表 - 力扣（LeetCode）

1.判空操作

2.遍历链表用cur表示当前结点 prev表示前结点 next表示下一个结点

prev初始化为NULL 因为prev就是逆置之后的最后一个结点指向的NULL

遍历开始 :

保留当前结点的next

将当前结点的next指向前结点

将前结点改为当前结点

当前结点改为后结点

保证:

prev的值应为当前结点的前一个结点即prev的值应随着cur的改变而改变

保存当前结点的next 以便链表能完整遍历

具体过程的图片

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

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

876. 链表的中间结点 - 力扣（LeetCode）

快慢指针

fast走两步 slow走一步 fast走完链表的时候 slow刚好就是链表的中间结点

链表元素是偶数 fast走到NULL slow就是第二个中间结点

链表元素个数是奇数 fast走到最后一个结点 slow就是中间结点

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

4. 输入一个链表，输出该链表中倒数第k个结点。

面试题 02.02. 返回倒数第 k 个节点 - 力扣（LeetCode）

快慢指针,让快指针先走k步, 然后再同时走,这样快指针走到NULL slow就是倒数第k个

int kthToLast(struct ListNode* head, int k){
    struct ListNode* fast = head;
    struct ListNode* slow = head;
    while(k--)
    {
        fast = fast->next;
    }
    while(fast)
    {
        fast = fast->next;
        slow = slow->next;
    }
    return slow->val;
}

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

1.找到新链表的头节点

2.用双指针遍历两个链表按照有序插入若有一个链表为空,则直接在tmp尾插另一个链表的剩余节点

21. 合并两个有序链表 - 力扣（LeetCode）

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    if(list1 == NULL)
    {
        return list2;
    }
    else if(list2 == NULL)
    {
        return list1;
    }
    struct ListNode* newList = list1;
    struct ListNode* list1Cur = list1->next;
    struct ListNode* list2Cur = list2;
    struct ListNode* newListCur;

    if(list1->val > list2->val)
    {
        newList = list2;
        list1Cur = list1;
        list2Cur = list2Cur->next;
    }
    newListCur = newList;
    while(list1Cur && list2Cur)
    {
        
        if(list1Cur->val < list2Cur->val)
        {
            newListCur->next = list1Cur;
            newListCur = newListCur->next;
            list1Cur = list1Cur->next;
        }
        else
        {
            newListCur->next = list2Cur;
            newListCur = newListCur->next;
            list2Cur = list2Cur->next;
        }
    }
    if(!list1Cur)
    {
        newListCur->next = list2Cur;
    }
    else if(!list2Cur)
    {
        newListCur->next = list1Cur;
    }

    return newList;

}

6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前。

思路:

创建两个哨兵位结点分别存放小于x的元素结点和大于等于x的结点

两个指针指向两个链表的当前位置

遍历数组小于x的尾插进小于x的新链表大于的也插入

将大于x的元素的链表的当前结点指针置为NULL 防止链表带环

再将小于x的元素的链表的当前结点指针指向存放大于x的元素的链表的哨兵位的下一个结点

最后返回存放小于x的链表的哨兵位结点的下一个结点

链表分割_牛客题霸_牛客网 (nowcoder.com)

class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) {
        // write code here
        struct ListNode* LittleList = (struct ListNode*)malloc(sizeof(struct ListNode));
        struct ListNode* BigList = (struct ListNode*)malloc(sizeof(struct ListNode));
        struct ListNode* cur1 = LittleList;
        struct ListNode* cur2 = BigList;
        while(pHead)
        {
            if(pHead->val < x)
            {
                cur1->next = pHead;
                cur1 = cur1->next;
            }
            else
            {
                cur2->next = pHead;
                cur2 = cur2->next;
            }
            pHead = pHead->next;
        }
        cur2->next = NULL;
        cur1->next = BigList->next;
        return LittleList->next;
    }
};

7. 链表的回文结构。

链表的回文结构_牛客题霸_牛客网 (nowcoder.com)

1.找链表的中间节点

2.从中间节点开始反转链表

3.双指针遍历只要有一方指针指向的值为NULL则结束若指针指向的值不同直接返回false

class PalindromeList {
public:
    struct ListNode* reverseList(struct ListNode* head) 
    {
        struct ListNode* end1 = NULL;
        struct ListNode* end2 = head;
        if(head == NULL || head->next== NULL)
        {
            return head;
        }

        while(end2)
        {
            struct ListNode* end2_next = end2->next;
            end2->next = end1;
            end1 = end2;
            end2 = end2_next;
        }
        return end1;

    }
    struct ListNode* middleNode(struct ListNode* head) {
        struct ListNode* fast = head;
        struct ListNode* slow = head;
        while(fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
    bool chkPalindrome(ListNode* A) {
        // write code here
        struct ListNode* mid = reverseList(middleNode(A));
        
       struct ListNode* end1 = A;
       struct ListNode* end2 = mid;
       while(end1 && end2)
       {
            if(end1->val != end2->val)
            {
                return false;
            }
            end1 = end1->next;
            end2 = end2->next;
       }
        return true;
    }
};

8. 输入两个链表，找出它们的第一个公共结点。

160. 相交链表 - 力扣（LeetCode）

1.遍历一遍两个链表根据最后一个结点判断是否相交计数器记录节点个数

2.快慢指针遍历 (找链表谁是快指针指的谁是慢指针指的)

3.快指针先走差距步判断两个指针地址是否相同相同返回相交地址

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    //1.判断是否相交
    struct ListNode * curA = headA;
    struct ListNode * curB = headB;
    int countA = 0;
    int countB = 0;
    while(curA->next)
    {
        curA = curA->next;
        countA++;
    }
    while(curB->next)
    {
        curB = curB->next;
        countB++;
    }
    if(curA != curB)
    {
        return NULL;
    }
    curA = headA;
    curB = headB;
    int gap = abs(countA-countB);
    while(gap--)
    {
        if(countA > countB)
        {
            curA = curA->next;
        }
        else
        {
            curB = curB->next;
        }
    }
    while(curA && curB)
    {
        if(curA == curB)
        {
            return curA;
        }
        curA = curA->next;
        curB = curB->next;
    }
    return NULL;

}

9. 给定一个链表，判断链表中是否有环。

141. 环形链表 - 力扣（LeetCode）

快慢指针 slow一次走1步 fast一次走2步如果有环它们会在环内相遇

slow走一步 fast走两步的情况:

slow进环 fast开始追击它们的距离持续缩短1

设它们的的距离为R

R-1

R-2

......

它们会在R为0时相遇

slow走一步, fast走三步的情况

slow进环 fast开始追击它们的距离持续缩短2

设它们的的距离为R

偶数的情况奇数的情况

R R

R-2 R-2

R-4 R-4

...... ......

2 1

0 -1

当R为偶数的时候 fast直接追上slow了

当R为奇数时 fast开始重新一轮的追击

这时它们的距离是C-1

当C为奇数

fast直接追上了

当C为偶数

fast就距离还是-1 就永远追不上

也就是说只有当R为奇数且C为偶数的情况下才永远追不上

slow走的距离是:L

fast走的距离是:L+X*C+N

3L = L+X*C+N

2L = X*C+N

2L = (X+1)*C-R

偶数 = (x+1)*偶数 +奇数不成立所以一定能追上

bool hasCycle(struct ListNode *head) {
    struct ListNode * fast = head;
    struct ListNode * slow = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast)
        {
            return true;
        }
    }
    return false;
}

10. 给定一个链表，返回链表开始入环的第一个结点。如果链表无环，则返回 NULL

142. 环形链表 II - 力扣（LeetCode）

slow走一步fast走两步

设slow和fast相遇的位置是meet

slow走的距离：L+N

fast走的距离：L+X*C+N

2(L+N) = L+X*C+N

L+N=X*C

L = X*C-N

L=(X-1)*C-C+R

slow从head开始出发 fast从meet开始走

它俩走的路程的结束位置就是入环时的位置

struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode * slow = head;
    struct ListNode * fast = head;
    struct ListNode * meet = head;
    struct ListNode * newhead = head;


    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast)
        {
            meet = slow;
            break;
        }
    }
    if(fast == NULL || fast->next == NULL)
    {
        return NULL;
    }
    slow = meet;
    fast = newhead;
    while(slow != fast)
    {
        slow = slow->next;
        fast = fast->next;
    }
    return slow;
}