【剑指offer&牛客101】中那些高频笔试，面试题——链表篇

于 2022-07-01 01:03:06 发布
阅读量992 收藏 10
点赞数 21
分类专栏： Java刷题笔记 文章标签： 链表 数据结构 笔试 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Biteht/article/details/125269195
版权

文章目录

链表类

牛客101

1. 反转链表

题目链接：反转链表

题目描述：

在这里插入图片描述

解题思路：

在这里插入图片描述

代码实现：

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        // 方法一迭代
        // 设置两个指针 prv 和 cur
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null) {
            ListNode next = cur.next;//保存cur的下一个节点
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
}

2. 链表内指定区间反转

题目链接：链表内指定区间反转

题目描述：

在这里插入图片描述

解题思路：

前一道题，我们知道如何去反转一个链表，这道题，指定区间反转，意思就是 对给出的区间的链表，进行反转，那么，我把这道题进行分解：

  1. 首先找到 m 和 n 的位置
  2. 将 m 和 n 分离出来
  3. 最后在将链表拼接起来即可

代码如下

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param head ListNode类 
     * @param m int整型 
     * @param n int整型 
     * @return ListNode类
     */
    public ListNode reverseBetween (ListNode head, int m, int n) {
        // write code here
        // 设置虚拟节点
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;
        ListNode pre = dummyNode;
        // 让pre 走到 m的前一个节点
        for(int i = 0;i < m-1;i++) {
            pre = pre.next;
        }
        // 找到n节点,让rightNode 走到 n的节点
        ListNode rightNode = pre;
        for(int i = 0;i < n-m+1;i++) {
            rightNode = rightNode.next;
        }
        // 取出出子链
        ListNode leftNode = pre.next;
        ListNode cur = rightNode.next;
        // 截断子链
        pre.next = null;
        rightNode.next = null;
        // 反转子链
        reverseNode(leftNode);
        // 拼接子链
        pre.next = rightNode;
        leftNode.next = cur;
        return dummyNode.next;// 返回头结点
    }
    public void reverseNode(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
    }
}

3. 从尾到头打印链表

题目链接： 从尾到头打印链表

题目描述：

在这里插入图片描述

解题思路：

这道题有两个方法：

  1. 方法一：也是我们最能常想到的，用栈
  2. 方法二：借用力扣大佬一思路：不用栈，不用递归，不额外分配空间

代码如下：

