LeetCode 必刷题目集合-链表

最新推荐文章于 2024-06-15 09:23:13 发布
最新推荐文章于 2024-06-15 09:23:13 发布
阅读量360 收藏
点赞数
分类专栏： LeetCode 文章标签： 链表 leetcode java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45415226/article/details/122243813
版权

目录

141.环形链表

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null) return false;
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null) {
            slow = slow.next;
            if (fast.next == null) return false;
            fast = fast.next.next;
            if (slow == fast) return true;
        }
        return false;
    }
}

142.环形链表 II

在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if (head == null) return null;
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null) {
            slow = slow.next;
            if (fast.next == null) return null;
            fast = fast.next.next;
            if (slow == fast) break;
        }
        if (fast == null) return null;
        while (head != fast) {
            head = head.next;
            fast = fast.next;
        }
        return head;
    }
}

21.合并两个有序链表

在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if (list1 == null) return list2;
        if (list2 == null) return list1;
        ListNode pre = new ListNode(0);
        ListNode node = pre;
        while (list1 != null && list2 != null) {
            if (list1.val <= list2.val) {
                node.next = list1;
                list1 = list1.next;
                node = node.next;
            } else {
                node.next = list2;
                list2 = list2.next;
                node = node.next;
            }
        }
        if (list1 == null) node.next = list2;
        else if (list2 == null) node.next = list1;
        return pre.next;
    }
}

206.反转链表

在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    // public ListNode reverseList(ListNode head) {
    //     // 迭代
    //     if (head == null) return head;
    //     ListNode node = head;
    //     head = head.next;
    //     node.next = null;
    //     while (head != null) {
    //         ListNode temp = head.next;
    //         head.next = node;
    //         node = head;
    //         head = temp;
    //     }
    //     return node;
    // }

    public ListNode reverseList(ListNode head) {
        // 递归
        if (head == null || head.next == null) return head;
        ListNode node = head.next;
        ListNode reverseHead = reverseList(node);
        node.next = head;
        head.next = null;
        return reverseHead;
    }
}

24.两两交换链表中的节点

在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode node = head.next.next;
        ListNode swapHead = head.next;
        head.next.next = head;
        head.next = node;
        while (node != null && node.next != null) {
            ListNode temp = node;
            node = node.next.next;
            head.next = temp.next;
            temp.next.next = temp;
            temp.next = node;
            head = temp;
        }
        return swapHead;
    }
}

160.相交链表

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
 * 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) {
        ListNode node1 = headA;
        ListNode node2 = headB;
        while (node1 != node2) {
            if (node1 == null) node1 = headB;
            else node1 = node1.next;
            if (node2 == null) node2 = headA;
            else node2 = node2.next;
        }
        return node1;
    }
}

83.删除排序链表中的重复元素

在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode node = head;
        while (node.next != null) {
            if (node.val == node.next.val) node.next = node.next.next;
            else node = node.next;
        }
        return head;
    }
}

19.删除链表的倒数第 N 个结点

在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if (head.next == null) return null;
        ListNode fast = head;
        ListNode slow = head;
        for (int i = 0; i < n; i++) fast = fast.next;
        if (fast == null) return head.next;
        while (fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return head;
    }
}

445.两数相加 II

在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        Stack<ListNode> stack1 = new Stack<>();
        Stack<ListNode> stack2 = new Stack<>();
        buildStack(stack1, l1);
        buildStack(stack2, l2);
        ListNode node = null;
        int m = 0;
        while (!stack1.empty() || !stack2.empty() || m != 0) {
            int a = stack1.empty() ? 0 : stack1.pop().val;
            int b = stack2.empty() ? 0 : stack2.pop().val;
            int c = (a + b + m) / 10;
            int d = (a + b + m) % 10;
            m = c;
            ListNode newNode = new ListNode(d);
            newNode.next = node;
            node = newNode;
        }
        return node;
    }

    public void buildStack(Stack<ListNode> stack, ListNode node) {
        while (node != null) {
            stack.push(node);
            node = node.next;
        }
    }
}

234.回文链表

在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        if (head.next == null) return true;
        ListNode fast = head.next;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        ListNode rNode = null;
        if (fast == null) rNode = reverseNode(slow);
        else rNode = reverseNode(slow.next);
        while (rNode != null) {
            if (rNode.val != head.val) return false;
            rNode = rNode.next;
            head = head.next;
        }
        return true;
    }

    public ListNode reverseNode(ListNode head) {
        if (head.next == null) return head;
        ListNode node = null;
        while (head != null) {
            ListNode temp = head.next;
            head.next = node;
            node = head;
            head = temp;
        }
        return node;
    }
}

328.奇偶链表

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode oddEvenList(ListNode head) {
        if (head == null) return head;
        ListNode oddHead = head;
        ListNode evenHead = head.next;
        while (head.next != null) {
            ListNode temp = head.next;
            head.next = temp.next;
            if (head.next == null) break;
            head = head.next;
            temp.next = head.next;
        }
        head.next = evenHead;
        return oddHead;
    }
}

