leetcode(HOT100)——链表篇

已于 2024-04-08 09:21:50 修改
阅读量451 收藏 6
点赞数 5
分类专栏： leetcode专题汇总 文章标签： leetcode 链表 算法
于 2024-04-05 11:17:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61028090/article/details/137167948
版权

1、相交链表

        本题思路就是定义两指针，指向两链表的同一起跑线，然后共同往前走，边走边判断两链表的节点是否相等， 代码如下：

/**
 * 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 curA = headA;
        ListNode curB = headB;
        int countA = 0;
        int countB = 0;
        while(curA != null){
            countA++;
            curA = curA.next;
        }
        while(curB != null){
            countB++;
            curB = curB.next;
        }
        curA = headA;
        curB = headB;
        if(countA > countB){
            int count = countA - countB;
            while(count > 0){
                curA = curA.next;
                count--;
            }
        }
        else if(countB > countA){
            int count = countB - countA;
            while(count > 0){
                curB = curB.next;
                count--;
            }
        }
        while(curA != null){
            if(curA == curB) return curA;
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
}

 2、反转链表

        经典题目，原地操作，需要定义一个pre节点， 具体代码如下：

/**
 * 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 null;
        ListNode cur = head;
        ListNode pre = null;
        while(cur != null && cur.next != null){
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        cur.next = pre;
        return cur;
    }
}

3、回文链表

        本题思路是将链表的节点值存入数组中，然后用左右指针分别判断数组的左右两边元素值是否相等， 代码如下：

/**
 * 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) {
        List<Integer> list = new ArrayList<>();
        ListNode cur = head;
        while(cur != null){
            list.add(cur.val);
            cur = cur.next;
        }
        int left = 0;
        int right = list.size()-1;
        while(left < right){
            if(list.get(left) != list.get(right)){
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

 4、环形链表

        定义快慢指针，快指针一次走两步，慢指针一次走一步，如果有环的话他们就会相遇，代码如下：

/**
 * 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) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast!=null && fast.next!=null && fast.next.next!=null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                return true;
            }
        }
        return false;
    }
}

5、环形链表 II

        本题先找到两节点相遇的地方，然后利用一点数学技巧可以得出在相遇的地方向前走a的距离，即可到达环的入口。(a为起点到环入口的距离) 

/**
 * 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) {
        ListNode fast = head;
        ListNode slow = head;
        while(true){
            if(fast==null || fast.next==null || fast.next.next==null) return null;
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                break;
            }
        }
        fast = head;
        while(fast != slow){
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

 6、合并两个有序链表

        创建一个新链表，不断添加两个链表的节点即可。

/**
 * 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 head = new ListNode();
        if(list1.val > list2.val){
            head = list2;
            list2 = list2.next;
        }
        else{
            head = list1;
            list1 = list1.next;
        }
        ListNode cur = head;
        while(list1!=null && list2!=null){
            if(list1.val > list2.val){
                cur.next = list2;
                cur = cur.next;
                list2 = list2.next;
            }
            else{
                cur.next = list1;
                cur = cur.next;
                list1 = list1.next;
            }
        }
        if(list1 == null){
            while(list2 != null){
                cur.next = list2;
                cur = cur.next;
                list2 = list2.next;
            }
        }
        if(list2 == null){
            while(list1 != null){
                cur.next = list1;
                cur = cur.next;
                list1 = list1.next;
            }
        }
        return head;
    }
}

7、两数相加

        本题需要考虑2个情况：短的链表需要补0、需要考虑进位。  代码如下：

/**
 * 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) {
        ListNode dummy = new ListNode();
        ListNode cur = dummy;
        int next = 0; //进位
        while(l1 != null || l2 != null){
            int n1 = l1 == null? 0 : l1.val;
            int n2 = l2 == null? 0 : l2.val;
            int sum = n1 + n2 + next;
            next = sum / 10;
            cur.next = new ListNode(sum % 10);
            cur = cur.next;
            if(l1 != null) l1 = l1.next;
            if(l2 != null) l2 = l2.next;
        }
        if(next > 0){
            cur.next = new ListNode(next);
        }
        return dummy.next;
    }
}

8、删除链表的倒数第 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) {
        int sum = 0; //节点个数
        ListNode cur = head;
        while(cur != null){
            sum++;
            cur = cur.next;
        }
        int count = sum - n;
        ListNode dummy = new ListNode();
        dummy.next = head;
        cur = dummy;
        //将节点移动至被删节点的前一个节点
        while(count > 0){
            cur = cur.next;
            count--;
        }
        cur.next = cur.next.next;
        return dummy.next;
    }
}

9、LRU 缓存

        本题需要维护一个队列，队头元素即为最近使用的元素，队尾元素即为最近最久没使用过的元素。 

class LRUCache {
    private int capacity;
    Map<Integer,Integer> map = new HashMap<>();
    LinkedList<Integer> LRUlist = new LinkedList<>();

    public LRUCache(int capacity) {
        this.capacity = capacity;
    }
    
    public int get(int key) {
        int temp = map.getOrDefault(key,-1);
        if(temp != -1){
            //更新LRUlist
            LRUlist.remove((Integer)key);
            LRUlist.addFirst(key);
        }
        return temp;
    }
    
    public void put(int key, int value) {
        //已经存在该key
        if(map.containsKey(key)){
            LRUlist.remove((Integer)key);
            LRUlist.addFirst(key);
            map.put(key,value);
        }
        else{
            //map未超出容量
            if(map.size() < capacity){
                map.put(key,value);
                LRUlist.addFirst(key);
            }
            else{
                int temp = LRUlist.removeLast(); //移除最近最久未使用的元素
                map.remove(temp);
                map.put(key,value);
                LRUlist.addFirst(key);
            }
        }
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

10、排序链表

        本题先将链表的值保存至集合中，再将集合的元素排序，再重新构造出一个链表。

/**
 * 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 sortList(ListNode head) {
        ListNode cur = head;
        List<Integer> nums = new ArrayList<>();
        while(cur != null){
            nums.add(cur.val);
            cur = cur.next;
        }
        Collections.sort(nums);
        ListNode dummy = new ListNode();
        cur = dummy;
        for(int i=0; i<nums.size(); i++){
            cur.next = new ListNode(nums.get(i));
            cur = cur.next;
        }
        return dummy.next;
    }
}

我真的很帅阿
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【2023】LeetCode HOT 100——链表
⚡
08-30 400
那么移动路径形如。
LeetCode刷题笔记——#21. 合并两个有序链表
12-22
###### leetcode 代码主体 ###### class Solution: def mergeTwoLists(self, l1, l2): if l1 is None: return l2 elif l2 is None: return l1 elif l1.val ListNode: prenode = ListNode(0)
LeetCode HOT 100 —— 148.排序链表
qq_39473176的博客
12-08 169
刷题总结
LeetCode HOT 100 —— 206 .反转链表
qq_39473176的博客
12-10 155
刷题总结
LeetCode HOT 100 —— 160.相交链表
qq_39473176的博客
12-09 151
刷题总结
LeetCode HOT 100 —— 114.二叉树展开为链表
qq_39473176的博客
12-05 232
刷题总结
LeetCode HOT 100 —— 234.回文链表
qq_39473176的博客
12-13 107
刷题总结
leetcode算法总结 —— HOT 100分类整理
Charles Ren's Tech Blog
04-01 8390
两数之和 二叉树的序列化与反序列化 最小栈 二叉树的最大深度（后序遍历深度向上返回）
LeetCode HOT 100 —— 146.LRU缓存
qq_39473176的博客
12-07 378
刷题总结
LeetCode HOT 100 —— 23.合并K个升序链表
qq_39473176的博客
11-25 464
刷题总结
LeetCode解题心得——反转链表（python）
12-21
题目 反转一个单链表。 示例： 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 思路 1.递归 class Solution: def reverseList(self, head: ListNode) -> ListNode: if head == None or head.next == None: ...
LeetCode刷题笔记——19. 删除链表的倒数第N个节点
12-21
  这道题本质上和《剑指Offer》刷题笔记——面试题22. 链表中倒数第k个节点是一样的。都可以用单指针两次遍历或者双指针一次遍历解决。 2、代码实现 # Definition for singly-linked list. # class ListNode: # ...
leetcode-86 分隔链表
01-08
给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前。 你应当保留两个分区中每个节点的初始相对位置。 示例: 输入: head = 1->4->3->2->5->2, x = 3 输出: 1->2->2->4-...
LeetCode刷题笔记——#14. 最长公共前缀
12-22
难度：简单 一、题目描述： 二、解题分析： 1、水平扫描 class Solution: def longestCommonPrefix(self, strs: List[str]) -> str: if len(strs) == 0: return '' s = strs[0] for i in range(1, len(strs)): ...
Golang | Leetcode Golang题解之第149题直线上最多的点数
weixin_66442839的博客
06-14 443
Golang | Leetcode Golang题解之第149题直线上最多的点数
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 452
【代码】力扣LCP 08.剧情触发时间。
Java | Leetcode Java题解之第149题直线上最多的点数
m0_57195758的博客
06-14 346
Java | Leetcode Java题解之第149题直线上最多的点数
链表经典题目：环形链表问题（LeetCode141.环形链表、LeetCode142.环形链表Ⅱ）
最新发布
iiiiiankor的博客
06-15 1106
🌟🌟🌟环形链表问题在面试中是经常爱考的，你有没有发现环形链表的题目代码都没有很难，一般是思路难以想到，所以人家考你的是思路，并不真的会纠你代码写的怎么样！快指针必须一次走2步吗？可以一次走3步，走4步可以吗？你会怎么回答？怎么证明快指针一次走2步一定可以追上？这里我们简单证明一下：➡️快指针一次走2步那么一定可以追得上首先需要知道，fast什么时候开始追击slow因为fast首先进入环，在slow进环之前，二者的运动路径并不一样！只有当slow也开始进环，才开始所谓的追及问题。
leetcode hot100有哪些
05-30
Hot 100题目是指LeetCode中最热门的100道题目，这些题目涵盖了许多经典的算法和数据结构问题，非常适合提高编程能力和算法水平。以下是LeetCode Hot 100题目的一些例子： 1. Two Sum 2. Add Two Numbers 3. Longest...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值