/** 方法一：
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        Stack<Integer> stack = new Stack<>();
        // 用栈来做,先遍历链表，将val放入栈中
        ListNode cur = head;
        while(cur != null) {
            stack.push(cur.val);
            cur = cur.next;
        }
        // 创建个数组，数组大小为栈的大小
        int size = stack.size();
        int[] nums = new int[size];
        // 遍历数组，给数组赋值
        for(int i = 0;i<size;i++) {
            nums[i] = stack.pop();
        }
        return nums;
    }
}


/** 方法二：
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        ListNode cur = head;
        // 先遍历看看到底有多少个节点
        int count = 0;
        while(cur != null) {
            count++;
            cur = cur.next;
        }
        int[] nums = new int[count];
        cur = head;// 这里让cur指向头节点
        // 从后往前打印
        for(int i = count -1;i >=0;i--) {
            nums[i] = cur.val;
            cur = cur.next;
        }
        return nums;

    }
}

4. 复杂链表的复制

题目链接：复杂链表的复制

题目描述：

在这里插入图片描述

解题思路：

遇到题，不要慌，先把题目分析一遍，就是说：复制一个新的链表出来，那么我们需要分析拆解问题：

  1. 新的链表的每个节点的val值不变
  2. 新的链表的next和random指针需要我们去修改
  3. 用什么方法最好？采用哈希，做映射 key-value 对应 原节点-新节点

两个循环，第一个循环建立 key-value 映射关系（原节点val和新节点val）
第二个循环，根据映射关系，修改新节点的next和random指针

代码如下：

// 方法二：
class Solution {
    public Node copyRandomList(Node head) {
        Map<Node,Node> map  = new HashMap<>();
        Node cur = head;//cur 代替 头结点 去遍历
        //1.第一次遍历 将老节点和新节点的映射关系放入map中
        while(cur != null) {
            //复制 节点 为 新节点
            Node node = new Node(cur.val);
            //存储 老节点 和新节点的 映射关系
            map.put(cur,node);
            cur = cur.next;
        }
        //第二次遍历 先让cur 指向头结点
        cur = head;
        //第二次遍历 修改新节点的 next 和 random指向
        while(cur != null) {
            map.get(cur).next = map.get(cur.next);
            map.get(cur).random = map.get(cur.random);
            cur = cur.next;
        }
        //最后返回 新的头节点
        return map.get(head);
        
    }
}

5. 链表中的节点每K个一组翻转

题目链接：链表中的节点每K个一组翻转

题目描述：

在这里插入图片描述

解题思路：

这道题，题目描述的很清楚，思路很简单，但是对于代码上来说，需要一定的要求，这里我借用力扣一大佬的图解，给大家分析。
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

代码如下：


import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param head ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    // 递归法
    public ListNode reverseKGroup (ListNode head, int k) {
        // write code here
        // 先判断递归终止条件
        if(head == null || head.next == null) {
            return head;// 如果没有头节点为空，或者只有一个节点
        }
        ListNode tail = head;
        // 让tail 走 k-1 步
        for(int i = 0;i < k;i ++) {
            // 这里需要注意：如果剩余的数量小于k了，则不需要翻转
            if(tail == null) {
                return head;
            }
            tail = tail.next;
        }
        
        // 翻转钱K个节点 注意这里的范围为：[);
        ListNode newHead = reverse(head,tail);
        // 递归，下一次开始的其实位置是tail
        head.next = reverseKGroup(tail,k);
        return newHead;
    
    }
    
    public ListNode reverse(ListNode head,ListNode tail) {
        // 翻转链表
        ListNode pre = null;
        ListNode next = null;
        while(head != tail) {
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }
        return pre;
    }
}

剑指 offer

6.剑指 Offer 18. 删除链表的节点

题目链接：删除链表的节点

题目描述：

在这里插入图片描述

解题思路：

核心思路：先读懂题意，要让我们删除节点，如何删除节点？首先，找到节点，找到节点之后，改变此节点的前后指向，即可完成删除，下面代码含详细注释

代码实现：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        //删除节点 首先找到节点
        // 1. 先判断头节点，如果头刚好就是，那么返回头结点下一个节点
        if(head.val == val) return head.next;
        // 2. 设置两个指针
        ListNode pre = null;
        ListNode cur = head;
        // 3. 进入循环，先找到 要删除的节点
        // 这里的循环条件，如果 找到了就跳出循环，没找到，当cur遍历到最后的时候，退出循环
        while(cur != null && cur.val != val) {
            pre = cur;
            cur = cur.next;
        }
        // 跳出循环,如果cur不等于空，说明cur.val == val
        if(cur != null) {
            pre.next = cur.next;
        }
        // 最后返回头结点
        return head;
    }
}

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

题目链接：链表中倒数第k个节点

题目描述：

在这里插入图片描述

解题思路：

这道题，我一开始做的时候，我的想法是，反转两次链表，第一次反转链表之后，在去遍历1-k，遍历完成之后，再次反转，但是写了一半，考虑到时间复杂度的问题，没写了哈哈，接下来我们说说这道题的正确的核心思路把。这道题的核心思路如下：

先读懂题意，题目上说，输出链表的倒数第K个节点，那么具体的方法很简单

在这里插入图片描述

这道题，我觉得能做出来，还得是一种经验，刷过这种类似的自然而然就能联想到一些方法。

  • 设置 快慢指针 fast 和 slow
  • fast 先走到 k+1 的位置，slow 从 head 位置开始，fast 和 slow 之间刚好就相差 k
  • 进入循环，fast 和 slow 同时一起走，当 fast == null 的时候，slow 的位置刚好就是 第 k 个节点
  • 最后 返回 slow 节点

代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        // 核心思路：快慢指针（fast slow）先让 fast 走 k+1 步
        // slow 从第一个节点开始
        // 然后同时一起走，当 fast 走完 为 null 时，slow的位置就是
        // 倒数的位置

        // 快慢指针,并初始化
        ListNode fast = head;
        ListNode slow = head;

        // 先让 fast 走 k+1步
        // 注意：循环条件
        while(k > 0 && fast != null){
            fast = fast.next;
            k--;
        }

        // 然后 fast 和 slow 同时一起走
        // 当 fast 为 null 时 跳出循环
        while(fast != null) {
            fast = fast.next;
            slow = slow.next;
        }

        // 此时 头节点 为 slow 返回头节点 slow
            return slow;
    }
}

8.剑指 Offer 25. 合并两个排序的链表

题目链接：合并两个排序的链表

题目描述：

在这里插入图片描述

解题思路：

先说一下我刚做这道题的思路体会，拿到这道题，读了遍题之后，我直接就开淦，想着，这简单嘛，直接 插入 嘛，1后面插1 在插2，在插3，再插4… ，这样子会出现个问题，先不说对不对，设置的引用就特别的多，贼蛋疼，后来还是选择老老实实的，重新做一遍，下面是核心思路：

  • 设置傀儡节点 和 引用 cur ，代替傀儡节点进行连接操作
  • 判断 两个链表的 val 值大小,来进行连接操作
  • 最后返回 头节点，dum.next

注意 里面隐含了一个细节，A 链 和 B 链 可能长度不等，当跳出循环的时候，说明 其中一个链表 已经为空了，那么我们需要判断一下 到底是哪一个 为空 ，并且 将不为空的剩余部分 连接在 cur 的后面

下面是具体代码，含注释，包懂！

代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

        // 核心思想，设置傀儡节点
        // 判断 l1.val 和 l2.val 的大小,在将他们连接在一起

        // 设置的傀儡节点
        ListNode dum = new ListNode(-1);
        // 用cur代替傀儡节点，进行连接
        ListNode cur = dum;
        // 进入循环，注意循环条件 当一个为null 的时候，跳出循环
        while(l1 != null && l2 != null) {
            // 进行判断
            if(l1.val <= l2.val) {
                cur.next = l1;
                l1 = l1.next;
            }else {
                cur.next = l2;
                l2 = l2.next;
            }
            cur = cur.next;
        }
        // 跳出循环,合并剩余的尾部：剩余尾部，那个剩下了，就将那个接在 cur.next 后面
        cur.next = l1 != null ? l1 : l2;
        return dum.next;
    }
}

9.剑指 Offer 52. 两个链表的第一个公共节点

题目链接：两个链表的第一个公共节点

题目描述：

在这里插入图片描述

解题思路：

具体思路，在代码里面，我注释写的很详细，包懂

代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 两个方法，如果去暴力遍历的话  复杂度就 大于 0（N）了
        // 肯定是不行
        // 核心思路：我们分析这个图，首先 A 的长度 和 B 的长度是不相同的！
        // 但是 A + B 的总长度 是相同的，我们利用这个性质（可以画个图），当 A 走完 走到 c3
        // A 就从 B 的头节点开始
        // 同理 当 B 走完 走到 c3 ，B 从 A 的头节点开始,因为 A 和 B 的长度不同，但是 A 和 B 的总数相同的性质
        // 在第二次遍历的时候 会相遇（画图好理解，这里我画图水平有限就不画了
        


        // 定义两个引用
        ListNode a = headA;
        ListNode b = headB;
        // 注意循环条件,当 a ！= b 的时候，循环的走下去
        while(a != b) {
            // 如果 A 走到 null 这个位置，就从 B 的头节点开始
            // 如果没有就继续走下去
            if(a == null) {
                a = headB;
            }else {
                a = a.next;
            }
            // 同理，如果 B 走到 null 这个位置，就从 A 的头节点开始
            if(b == null) {
                b = headA;
            }else {
                b = b.next;
            }
        }
        // 跳出循环，说明 a == b 了，返回 a 和 b 任意都可
        return a;   
    }
}

🎉✨总结

链表题，是笔试面试中的高频考点，难度不大，但是需要我们去熟练掌握，题型很多，有些题没做过，想真的很难想出来，所以一句话，熟能生巧，见多识广，多刷题多总结才是提升算法的做好途径

“种一颗树最好的是十年前,其次就是现在”

所以,

“让我们一起努力吧,去奔赴更高更远的山海”

如果有错误❌,欢迎指正哟😋

🎉如果觉得收获满满,可以动动小手,点点赞👍,支持一下哟🎉

以梦为马，不负韶华

在这里插入图片描述

偷偷敲代码的青花瓷
关注
  • 21
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 21
    评论
专栏目录
链表笔试面试题（一）
xiongluo0628的博客
08-02 1296
本博客内容 1、单链表的结构 2、求链表的长度 3、单链表反转 4、单链表倒数第k个节点 5、查找链表的中间节点 6、从尾到头打印链表 7、已知2个单链表有序，把它们合并为一个有序链表 8、判断一个单链表是否有环 9、判断2个链表是否相交 10、求2个单链表相交的第1个节点 1、单链表的结构 struct ListNode { int m_nValue...
剑指offer（java版）----牛客.zip
09-20
《剑指Offer》是经典的一本面试准备书籍，主要针对计算机科学与技术领域的求职者，尤其是对Java开发者具有很高的参考价值。这本书源自牛客网，一个专注于编程技能测试和在线编程竞赛的平台，旨在帮助求职者提升编程...
【面试必看】链表的常见笔试题
Money、坤的博客
06-26 409
1. 合并链表链接：https://leetcode.cn/problems/merge-two-sorted-lists 2. 反转链表 3. 链表中倒数第k个节点 4. 删除链表的倒数第N个节点 5. 相交链表 6. 环形链表 7. 回文链表 8. 反转指定区间上范围的链表
牛客编程题--必刷101之字符串(高效刷题，举一反三)
qq_36317312的博客
06-30 1591
文章目录1、 字符串变形 1、 字符串变形 题目描述：对于一个长度为 n 字符串，我们需要对它做一些变形。 首先这个字符串中包含着一些空格，就像"Hello World"一样，然后我们要做的是把这个字符串中由空格隔开的单词反序，同时反转每个字符的大小写。 比如"Hello World"变形后就变成了"wORLD hELLO"。 输入：“This is a sample”,16 返回值： “SAMPLE A IS tHIS” ......
力扣链表笔试题--看这一篇就够了
Word码鸭的博客
12-29 801
83.删除升序链表中重复的元素，使每个元素只出现一次 public class LeetCode83 {//存在一个按升序排列的链表，给你这个链表的头节点 head ， // 请你删除所有重复的元素，使每个元素 只出现一次 。 public ListNode deleteDuplicates(ListNode head) { ListNode dummyHead=new ListNode(101); dummyHead.next=head;
单链表常见面试题
Dxx_xx4的博客
07-09 5528
数据结构和算法，是我们程序设计最重要的两大元素，可以说，我们的编程，都是在选择和设计合适的数据结构来存放数据，然后再用合适的算法来处理这些数据。 在面试中，最经常被提及的就是链表，因为它简单，但又因为需要对指针进行操作，凡是涉及到指针的，都需要我们具有良好的编程基础才能确保代码没有任何错误。 链表是一种动态的数据结构，因为在创建链表时，我们不需要知道链表的长...
offer_牛客_剑指offer_剑指Offer算法题编程代码解析汇总_
10-02
其中的剑指Offer部分，源于《剑指Offer：名企面试官精讲典型编程题》这本书，涵盖了数据结构、算法、设计模式等多个方面，旨在帮助程序员提高在面试中遇到的算法题的解决能力。 二、剑指Offer算法题解析 这个...
牛客网校招面试题库测试篇.pdf
06-27
本题库均来自海量真实校招面试题目大数据进行的整理，后续也会不断更新，如需下载，也可点击进行下载
牛客面试算法top101（JAVA和C++）
04-30
牛客面试算法top101（JAVA和C++）
【应聘笔记系列】三个常见链表笔试题
寸先生的AI道路
06-27 3021
链表是经常应聘时经常考察的重要数据结构，今日复习了一下并就几个几个代表性问题上机调试了一下程序。1、  单链表问题Ø         单链表的反转：这个问题似乎在面试和笔试中特别受宠，屡屡出现.解决方法：用三个指针。代码如下：node *reverse(node *head){ node *p1,p2,p3; if(head==NULL || head->next==N
链表-面试高频考点解析
AaronYu的博客
02-19 167
链表是一种基本数据结构，因为链表使用过程中指来指去的指针让大家抓狂，以至于大家面试前总是要特意看下链表相关知识。今天，我来带大家学习「链表」（Linked list) 这个数据结构。 我们总是拿链表和数组来进行比较，不同于数组需要连续内存，链表并不需要一块连续的内存，它通过「指针」将一组零散的内存块串联起来使用。 了解了链表的官方定义后，我们来看看链表有那些结构。链表包括单链表、循...
剑指Offer：重建二叉树
zhangkai's blog
10-29 77
点击上方“码侬进阶之路”，选择“星标”公众号资源干货，与你分享题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 例如...
[剑指offer]求和1+2+3+....n
Irean_Lau的专栏
04-07 826
/* 46:> 求和1+2+3+....n 不能使用for while if else switch case 三目运算符 */ class Sum { public: Sum() { ++N; sum += N; } static void set() { N = 0; su
剑指offer 链表题最佳解汇总 Python
wstcjf的博客
09-22 769
面试题5: 从尾到头打印链表 输入一个链表，从尾到头打印链表每个节点的值。 思路： 方法一： class Solution:     # 返回从尾部到头部的列表值序列，例如[1,2,3]     def printListFromTailToHead(self, listNode):         l = []         # 直接遍历一遍链表保存结果到list中，再返回倒序
【剑指offer】链表题目集合
littlemichelle
09-09 175
从尾到头打印链表 class Solution: # 返回从尾部到头部的列表值序列，例如[1,2,3] def printListFromTailToHead(self, listNode): rs = [] if not ListNode:return rs while listNode: rs.appe...
一刷剑指Offer：链表专题
你今天真好看呀
04-20 284
文章目录剑指Offer_6：从尾到头打印链表剑指offer_6（LeetCode）：从尾到头打印链表剑指Offer_53：链表中环的入口节点剑指Offer_18：删除链表中重复的节点剑指Offer_22：链表中倒数第K个节点剑指Offer_24：反转链表剑指Offer_25：合并两个排序的链表剑指Offer_36：二叉搜索树与双向链表剑指Offer_52：两个链表的第一个公共节点 剑指Offer_...
【算法】剑指offer-链表
weixin_41441345的博客
07-30 146
链表 剑指 Offer 52. 两个链表的第一个公共节点 利用set集合不重复的特性，先后将两个链表的值存入set中，后者若add失败。则返回此公共节点 public ListNode getIntersectionNode(ListNode headA, ListNode headB) { Set<ListNode> set = new HashSet<>(); ListNode res = null; while(hea

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

偷偷敲代码的青花瓷

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值