725.分隔链表

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode[] splitListToParts(ListNode head, int k) {
        ListNode[] result = new ListNode[k];
        if (head == null) return result;
        int nodes = sumNodes(head);
        int m = nodes / k;
        int n = nodes % k;
        int[] arr = new int[k];
        Arrays.fill(arr, m);
        for (int i = 0; i < n; i++) {
            arr[i] += 1;
        }
        for (int i = 0; i < k; i++) {
            if (arr[i] == 0) continue;
            result[i] = head;
            ListNode pre = null;
            for (int j = 0; j < arr[i]; j++) {
                pre = head;
                head = head.next;
            }
            pre.next = null;
        }
        return result;
    }

    public int sumNodes(ListNode head) {
        int sum = 0;
        while (head != null) {
            sum++;
            head = head.next;
        }
        return sum;
    }
}
EricIsRising
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode怎么销号-leetcode-exercise:leetcode用python练习
06-30
逆转链表，对链表这个结构不熟，这道easy题还做了一阵子 9 Easy April 15 直接用了两个集合做差集 10 Medium April 15 找数组中第k大的数 11 Easy April 20 找数组中不相邻元素最大和（动态规划） 12 Medium（Easy) ...
javalruleetcode-leetcode:leetcode刷题集合
06-29
leetcode题目分类 1.数组 2.Linked List （注意如果是两个Integer类型进行比较要用equals，有赞笔试真题，要学会在原地解决这个问题） （用递归的方法 要多写 经常问） 3.数组和链表 4.栈和队列（要分析java stack ...
LeetCode链表集锦
如风暖阳的博客
07-04 255
LeetCode链表集锦
LeetCode算法之--链表系列
程序大视界
12-21 697
LeetCode链表常见算法题型
LeetCode 必刷题目集合-树
要努力成为一名优秀的软件工程师！
12-03 1864
LeetCode 必刷题目集合-树
LeetCode刷题 --- 链表
qq_43325216的博客
05-18 489
参考上一题，定义哨兵节点，以及三个指针节点，仍然按照p和q比较，遍历，多定义的r节点，是p节点的上一个节点，pq相同的时候，q不断后移，一直移到为null或者值不同，然后将r的下一个节点指向q。去重，可以使用Map或者set ，遍历链表，如果节点的值已经在集合中存在，那么这个节点就是重复节点，可以删除，如果不存在，则将值存入集合，继续遍历。定义两个指针节点p和q，分别指向头节点，先让q节点向后移动n步，然后，在让p和q同时后移，当q指向空的时候，p恰好是倒数第n个节点的前一个节点。
【Leetcode链表篇】-Leetcode链表相关的题目
Mind_programmonkey的博客
05-16 579
链表篇 1.Leetcode002 两数相加 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例 1： 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 链表的：加法模板 记录好进位值 /** * Definition for singly-
LeetCode刷题---环形链表
weixin_47109902的博客
12-02 391
环形链表：一般来说就是链表的最后一个结点指向链表中的某个结点形成一个闭环，那么这个就是环形链表。
刷算法Leetcode---2（链表篇）
m0_70220973的博客
12-14 1676
Leetcode链表篇~
2024年LeetCode - 链表题大集合 - Java - 细喔，腾讯java社招面试有几轮
2401_84584204的博客
05-06 477
还有更多的Redis、MySQL、JVM、Kafka、微服务、Spring全家桶等学习笔记这里就不一一列举出来。
常考的leetcode题目-Algorithms-and-Data-Structures:该存储库用于记录算法问题
06-30
常考的leetcode题目 算法和数据结构 该存储库用于实现和练习算法和数据结构。 数据结构 这是我在学术生活中学到的数据结构和算法的集合。 本总结供进一步学习之用。 所有算法都应该经过测试并且 100% 正确。 数据...
leetcode答案-leetcode-[removed]leetcode
06-30
leetcode 答案 leetcode-javascript leetcode 题解，记录自己的 leetcode 解题之路。 本仓库目前分为三个部分： 第一个部分是 leetcode 分类经典题目的解析，包括思路，关键点和具体的代码实现。 第二部分是对于数据...
LeetCode 23. 合并K个排序链表
12-21
题目 合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。 示例: 输入: [ 1->4->5, 1->3->4, 2->6 ] 输出: 1->1->2->3->4->4->5->6 来源：力扣（LeetCode） 链接：...
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 402
【代码】力扣LCP 08.剧情触发时间。
【代码随想录算法训练Day35】LeetCode 1005. K 次取反后最大化的数组和、LeetCode 134.加油站、LeetCode 135.分发糖果
qq_46121420的博客
06-11 220
贪心第三天
【回溯】Leetcode 77. 组合【中等】
FLGB
06-11 249
你可以按 任何顺序 返回答案。
链表经典题目：环形链表问题（LeetCode141.环形链表、LeetCode142.环形链表Ⅱ）
最新发布
iiiiiankor的博客
06-15 713
🌟🌟🌟环形链表问题在面试中是经常爱考的，你有没有发现环形链表的题目代码都没有很难，一般是思路难以想到，所以人家考你的是思路，并不真的会纠你代码写的怎么样！快指针必须一次走2步吗？可以一次走3步，走4步可以吗？你会怎么回答？怎么证明快指针一次走2步一定可以追上？这里我们简单证明一下：➡️快指针一次走2步那么一定可以追得上首先需要知道，fast什么时候开始追击slow因为fast首先进入环，在slow进环之前，二者的运动路径并不一样！只有当slow也开始进环，才开始所谓的追及问题。
leetcode387：字符串中的第一个唯一字符
Ricky_youngone的博客
06-10 190
这个题目看似简单，实际上很考验你对于字符数组的理解，说白了，这个题目中档，一开始我用的是遍历和标记，最后发现不行。换了unordered_map这个方法，这个方法也是映射，也就是遍历一遍给的字符，把单独的字符在char映射到int中增加1，然后在遍历一遍字符，看看哪个是第一个出现且char映射的int数字只有1，这个就是第一个唯一字符。
leetcode-5:实现链表的首尾链接
12-30
leetcode-5题要求我们实现链表的首尾链接，即将链表中最后一个节点的next指针指向链表中的第一个节点，并将链表中的第一个节点的prev指针指向链表中最后一个节点。 解题思路如下： 1. 首先，判断链表是否为空，若为...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值