数据结构与算法⑤(第二章OJ题，上)前五道链表面试题

GR鲸鱼

已于 2023-04-22 09:43:03 修改

阅读量262

点赞数 2

分类专栏： ③数据结构与算法（C语言描述）文章标签： c语言开发语言数据结构算法 leetcode Powered by 金山文档

于 2023-02-17 22:18:15 首次发布

本文链接：https://blog.csdn.net/GRrtx/article/details/129073759

版权

③数据结构与算法（C语言描述）专栏收录该内容

17 篇文章 5 订阅

订阅专栏

本文介绍了如何在链表中删除等于特定值的节点，如何反转单链表，找到链表的中间节点，以及如何获取链表的倒数第k个节点。提供了不同时间复杂度的解决方案，包括快慢指针和迭代的方法。此外，还讨论了合并两个有序链表的问题。

摘要由CSDN通过智能技术生成

1. 删除链表中等于val 的所有节点

203. 移除链表元素

难度简单

给你一个链表的头节点 head 和一个整数 val ，

请你删除链表中所有满足 Node.val == val 的节点，并返回新的头节点。

示例 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

输出：[]

提示：

列表中的节点数目在范围 [0, 10^4] 内

1 <= Node.val <= 50

0 <= val <= 50

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeElements(struct ListNode* head, int val) {

}

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeElements(struct ListNode* head, int val) {
    struct ListNode* cur = head;
    struct ListNode* prev = NULL;
    while (cur)
    {
        if (cur->val == val)
        {
            if (cur == head)
            {
                head = cur->next;
                free(cur);
                cur = head;
            }
            else
            {
                prev->next = cur->next;
                free(cur);
                cur = prev->next;
            }
        }
        else
        {
            prev = cur;
            cur = cur->next;
        }
    }
    return head;
}

2. 反转一个单链表

206. 反转链表

难度简单

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

示例 1：

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

输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]

输出：[2,1]

示例 3：

输入：head = []

输出：[]

提示：

链表中节点的数目范围是 [0, 5000]

-5000 <= Node.val <= 5000

进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head) {

}

时间O(N^2)的代码：

（自己第一遍写的笨方法）过了挺高兴，看完别人的思路就...

struct ListNode* reverseList(struct ListNode* head) {
    if (head == NULL)
    {
        return NULL;
    }
    struct ListNode* cur = head;
    while (cur->next)//直接找到最后一个在指回来
    {
        cur = cur->next;
    }
    struct ListNode* newHead = cur;
    while(cur!=head)
    {
        struct ListNode* prev = head;
        while (prev->next != cur)
        {
            prev = prev->next;
        }
        cur->next = prev;
        cur = prev;
    }
    cur->next = NULL;
    return newHead;
}

时间O(N)的代码（三指针）：

struct ListNode* reverseList(struct ListNode* head) {
    if(head==NULL)
    {
       return NULL;
    }
    struct ListNode *n1=NULL,*n2=head,*n3=head->next;
    while(n2)
    {
        n2->next=n1;//翻转
        n1=n2;//迭代往后走
        n2=n3;
        if(n3!=NULL)
        {
            n3=n3->next;
        }
    }
    return n1;
}

简化：

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode *n1=NULL,*n2=head;
    while(n2)
    {
        struct ListNode *n3=n2->next;
        n2->next=n1;//翻转
        n1=n2;//迭代往后走
        n2=n3;
    }
    return n1;
}

时间O(N)的代码（头插）：

其实和上面本源是一样的（上面简化后应该就是这个了），只是名字变了可能更好理解

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* newHead=NULL,*cur=head;
    while(cur)
    {
        struct ListNode* curNext=cur->next;
        cur->next=newHead;//头插
        newHead=cur;//迭代往后走
        cur=curNext;
    }
    return newHead;
}

3.返回链表的中间结点

876. 链表的中间结点

难度简单

给定一个头结点为 head 的非空单链表，返回链表的中间结点。

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

示例 1：

输入：[1,2,3,4,5]

输出：此列表中的结点 3 (序列化形式：[3,4,5])

返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。

注意，我们返回了一个 ListNode 类型的对象 ans，这样：

ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.

示例 2：

输入：[1,2,3,4,5,6]

输出：此列表中的结点 4 (序列化形式：[4,5,6])

由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。

提示：

给定链表的结点数介于 1 和 100 之间。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* middleNode(struct ListNode* head){

}

普通思路的代码：

