力扣-Hot100-链表其三【算法学习day.36】

前言

###我做这类文档一个重要的目的还是给正在学习的大家提供方向(例如想要掌握基础用法,该刷哪些题?)我的解析也不会做的非常详细,只会提供思路和一些关键点,力扣上的大佬们的题解质量是非常非常高滴!!!


习题

1.随机链表的复制

题目链接: 138. 随机链表的复制 - 力扣(LeetCode)

题面:

**基本分析:**主要难在random的处理上,我看题解的

代码:

java 复制代码
/*
// Definition for a Node.
class Node {
    int val;
    Node next;
    Node random;

    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}
*/

class Solution {
    public Node copyRandomList(Node head) {
       for(Node i = head;i!=null;i=i.next){
          Node flag = new Node(i.val);
          flag.next = i.next;
          i.next = flag;
          i=i.next;
       }
       for(Node i = head;i!=null;i=i.next){
         if(i.random!=null){
            i.next.random = i.random.next;
         }
         i = i.next;
       }
       Node root = new Node(-1);
       Node node = new Node(-1);
       root.next = node;
       for(Node i = head;i!=null;i=i.next){
        node.next = i.next;
        i.next = node.next.next;
        node = node.next;
       }
       return root.next.next;
    }
}

2.排序链表

题目链接: 148. 排序链表 - 力扣(LeetCode)

题面:

**基本分析:**我是先把所有值存起来然后构建链表的暴力写法

代码:

java 复制代码
/**
 * 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) {
        int[] arr = new int[50005];
        int count =  0;
        for(ListNode i = head;i!=null;i=i.next){
            arr[count++] = i.val;
        }
        Arrays.sort(arr,0,count);
        ListNode p = head;
        for(int i = 0;i<count;i++){
            p.val = arr[i];
            p = p.next;
        }
        return head;
    }
}

3.LRU缓存

题目链接: 146. LRU 缓存 - 力扣(LeetCode)

题面:

**基本分析:**把整个过程想象成一叠书,可以看看灵神的题解

代码:

java 复制代码
class LRUCache {
    private static class Node {
        int key, value;
        Node prev, next;

        Node(int k, int v) {
            key = k;
            value = v;
        }
    }

    private final int capacity;
    private final Node dummy = new Node(0, 0); // 哨兵节点
    private final Map<Integer, Node> keyToNode = new HashMap<>();

    public LRUCache(int capacity) {
        this.capacity = capacity;
        dummy.prev = dummy;
        dummy.next = dummy;
    }

    public int get(int key) {
        Node node = getNode(key);
        return node != null ? node.value : -1;
    }

    public void put(int key, int value) {
        Node node = getNode(key);
        if (node != null) { // 有这本书
            node.value = value; // 更新 value
            return;
        }
        node = new Node(key, value); // 新书
        keyToNode.put(key, node);
        pushFront(node); // 放在最上面
        if (keyToNode.size() > capacity) { // 书太多了
            Node backNode = dummy.prev;
            keyToNode.remove(backNode.key);
            remove(backNode); // 去掉最后一本书
        }
    }

    // 获取 key 对应的节点,同时把该节点移到链表头部
    private Node getNode(int key) {
        if (!keyToNode.containsKey(key)) { // 没有这本书
            return null;
        }
        Node node = keyToNode.get(key); // 有这本书
        remove(node); // 把这本书抽出来
        pushFront(node); // 放在最上面
        return node;
    }

    // 删除一个节点(抽出一本书)
    private void remove(Node x) {
        x.prev.next = x.next;
        x.next.prev = x.prev;
    }

    // 在链表头添加一个节点(把一本书放在最上面)
    private void pushFront(Node x) {
        x.prev = dummy;
        x.next = dummy.next;
        x.prev.next = x;
        x.next.prev = x;
    }
}

4.合并k个升序链表

题目链接: 23. 合并 K 个升序链表 - 力扣(LeetCode)

题面:

**基本分析:**暴力做法还是很好做的,把所有值存数组,排序后构造一个数组并返回

代码:

java 复制代码
/**
 * 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 mergeKLists(ListNode[] lists) {
        int[] arr = new int[10005];
        int count = 0;
        for(ListNode node : lists){
            for(ListNode i = node;i!=null;i=i.next){
                arr[count++] = i.val;
            }
        }
        Arrays.sort(arr,0,count);
        ListNode root = new ListNode(0);
        ListNode node = new ListNode(0);
        root.next = node;
        for(int i = 0;i<count;i++){
            ListNode flag = new ListNode(arr[i]);
            node.next = flag;
            node = node.next;
        }
        return root.next.next;
    }
}

后言

上面是力扣Hot100的链表专题,下一篇是其他专题的习题,希望有所帮助,一同进步,共勉!

相关推荐
XiaoLeisj13 分钟前
【递归,搜索与回溯算法 & 综合练习】深入理解暴搜决策树:递归,搜索与回溯算法综合小专题(二)
数据结构·算法·leetcode·决策树·深度优先·剪枝
Jasmine_llq32 分钟前
《 火星人 》
算法·青少年编程·c#
Code哈哈笑35 分钟前
【Java 学习】深度剖析Java多态:从向上转型到向下转型,解锁动态绑定的奥秘,让代码更优雅灵活
java·开发语言·学习
闻缺陷则喜何志丹43 分钟前
【C++动态规划 图论】3243. 新增道路查询后的最短距离 I|1567
c++·算法·动态规划·力扣·图论·最短路·路径
Lenyiin1 小时前
01.02、判定是否互为字符重排
算法·leetcode
鸽鸽程序猿1 小时前
【算法】【优选算法】宽搜(BFS)中队列的使用
算法·宽度优先·队列
Jackey_Song_Odd1 小时前
C语言 单向链表反转问题
c语言·数据结构·算法·链表
Watermelo6171 小时前
详解js柯里化原理及用法,探究柯里化在Redux Selector 的场景模拟、构建复杂的数据流管道、优化深度嵌套函数中的精妙应用
开发语言·前端·javascript·算法·数据挖掘·数据分析·ecmascript
乐之者v1 小时前
leetCode43.字符串相乘
java·数据结构·算法