牛客-链表

已于 2024-04-09 23:46:46 修改
阅读量309 收藏 2
点赞数 3
文章标签： 算法 数据结构 链表
于 2024-04-08 22:32:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaqaz/article/details/137524055
版权

牛客算法刷题

文章目录

前言

一、链表

1.反转链表

描述：
给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。
代码如下（示例）：

方法一：
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    public ListNode ReverseList (ListNode head) {
        // write code here
        ListNode pre =  null;
        ListNode temp = null;
        while(head != null){
            temp = head.next;
            head.next = pre;
            pre = head;
            head = temp;
        }

        return pre;
    }

2.链表内指定区间反转

描述：将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度O(n)，空间复杂度O(1)。
代码如下（示例）：

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 dummy = new ListNode(0);
        dummy.next = head;
        ListNode pre = dummy;
        for(int i = 1; i <m; i++){
            pre = pre.next;
        }

        ListNode cur = pre.next;
        ListNode temp;
        for(int i = m; i < n; i ++){
            temp = cur.next;
            cur.next = temp.next;
            temp.next = pre.next;
            pre.next = temp;
        }
        return dummy.next;
    }

3.合并两个排序的链表

描述：输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。
代码如下（示例）：

方法一：
public class Solution {
    /**
     * 一般解法
     *
     * 
     * @param pHead1 ListNode类 
     * @param pHead2 ListNode类 
     * @return ListNode类
     */
    public ListNode Merge (ListNode pHead1, ListNode pHead2) {
        // write code here
        if(pHead1 ==null){
            return pHead2;
        }
        if(pHead2 == null){
            return pHead1;
        }
        ListNode dummy = new ListNode(0);
        ListNode list = dummy;
        while(pHead1 != null && pHead2 != null){
            if(pHead1.val >= pHead2.val){
                list.next = pHead2;
                pHead2 = pHead2.next;
            }else if(pHead1.val < pHead2.val){
                list.next = pHead1;
                pHead1 = pHead1.next;
            }
            list = list.next;
        }
        if(pHead1 == null){
            list.next = pHead2;
        }
        if(pHead2 == null){
            list.next = pHead1;
        }
        return dummy.next;

    }
方法二：
public class Solution {
    /**
     * 递归法
     *
     * 
     * @param pHead1 ListNode类 
     * @param pHead2 ListNode类 
     * @return ListNode类
     */
    public ListNode Merge (ListNode pHead1, ListNode pHead2) {
        // write code here
        if(pHead1 ==null){
            return pHead2;
        }
        if(pHead2 == null){
            return pHead1;
        }
        ListNode list = null;
        if(pHead1.val >= pHead2.val){
                list = pHead2;
                list.next = Merge(pHead1,pHead2.next);
        }else if(pHead1.val < pHead2.val){
                list = pHead1;
                list.next = Merge(pHead1.next,pHead2);
        }
        return list;
    }

4.判断链表中是否有环

描述：判断给定的链表中是否有环。如果有环则返回true，否则返回false。
代码如下（示例）：

public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null){
            return false;
        }
        ListNode fast = head;
        ListNode slow = head;
        while(slow.next != null && fast.next != null && fast.next.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast== slow){
                return true;
            }
        }
        return false;
    }

4.链表中环的入口结点

描述：给一个长度为n链表，若其中包含环，请找出该链表的环的入口结点，否则，返回null。
代码如下（示例）：

方法一：
public class Solution {
    public ListNode EntryNodeOfLoop(ListNode pHead) {
        if(pHead == null){
            return null;
        }
        ListNode fast = pHead;
        ListNode slow = pHead;
        while(fast.next != null && fast.next.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                slow = pHead;
                while(slow != fast){
                    slow = slow.next;
                    fast = fast.next;
        }
        return slow;
            }
        }
        return null;
    }
方法二：
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead) {
        // ArrayList<ListNode> listNodes = new ArrayList<>();
        // HashMap<ListNode,Boolean> Map = new HashMap<>();
         HashSet<ListNode> set = new HashSet<>();
         while(pHead != null){
            if(set.contains(pHead)){
                return pHead;
            }
            set.add(pHead);
            pHead = pHead.next;
         }
         return null;
    }

5.链表中倒数最后k个结点

描述：输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。
如果该链表长度小于k，请返回一个长度为 0 的链表。
代码如下（示例）：