struct ListNode* middleNode(struct ListNode* head){
    struct ListNode*cur=head;
    int count=0;
    while(cur!=NULL)
    {
        cur=cur->next;
        count++;//计算链表长度
    }
    struct ListNode*middle=head;
    for(int i=0;i<count/2;i++)//如5的话3次，6的话4次
    {
        middle=middle->next;
    }
    return middle;
}

这样的时间复杂度是N+N/2 虽然还是O(N)

但是以后面试可能会要求只能遍历一遍数组呢，这时就要用到快慢指针的思想了

虽然以前有用过，但是变一下就想不到了，看到这个思路又是震惊的一天...

运用快慢指针的代码：

struct ListNode* middleNode(struct ListNode* head) {
    struct ListNode* fast = head , * slow = head;
    while (fast!=NULL&&fast->next!=NULL)
    {
        fast=fast->next->next;//快指针一次走两步
        slow=slow->next;//慢指针一次走一步
    }
    return slow;
}

4. 输出该链表中倒数第k个结点

剑指 Offer 22. 链表中倒数第k个节点

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，

本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。

这个链表的倒数第 3 个节点是值为 4 的节点。

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* getKthFromEnd(struct ListNode* head, int k){

}

（这题没给范围，有点不严谨，但是懂思路就好了）

力扣这题是后更新的，所以测试用例更不严谨

这里说一下，力扣应该是OJ题做的最好的，但是面试那些应该用牛客多一点。

牛客网链接：https://www.nowcoder.com/practice/529d3ae5a407492994ad2a246518148a?tpId=13&&tqId=11167&rp=2&ru=/activity/oj&qru=/ta/coding-interviews/question-ranking

普通思路的代码：

这题和上一题的普通思路一样，相当于遍历两次链表

struct ListNode* getKthFromEnd(struct ListNode* head, int k){
    struct ListNode*cur=head;
    int count=0;
    while(cur!=NULL)
    {
        cur=cur->next;
        count++;//计算链表长度
    }
    struct ListNode*newHead=head;
    for(int i=0;i<count-k;i++)
    {
        newHead=newHead->next;
    }
    return newHead;
}

写完普通思路我想着用快慢指针怎么用，想了几秒就觉得不行就不想了，以为不能用

（不想动太多脑的坏处）看到别人的思路我已经开始咬嘴唇了...

虽然觉得k不一样时，时间一样，但是帅就对了：

运用快慢指针的代码：

struct ListNode* getKthFromEnd(struct ListNode* head, int k){
    struct ListNode* fast = head , * slow = head;
    while(k--)
    {
        if(fast==NULL)
        {
            return NULL;
        }
        fast=fast->next;//快指针先走k步
    }
    while(fast)
    {
        fast=fast->next;
        slow=slow->next;//快慢指针一起走
    }
    return slow;
}

5. 合并两个有序链表为一个新的有序链表

21. 合并两个有序链表

难度简单

将两个升序链表合并为一个新的升序链表并返回。

新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]

输出：[1,1,2,3,4,4]

示例 2：

输入：l1 = [], l2 = []

输出：[]

示例 3：

输入：l1 = [], l2 = [0]

输出：[0]

提示：

两个链表的节点数目范围是 [0, 50]

-100 <= Node.val <= 100

l1 和 l2 均按非递减顺序排列

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){

}

尾插法代码：

 struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
     if (list1 == NULL)
     {
         return list2;
     }
     if (list2 == NULL)
     {
         return list1;
     }
     struct ListNode* cur=NULL;
     if(list1->val <= list2->val)
     {
        cur = list1;
        list1 = list1->next;
     }
     else
     {
        cur = list2;
        list2 = list2->next;
     }
     struct ListNode* new = cur;
     while (list1 && list2)
     {
         if (list1->val <= list2->val)
         {
             cur->next = list1;
             cur = list1;
             list1 = list1->next;
         }
         else
         {
             cur->next = list2;
             cur = list2;
             list2 = list2->next;
         }
     }
     if (list1 == NULL)
     {
         cur->next = list2;
     }
     else
     {
         cur->next = list1;
     }
     return new;
}

尾插法+哨兵位的头节点代码：

哨兵位的头节点就是不存数据的节点

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

本篇完。

后面还有接着这部分的较难的OJ题

GR鲸鱼

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
4
评论
数据结构与算法⑤(第二章OJ题，上)前五道链表面试题

数据结构与算法⑤（第二章OJ题）链表面试题，力扣：203. 移除链表元素，206. 反转链表，876. 链表的中间结点，剑指 Offer 22. 链表中倒数第k个节点，21. 合并两个有序链表
复制链接

扫一扫