leetcode(HOT100)——链表篇

已于 2024-04-08 09:21:50 修改
阅读量453 收藏 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 401
那么移动路径形如。
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 171
刷题总结
LeetCode HOT 100 —— 206 .反转链表
qq_39473176的博客
12-10 157
刷题总结
LeetCode HOT 100 —— 160.相交链表
qq_39473176的博客
12-09 152
刷题总结
LeetCode HOT 100 —— 114.二叉树展开为链表
qq_39473176的博客
12-05 235
刷题总结
LeetCode HOT 100 —— 234.回文链表
qq_39473176的博客
12-13 108
刷题总结
leetcode算法总结 —— HOT 100分类整理
Charles Ren's Tech Blog
04-01 8396
两数之和 二叉树的序列化与反序列化 最小栈 二叉树的最大深度（后序遍历深度向上返回）
LeetCode HOT 100 —— 146.LRU缓存
qq_39473176的博客
12-07 380
刷题总结
LeetCode HOT 100 —— 23.合并K个升序链表
qq_39473176的博客
11-25 466
刷题总结
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)): ...
LeetCode 算法：排序链表 c++
最新发布
小金牛来了
06-22 540
LeetCode 算法：排序链表 c++
力扣454题解：四数相加（java实现简易）
2301_77695569的博客
06-17 703
LeetCode第454题是一个考察数组和哈希表的经典问题。通过这个问题，我们可以加深对双指针技巧和哈希表应用的理解。掌握这个问题的解法，对于解决其他相关问题非常有帮助。
leetcode:2848. 与车相交的点（python3解法）
qq_41905051的博客
06-19 174
leetcode:2848. 与车相交的点（python3解法）
LeetCode 610, 28, 23
qq_61350148的博客
06-18 913
使用mysql和java语言解决LeetCode 610, 28, 23。
leetcode hot100有哪些
05-30
LeetCode是一个非常受欢迎的在线编程学习平台，提供了大量的编程题目和算法学习资源。Hot 100题目是指LeetCode中最热门的100道题目，这些题目涵盖了许多经典的算法和数据结构问题，非常适合提高编程能力和算法水平。以下是LeetCode Hot 100题目的一些例子： 1. Two Sum 2. Add Two Numbers 3. Longest Substring Without Repeating Characters 4. Median of Two Sorted Arrays 5. Longest Palindromic Substring 6. Container With Most Water 7. Next Permutation 8. Trapping Rain Water 9. Merge Intervals 10. Jump Game II 11. Combination Sum 12. Valid Parentheses 13. Unique Paths 14. Product of Array Except Self 15. Find Minimum in Rotated Sorted Array 以上只是Hot 100题目的一部分，如果您想进一步了解LeetCode Hot 100题目，请访问LeetCode官方网站。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值