方法一：
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    public ListNode FindKthToTail (ListNode pHead, int k) {
        // write code here
        if(pHead == null){
            return null;
        }
        ListNode fast = pHead;
        while(fast != null && k > 0 ){
            fast = fast.next;
            k = k-1;
        }
        if(k > 0){
            return null;
        }
        ListNode slow = pHead;
        while(fast != null){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
方法二：
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    public ListNode FindKthToTail (ListNode pHead, int k) {
        // write code here
        if(pHead == null){
            return null;
        }
        ListNode fast = pHead;
        int i = 0;
        while(fast != null){
            fast = fast.next;
            i = i+1;
        }
        if(i-k < 0){
            return null;
        }
        ListNode slow = pHead;
        for(int j = 0; j < i-k; j++){
            slow = slow.next;
        }
        return slow;
    }

6.两个链表的第一个公共结点

描述：输入两个无环的单向链表，找出它们的第一个公共结点，如果没有公共节点则返回空。
例如，输入{1,2,3},{4,5},{6,7}时，两个无环的单向链表的结构如下图所示：可以看到它们的第一个公共结点的结点值为6，所以返回结点值为6的结点。
在这里插入图片描述

代码如下（示例）：
使用两个指针N1,N2，一个从链表1的头节点开始遍历，我们记为N1，一个从链表2的头节点开始遍历，我们记为N2。
让N1和N2一起遍历，当N1先走完链表1的尽头（为null）的时候，则从链表2的头节点继续遍历，同样，如果N2先走完了链表2的尽头，则从链表1的头节点继续遍历，也就是说，N1和N2都会遍历链表1和链表2。
因为两个指针，同样的速度，走完同样长度（链表1+链表2），不管两条链表有无相同节点，都能够到达同时到达终点。
在这里插入图片描述

public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        if(pHead1 == null || pHead2 == null){
            return null;
        }
        ListNode p1 = pHead1;
        ListNode p2 = pHead2;
        while(p1 != p2){
            p1 = (p1 == null ? pHead2 : p1.next);
            p2 = (p2 == null ? pHead1 : p2.next);
        }
        return p1;
    }

7.链表相加(二)

描述：假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。给定两个这种链表，请生成代表两个整数相加值的结果链表。
例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。
在这里插入图片描述
代码如下（示例）：

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head1 ListNode类 
     * @param head2 ListNode类 
     * @return ListNode类
     */
    public ListNode addInList (ListNode head1, ListNode head2) {
        // write code here
        ListNode list1 = getReturnList(head1);
        ListNode list2 = getReturnList(head2);
        int n = 0;
        ListNode result = new ListNode(-1);
        ListNode pre = result;
        while(list1 != null || list2 != null || n != 0){
            if(list1 != null){
                n = n + list1.val;
                list1 = list1.next; 
            }
            if(list2 != null){
                n = n + list2.val;
                list2 = list2.next;
            }
            //取余
            pre.next = new ListNode(n % 10);
            //指针移位
            pre = pre.next;
            //取整进位
            n = n / 10;
        }
        return getReturnList(result.next);
    }
	//反转链表
    private ListNode getReturnList(ListNode node){
        if(node == null || node.next == null){
            return node;
        }
        ListNode pre = null, temp;
        while(node != null){
            temp = node.next;
            node.next = pre;
            pre = node;
            node = temp;
        }
        return pre;
    }

8.单链表的排序

描述：给定一个节点数为n的无序单链表，对其按升序排序。
代码如下（示例）：

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * @param head ListNode类 the head node
     * @return ListNode类
     */
    public ListNode sortInList (ListNode head) {
        // write code here
        ArrayList<Integer> list = new ArrayList();
        while(head != null){
            list.add(head.val);
            head = head.next;
        }
        Collections.sort(list);
        ListNode root = new ListNode(0);
        ListNode cur = root;
        for (int i = 0; i < list.size(); i++){
            cur.next = new ListNode(list.get(i));
            cur = cur.next;
        }
    return root.next;
    }

9.单链表的排序

描述：给定一个链表，请判断该链表是否为回文结构。回文是指该字符串正序逆序完全一致。
代码如下（示例）：

方法一：
public class Solution {
    /**
     * 利用堆栈法
     * @param head ListNode类 the head
     * @return bool布尔型
     */
    public boolean isPail (ListNode head) {
        // write code here
        Stack<ListNode> stack = new Stack<>();
        ListNode node = head;
        while(node != null){
            stack.push(node);
            node = node.next;
        }
        while(head != null){
            if(head.val != stack.pop().val){
                return false;
            }
            head = head.next;
        }
    return true;
    }
方法二：
public class Solution {
    /**
     * 利用双指针法
     * @param head ListNode类 the head
     * @return bool布尔型
     */
    public boolean isPail (ListNode head) {
        // write code here
        if(head == null || head.next == null){
            return true;
        }
        ListNode slow = head, fast = head;
        while (fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode mid = getReturnList(slow.next);
        while(mid != null && head != null){
            if(head.val != mid.val){
            return false;
            }
            head = head.next;
            mid = mid.next;
        }
        return true;
    }
    private ListNode getReturnList(ListNode list){
        if(list == null || list.next == null)
            return list;
        ListNode pre = null,temp;
        while(list != null){
            temp = list.next;
            list.next = pre;
            pre = list;
            list = temp;
        }
        return pre;
    }

10.链表的奇偶重排

描述：给定一个单链表，请设定一个函数，将链表的奇数位节点和偶数位节点分别放在一起，重排后输出。注意是节点的编号而非节点的数值。

代码如下（示例）：

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * @param head ListNode类 
     * @return ListNode类
     */
    public ListNode oddEvenList (ListNode head) {
        // write code here
        if(head == null || head.next == null){
            return head;
        }
        ListNode list1 = head, list2 = head.next, list2Head = list2;
        while(list2 != null && list2.next != null){
            list1.next = list2.next;
            list1 = list1.next;
            list2.next = list1.next;
            list2 = list2.next;
        }
        list1.next = list2Head;
        return head;
    }

11.删除有序链表中重复的元素-I

描述：删除给出链表中的重复元素（链表中元素从小到大有序），使链表中的所有元素都只出现一次.
代码如下（示例）：

方法一：
public class Solution {
    /**
     * @param head ListNode类 
     * @return ListNode类
     */
    public ListNode deleteDuplicates (ListNode head) {
        // write code here
        if(head == null || head.next == null){
            return head;
        }
        ListNode pre = head;
        while (pre != null && pre.next != null){
            if(pre.val == pre.next.val){
                pre.next = pre.next.next;
            }else{
                pre = pre.next;
            }
        }
        return head;
    }

12.删除有序链表中重复的元素-I

描述：给出一个升序排序的链表，删除链表中的所有重复出现的元素，只保留原链表中只出现一次的元素。
代码如下（示例）：

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param head ListNode类
     * @return ListNode类
     */
    public ListNode deleteDuplicates (ListNode head) {
        // write code here
        ListNode newList = new ListNode(-1);
        newList.next = head;
        ListNode pre = newList;
        while (pre.next != null && pre.next.next != null) {
            int val = pre.next.next.val;
            if(pre.next.val == val){
                while(pre.next != null && pre.next.val == val){
                    pre.next = pre.next.next;
                }
            }else{
                pre = pre.next;
            }
        }
        return newList.next;
    }

总结

坚持每天刷题！！!（打卡第2天）

xiaqaz
关注
查找链表中倒数第k个结点
sanmuyang123的博客
09-06 589
定义两个指针。第一个指针从链表的头指针开始遍历向前走k-1，第二个指针保持不动；从第k步开始，第二个指针也开始从链表的头指针开始遍历。由于两个指针的距离保持在k-1，当第一个（走在前面的）指针到达链表的尾结点时，第二个指针（走在后面的）指针正好是倒数第k个结点。 #include<iostream> using namespace std; struct ListNode { ...
牛客刷题之链表
qq_40651109的博客
07-27 191
题目描述 给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 解题思路： 首先判断链表是否为空，为空直接返回空； 然后，将头节点分别赋给两个指针； 判断list1是否为空，若为空，直接返回null,否则，让list1先向前移动两个位置，让list2移动一个位置； 若有环，此时list1和list2相等，...
【剑指offer】【java】【链表】两个链表的第一个公共结点
qq_29295351的博客
03-06 167
题目 输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的） 思路 故p1遍历到尾结点后再从phead2开始遍历 p2遍历到尾结点后再从phead1开始 两个指针同步next移位，走过的距离是 a+c+b=b+c+a 所以他们会在公共结点汇集 代码 /* public class ListNode { int ...
牛客在线编程之链表
young_man2的博客
09-27 1000
牛客在线编程之链表
链表的部分OJ题目
H48530的博客
03-16 588
链表的部分OJ题目移除链表元素反转链表链表的中间结点链表中倒数第K个结点合并两个有序链表链表分割删除链表中重复结点相交链表链表的回文结构 移除链表元素 LeetCode-203 移除链表元素 203. 移除链表元素 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 class Solution { public ListNode removeElements(ListNode head, int v
2022.10.28-牛客-Java数组专项练习
最新发布
YYNPYWW的博客
10-28 615
2022.10.28-牛客-Java数组专项练习
2022.10.27-牛客-Java数组专项练习
YYNPYWW的博客
10-27 642
2022.10.27-牛客-Java数组专项练习
2022.10.25-牛客-Java数组专项练习
YYNPYWW的博客
10-25 252
2022.10.25-牛客-Java数组专项练习
牛客(9.18)-链表专项练习
weixin_44151598的博客
09-19 734
第一题：设有n个元素的集合，采用带头结点有序链表来实现，设集合的元素占8个字节，链接指针占2个字节，该集合的存储密度为(C) A、0.8 B、n/(n+1) C、0.8n/(n+1) D、0.8(n+1)/n 答案解析：题目要求计算集合的存储密度首先需要知道什么是存储密度：存储密度 = （结点数据本身所占的存储量）/（结点结构所占的存储总量）由题目可知：元素占8n字节，指针占2n字节，头结点...
牛客 - Java专项练习题知识点整理（四）
新新许愿树
02-21 324
目录 ■ 构造方法修饰符 ■ 泛型 ■ Java线程之间的通信 ■ for语句执行流程 ■ 异常类Throwable ■ String classFile = "com.jd.".replaceAll(".","/")+"MyClass.class"; ■ 子类调用父类构造函数 ■ 进制的表现形式 ■ HashMap如何解决hash冲突 ■ Java是从哪个语言改进而来的 ■...
牛客_反转链表
zhangvalue的博客
02-23 452
题目描述 输入一个链表，反转链表后，输出新链表的表头。 思路： 链表是单向遍历，想要反转链表需要使用两个变量来控制 其中firstNode主要作用是作为一个中间结点的作用，不然单链表中间断掉失去下一个结点的信息 secondeNode作为最终的结点 /* public class ListNode { int val; ListNode next = null; ...
牛客_合并两个排序的链表
zhangvalue的博客
02-23 215
题目描述 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。 思路： 一、使用递归 /* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public ...
牛客TOP101之链表篇（高效刷题，带你手撕算法）
qq_36317312的博客
05-04 2955
1、反转链表 1、给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。 如当输入链表{1,2,3}时， 经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。 以上转换过程如下图所示： 输入：{1,2,3} 返回值：{3,2,1} 输入：{} 返回值：{} 说明：空链表则输出空 常规思路：迭代 具体细节：在遍历链表时，将当前节点的next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个
【牛客】 链表分割
weixin_45393657的博客
03-08 136
题目描述： 现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。 public static ListNode partition(ListNode pHead, int x){ //创建一个傀儡节点作为小于x值节点的头节点 ListNode smallhead=new ListNode(-1); //smallTail用于连接小于x值的节点
牛客网---链表分割
sophia__yu的博客
11-06 304
编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前。 给定一个链表的头指针 ListNode* pHead，请返回重新排列后的链表的头指针。注意：分割以后保持原来的数据顺序不变。 对于这个题：思路是： 先将原链表数据分为2个集合，一个是小于x的集合l1，另一个是大于等于x的集合l2，只是把数据放进数组，并不排序，然后把l2中数据添加在集合l1后面，这样就完成小...
牛客网-剑指offer-15-反转链表
风万里的博客
09-13 696
时间限制：1秒 空间限制：32768K 热度指数：174815 本题知识点： 链表  算法知识视频讲解 题目描述 输入一个链表，反转链表后，输出链表的所有元素。 /* public class ListNode {     int val;     ListNode next = null;     ListNode(int val) {        
牛客网刷题----链表
llz56的博客
06-02 368
1、单链表的逆序 2、找到单链表环开始的地方 方法1： （1）.首先判断是否存在环 （2）.若存在环，则从起点开始，每走一步就删除上一个节点的next指针，最后一个节点就是环的起点。因为环的起点会存在两个next指向它 链接：https://www.nowcoder.com/questionTerminal/6e630519bf86480296d0f1c868d425ad 来源：牛客网 List...
牛客网算法学习笔记-链表
u012656267的博客
05-25 3888
对于一个链表，我们需要用一个特定阈值完成对它的分化，使得小于等于这个值的结点移到前面，大于该值的结点在后面，同时保证两类结点内部的位置关系不变。 给定一个链表的头结点head，同时给定阈值val，请返回一个链表，使小于等于它的结点在前，大于等于它的在后，保证结点值不重复。 测试样例： {1,4,2,5},3 {1,2,4,5} 单独建立两个头结点，并且建立两个尾结点，保证有头指针
力扣解题思路：复杂链表、图的复制
qq_39879315的博客
08-24 150
复杂链表的复制 思路：输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的 head。 这一题猛地一看好像很简单，只要复制相应的节点然后穿起来即可，但是这里有个问题，节点复制当然简单，但是要按照原始链表的random的指向，如何复制这个指向呢？我们可以先把所有next指向先复制了，就可以把链表穿起来，但是在新链表中寻找random是个很复杂的事情，那么我们是否有更好的方法呢，比如我们知道random在原链表中的位置，那我们是否可
牛客网算法题总结：链表反转解析
"这篇总结主要涉及的是在牛客平台上完成的一些简单的算法题目，特别是关于链表操作的问题，其中重点介绍了如何反转链表。" 在算法编程中，链表是一种非常基础且重要的数据结构，它由一系列节点组成，每个节点包含...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值