《LeetCode热题100》笔记题解思路技巧优化_Part_3

news2024/9/23 7:27:28

《LeetCode热题100》笔记&题解&思路&技巧&优化_Part_3

  • 😍😍😍 相知
  • 🙌🙌🙌 相识
  • 😢😢😢 开始刷题
    • 链表
      • 🟢1. 相交链表
      • 🟢2. 反转链表
      • 🟡3. 回文链表
      • 🟢4. 环形链表
      • 🟡5. 环形链表II
      • 🟢6. 并两个有序链表
      • 🟡7. 两数相加
      • 🟡8. 删除链表的倒数第N个结点
      • 🟡9. 两两交换链表中的节点
      • 🔴10. K个一组翻转链表
      • 🟡11. 随机链表的复制
      • 🟡12. 排序链表
      • 🔴13. 合并K个升序链表
      • 🟡14. LRU缓存

在这里插入图片描述

😍😍😍 相知

刷题不要一上来就直接干，先看题，明白题说的什么意思，然后想一下用什么现成的算法和数据结构可以快速解决，如果还是无从下手，建议先去看视频，不要直接翻评论或官方代码实现，看完视频，自己在idea中模拟敲几遍代码，如果跑通了，先别急着上leetcode黏贴，而是再回顾一下要点，然后确定自己完全懂了后，在leetcode中手敲，注意是手敲下来！！！ 目前我就是采用的这种方法，虽然慢，但是可以维持一周忘不掉它，如果要想长期不忘，只能隔段时间就review一下了，就算是大牛，知道方法，长时间不碰，也不可能保证一次到位把代码敲完一遍过！！！

🙌🙌🙌 相识

刷LeetCode热题100的想法有几个原因：

  1. 流行度高：LeetCode是一个广受欢迎的在线刷题平台，拥有大量用户和活跃的讨论社区。因此，热门题目通常代表了大多数人认为重要的题目或者面试中常见的题目。

  2. 面试备战：LeetCode上的题目往往和面试题目有很大的重合度。刷LeetCode热题100可以帮助你熟悉常见的面试题型和解题思路，提高应对面试的能力。

  3. 广泛的覆盖：热题100覆盖了各种难度级别的题目，包括简单、中等和困难。通过解答这些题目，可以提高自己的算法和编程能力，并扩展自己的知识面。

  4. 反馈和讨论：由于热题100是根据用户的反馈和讨论度排名的，因此这些题目往往有大量的解题思路和讨论可以参考。你可以从其他人的解题过程中学习到很多知识和技巧。

😢😢😢 开始刷题

链表

🟢1. 相交链表

题目链接：https://leetcode.cn/problems/intersection-of-two-linked-lists/?envType=study-plan-v2&envId=top-100-liked
在这里插入图片描述
我们需要做的事情是，让两个链表从同距离末尾同等距离的位置开始遍历。这个位置只能是较短链表的头结点位置。
为此，我们必须消除两个链表的长度差

  1. 指针 pA 指向 A 链表，指针 pB 指向 B 链表，依次往后遍历
  2. 如果 pA 到了末尾，则 pA = headB 继续遍历
  3. 如果 pB 到了末尾，则 pB = headA 继续遍历
  4. 比较长的链表指针指向较短链表head时，长度差就消除了
  5. 如此，只需要将最短链表遍历两次即可找到位置

在这里插入图片描述

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA==null||headB==null)return null;
        ListNode tempA = headA;
        ListNode tempB = headB;
        while(tempA!=tempB){
            tempA = tempA==null?headB:tempA.next;
            tempB = tempB==null?headA:tempB.next; 
        }
        return tempA;
    }
}

🟢2. 反转链表

题目链接：https://leetcode.cn/problems/reverse-linked-list/?envType=study-plan-v2&envId=top-100-liked

头插法！
在这里插入图片描述

/**
 * 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||head.next == null) return head;
        ListNode result = new ListNode(0);
        result.next = null;
        while(head!=null){
            ListNode tempafter = result.next;
            ListNode headtemp = head;
            head = head.next;
            headtemp.next = tempafter;
            result.next = headtemp;
        }
        return result.next;
        



    }
}

🟡3. 回文链表

题目链接：https://leetcode.cn/problems/palindrome-linked-list/?envType=study-plan-v2&envId=top-100-liked

利用栈的反转功能
遍历两次，填充1次，对比一次即可

class Solution {
    public boolean isPalindrome(ListNode head) {
        Stack<Integer> stack=new Stack<Integer>();
        ListNode cur=head;
        while(cur!=null){
            stack.push(cur.val);
            cur=cur.next;
        }
        while(head!=null){
            if(stack.pop()!=head.val)
                return false;
            head=head.next;
        }
        return true;
    }
}

🟢4. 环形链表

题目链接：https://leetcode.cn/problems/linked-list-cycle/description/?envType=study-plan-v2&envId=top-100-liked

利用快慢指针

如果有环总有一天会遇到！

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

🟡5. 环形链表II

题目链接：https://leetcode.cn/problems/linked-list-cycle-ii/description/?envType=study-plan-v2&envId=top-100-liked

双指针的第一次相遇：
设两指针 fast，slow 指向链表头部 head 。
令 fast 每轮走 2 步，slow 每轮走 1 步。
执行以上两步后，可能出现两种结果：

  • 第一种结果： fast 指针走过链表末端，说明链表无环，此时直接返回 null。

如果链表存在环，则双指针一定会相遇。因为每走 1 轮，fast 与 slow 的间距 +1，fast 一定会追上 slow 。

第二种结果： 当fast == slow时， 两指针在环中第一次相遇。下面分析此时 fast 与 slow 走过的步数关系：

设链表共有 a+b 个节点，其中 链表头部到链表入口 有 aaa 个节点（不计链表入口节点）， 链表环 有 b 个节点（这里需要注意，aaa 和 bbb 是未知数，例如图解上链表 a=4 , b=5）；设两指针分别走了 fff，sss 步，则有：

fast 走的步数是 slow 步数的 2 倍，即 f = 2s；（解析： fast 每轮走 2 步）
fast 比 slow 多走了 nnn 个环的长度，即 f = s + nb；（ 解析： 双指针都走过 a 步，然后在环内绕圈直到重合，重合时 fast 比 slow 多走 环的长度整数倍 ）。
将以上两式相减得到f = 2nb，s = nb，即 fast 和 slow 指针分别走了 2n，n 个环的周长。

接下来该怎么做呢？

如果让指针从链表头部一直向前走并统计步数k，那么所有 走到链表入口节点时的步数 是：k=a+nb ，即先走 aaa 步到入口节点，之后每绕 1 圈环（ b 步）都会再次到入口节点。而目前 slow 指针走了 nb 步。因此，我们只要想办法让 slow 再走 a 步停下来，就可以到环的入口。

但是我们不知道 a 的值，该怎么办？依然是使用双指针法。考虑构建一个指针，此指针需要有以下性质：此指针和 slow 一起向前走 a 步后，两者在入口节点重合。那么从哪里走到入口节点需要 a 步？答案是链表头节点head。

双指针第二次相遇：
令 fast 重新指向链表头部节点。此时 f=0，s=nb 。
slow 和 fast 同时每轮向前走 1 步。
当 fast 指针走到 f=a 步时，slow 指针走到 s=a+nb 步。此时两指针重合，并同时指向链表环入口，返回 slow 指向的节点即可。

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

🟢6. 并两个有序链表

题目链接：https://leetcode.cn/problems/merge-two-sorted-lists/description/?envType=study-plan-v2&envId=top-100-liked

递归法

/**
 * 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;
        if(list1.val<list2.val){
            list1.next = mergeTwoLists(list1.next,list2);
            return list1;
        }
        else{
            list2.next = mergeTwoLists(list1,list2.next);
            return list2;
        }
        
    }
}

🟡7. 两数相加

题目链接：https://leetcode.cn/problems/add-two-numbers/?envType=study-plan-v2&envId=top-100-liked

利用进位节点。逐层相加，更新进位 而且要考虑进位不为零，2个链表不一样长等情况

/**
 * 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) {
        int jinwei = 0;
        ListNode temp = new ListNode(0);
        ListNode temp1 = l1;
        ListNode temp2 = l2;
        ListNode result = temp;
        while(temp1!=null|temp2!=null||jinwei!=0){
            int a = temp1==null?0:temp1.val;
            int b = temp2==null?0:temp2.val;
            ListNode arr = new ListNode((a+b+jinwei)%10);
            temp.next= arr;
            temp = temp.next;
            jinwei = (a+b+jinwei)/10;
            temp1 = temp1==null?temp1:temp1.next;
            temp2 = temp2==null?temp2:temp2.next;
        }
        return result.next;
        


    }
}

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

题目链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/?envType=study-plan-v2&envId=top-100-liked

双指针

/**
 * 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) {
        ListNode result = head;
        ListNode slow = head;
        ListNode fast = 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;
    }
}

🟡9. 两两交换链表中的节点

题目链接：https://leetcode.cn/problems/swap-nodes-in-pairs/?envType=study-plan-v2&envId=top-100-liked

/**
 * 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 result= new ListNode(0);
        ListNode temp = result;
        ListNode slow = head;
        while(slow!=null&&slow.next!=null){
            temp.next = slow.next;
            slow.next = slow.next.next;
            temp.next.next = slow;

            temp = temp.next.next;
            slow = slow.next;

        }
        return result.next;

    }
}

🔴10. K个一组翻转链表

题目链接：https://leetcode.cn/problems/reverse-nodes-in-k-group/description/?envType=study-plan-v2&envId=top-100-liked

/**
 * 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 reverseKGroup(ListNode head, int k) {
        ListNode post = head;
        for(int i  = 0;i<k;i++){
            if(post==null)return head;
            post = post.next;
        }
        ListNode pre = null;
        ListNode cur = head;
        while(cur!=post){
            ListNode temp = cur.next;
            cur.next= pre;
            pre = cur;
            cur = temp;
        }
        head.next = reverseKGroup(cur,k);
        return pre;
    }
    
}

🟡11. 随机链表的复制

题目链接：https://leetcode.cn/problems/copy-list-with-random-pointer/?envType=study-plan-v2&envId=top-100-liked

/*
// 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) {
        Node temp = head;
        HashMap <Node,Node> hashmap = new HashMap<>();
        while(temp!=null){
            hashmap.put(temp,new Node(temp.val));
            temp = temp.next;
        }
        temp = head;
        while(temp!=null){
            hashmap.get(temp).next = hashmap.get(temp.next);
            hashmap.get(temp).random = hashmap.get(temp.random);
            temp = temp.next;
        }
        return hashmap.get(head);

    }
}

🟡12. 排序链表

题目链接：https://leetcode.cn/problems/sort-list/description/?envType=study-plan-v2&envId=top-100-liked

/**
 * 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) {
        return head==null?head:mergesort(head);
    }
    public ListNode mergesort(ListNode head){
        if(head==null||head.next == null) return head;
        ListNode slow = head;
        ListNode fast = head;
        ListNode pre = null;
        while(fast!=null&&fast.next!=null){
            pre = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        pre.next = null;
        ListNode l = mergesort(head);
        ListNode r = mergesort(slow);
        return mergeTwoLists(l, r);
    } 
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1==null)return list2;
        if(list2==null)return list1;
        if(list1.val<list2.val){
            list1.next = mergeTwoLists(list1.next,list2);
            return list1;
        }
        else{
            list2.next = mergeTwoLists(list1,list2.next);
            return list2;
        }
        
    }
}

🔴13. 合并K个升序链表

题目链接：https://leetcode.cn/problems/merge-k-sorted-lists/?envType=study-plan-v2&envId=top-100-liked

/**
 * 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) {
        if(lists.length==0||(lists.length==1&&lists[0]==null))return null;
        ListNode result = lists[0];
        for(int i= 1;i<lists.length;i++){
            result = mergeTwoLists(result,lists[i]);
        }
        return result;
        
    }
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1==null)return list2;
        if(list2==null)return list1;
        if(list1.val<list2.val){
            list1.next = mergeTwoLists(list1.next,list2);
            return list1;
        }
        else{
            list2.next = mergeTwoLists(list1,list2.next);
            return list2;
        }
        
    }
}

🟡14. LRU缓存

题目链接：https://leetcode.cn/problems/lru-cache/description/?envType=study-plan-v2&envId=top-100-liked

class LRUCache {
    private int cap;
    private Map<Integer, Integer> map = new LinkedHashMap<>();
    public LRUCache(int capacity) {
        this.cap = capacity;
    }
    
    public int get(int key) {
        if (map.containsKey(key)) {
            int val = map.get(key);
            map.remove(key);
            map.put(key,val);
            return val;
        }
        return -1;
    }
    
    public void put(int key, int value) {
        if (map.containsKey(key)) {
            map.remove(key);
        }else if (map.size() == cap){
            Iterator<Map.Entry<Integer, Integer>> iterator = map.entrySet().iterator();
            iterator.next();
            iterator.remove();
        }
        map.put(key,value);
    }
}

/**
 * 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);
 */

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1518402.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

html5cssjs代码 020 推荐网址

html5cssjs代码 020 推荐网址

html5&css&js代码 020 推荐网址 一、代码二、解释 这段HTML代码定义了一个网页&#xff0c;它包含了一个标题、一些样式和一个表格。表格中列出了一些推荐的网址&#xff0c;包括序号、名称、网址、描述和备注。每个表格行都包含一个链接到相应网址的超链接。页面的样式…
阅读更多...
一种基于宏和serde_json实现的rust web中统一返回类

一种基于宏和serde_json实现的rust web中统一返回类

本人rust萌新&#xff0c;写web碰到了这个&#xff0c;基于ChatGPT和文心一言学了宏&#xff0c;强行把这玩意实现出来了&#xff0c;做个学习记录&#xff0c;如果有更好的方法&#xff0c;勿喷。 先看效果&#xff0c;注意不支持嵌套&#xff0c;且kv映射要用>(因为它这个…
阅读更多...
《JAVA与模式》之抽象工厂模式

《JAVA与模式》之抽象工厂模式

系列文章目录 文章目录 系列文章目录前言一、使用简单工厂模式的解决方案二、引进抽象工厂模式三、抽象工厂模式结构四、抽象工厂模式的优缺点前言 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站，这篇文章男女通用，看…
阅读更多...
MC78L05ACDR2G线性稳压器芯片中文资料规格书PDF数据手册引脚图参数图片价格

MC78L05ACDR2G线性稳压器芯片中文资料规格书PDF数据手册引脚图参数图片价格

产品概述&#xff1a; MC78L00A系列线性稳压器价格便宜&#xff0c;易于使用&#xff0c;适用于各种需要最高100mA的调节电源的应用。与大功率MC7800和MC78M00系列一样&#xff0c;这款稳压器也提供内部电流限制和高温关断&#xff0c;因此非常坚固耐用。在很多应用中&#xf…
阅读更多...
提高工作效率，这 10 款 AI 工具不能错过

提高工作效率，这 10 款 AI 工具不能错过

作为一个职场打工人&#xff0c;我深知时间和效率的重要性。正是因为如此&#xff0c;我开始使用各种人工智能工具来帮助我提高工作效率。在这篇文章中&#xff0c;我将会分享 10 款必备的 AI 工具&#xff0c;这些工具可以让你的工作更加高效&#xff0c;从而为你节省更多的时…
阅读更多...
windows 11访问Debian10上的共享目录

windows 11访问Debian10上的共享目录

步骤 要在Windows 11上访问Debian 10.0.0的共享目录&#xff0c;可以通过以下步骤来实现&#xff1a; 1. 设置Samba服务&#xff1a;在Debian系统上&#xff0c;需要安装并配置Samba服务&#xff0c;以便能够实现文件夹共享。Samba是一个允许Linux/Unix服务器与Windows操作系…
阅读更多...
Windows系统搭建Cloudreve结合内网穿透打造可公网访问的私有云盘

Windows系统搭建Cloudreve结合内网穿透打造可公网访问的私有云盘

目录 ⛳️推荐 1、前言 2、本地网站搭建 2.1 环境使用 2.2 支持组件选择 2.3 网页安装 2.4 测试和使用 2.5 问题解决 3、本地网页发布 3.1 cpolar云端设置 3.2 cpolar本地设置 4、公网访问测试 5、结语 ⛳️推荐 前些天发现了一个巨牛的人工智能学习网站&#xff…
阅读更多...
C#，数值计算，数据测试用的对称正定矩阵（Symmetric Positive Definite Matrix）的随机生成算法与源代码

C#，数值计算，数据测试用的对称正定矩阵（Symmetric Positive Definite Matrix）的随机生成算法与源代码

C.Hermite 1、对称矩阵 对称矩阵（Symmetric Matrices）是指以主对角线为对称轴，各元素对应相等的矩阵。在线性代数中，对称矩阵是一个方形矩阵，其转置矩阵和自身相等。1855年，埃米特(C.Hermite,1822-1901年)证明了别的数学家发现的一些矩阵类的特征根的特殊性质，如称为埃…
阅读更多...
AI智能电话机器人的核心技术是什么？

AI智能电话机器人的核心技术是什么？

电话机器人是近几年兴起的人工智能产品&#xff0c;它主要通过电话群呼潜在客户&#xff0c;沟通进行信息筛选&#xff0c;帮助企业选择意向客户。企业使用电话机器人可以减少人工成本&#xff0c;提高工作效率。我们一起来看看智能电话机器人的核心技术是什么&#xff1f; 电话…
阅读更多...
Tengine编译安装

Tengine编译安装

首先下载源码 可以去官网&#xff1a;The Tengine Web Server 当前最新版地址&#xff1a;https://tengine.taobao.org/download/tengine-3.1.0.tar.gz 安装编译依赖 yum -y install gcc pcre-devel zlib-devel openssl-devel libxml2-devel \libxslt-devel gd-devel GeoIP…
阅读更多...
安装linux_centos7虚拟机_开启网络_ssh_防火墙

安装linux_centos7虚拟机_开启网络_ssh_防火墙

文章目录 安装linux_centos7虚拟机_开启网络_ssh_防火墙安装centos7虚拟机1. 进入VMware --> 点击文件 --> 新建虚拟机2. 选择典型 --> 选择下一步3. 选择--> 稍后安装操作系统4. 选择--> Linux --> CentOS 7 64位5. 在虚拟机名称输入(虚拟机名) --> 选择…
阅读更多...
一条 SQL 更新语句如何执行的

一条 SQL 更新语句如何执行的

Server 层 存储引擎层 总流程 查询语句 连接器 查询缓存 分析器 优化器 执行器 更新语句 redo log&#xff08;节省的是随机写磁盘的 IO 消耗&#xff08;转成顺序写&#x…
阅读更多...
windows达梦安装

windows达梦安装

1.首先准备好windows安装系统&#xff0c;准备工作的做好&#xff0c;然后把素材包dm8_20230418_x86_win_64放进去&#xff0c;进行解压 解压完成之后&#xff0c;把dm8_20230418_x86_win_64再次进行解压&#xff0c;然后点击安装setup进行安装 然后点击接受进行下一步&#xf…
阅读更多...
网络安全msf学习1

网络安全msf学习1

工具&#xff1a;netcat 用途 &#xff1a;端口连接、数据提交 工具nmap 用途&#xff1a;端口扫描、服务识别、操作系统指纹识别 工具 httprint 用途&#xff1a;通过远程http指纹判断http服务类型 工具&#xff1a; tamper ie 用途&#xff1a; http数据包修改、转发工…
阅读更多...
直方图及数据95%置信区间及特征筛选

直方图及数据95%置信区间及特征筛选

rm(list ls()) library(Rmisc) library(ggplot2) library(dplyr)data <- iris x<-iris$Sepal.Length #求置信区间方法1## confidence_interval <- t.test(x)$conf.int print(confidence_interval) #[1] 5.709732 5.976934 #attr(,"conf.level") #[1] 0.95#…
阅读更多...
翻转时钟效果

翻转时钟效果

时分秒三个部分结构功能完全一致&#xff0c;均有四块构成&#xff0c;上下各两块。 正面可见&#xff0c;背面不可见&#xff0c;同时需要调整翻转过程中的z-index。 初始状态card2为已经翻转状态。 calendar.html <!DOCTYPE html> <html lang"en">&…
阅读更多...
Excel第26享：模糊查找之Hlookup函数与通配符的嵌套

Excel第26享：模糊查找之Hlookup函数与通配符的嵌套

1、需求描述 如下图所示&#xff0c;现第一行有三个参考值&#xff1a;人S、羊E、猪3&#xff0c;在第三行有5个字&#xff1a;马、牛、人、羊、猪&#xff0c;每个字如果出现在第一行的三个参考值中&#xff0c;就返回该单元格的数值。如&#xff0c;人&#xff0c;就返回“人…
阅读更多...
unicloud update 修改

unicloud update 修改

update 修改 使用腾讯云时更新方法必须搭配doc、where方法使用&#xff0c;db.collection(‘test’).update()会报如下错误&#xff1a;param should have required property ‘query’ collection.doc().update(Object data)未使用set、remove更新操作符的情况下&#xff0c…
阅读更多...
vue：功能：table动态合并+前端导出

vue：功能：table动态合并+前端导出

场景&#xff1a;第一列WM 名字相同&#xff0c;行内合并&#xff0c;后面的列合并的行数根据第一列合并的行来。第二列‘累计请假天数根据合并的几列显示数值。后续需合并的列以第一列合并行数为基准 注&#xff09;当前数据表头固定&#xff0c;行内数据不固定。以第一列WM为…
阅读更多...
主板维修一般多少钱？电脑主板常见维修方法交换法

主板维修一般多少钱？电脑主板常见维修方法交换法

修主板一般要多少钱&#xff1f; 下面就让我们一起来了解一下吧。 电脑主板维修价格根据损坏程度不同而不同 1、电容器最容易损坏。 如果只是更换电容的话&#xff0c;大约需要50元左右。 2、如果主板上的电路损坏&#xff0c;面积越大&#xff0c;价格就越贵&#xff0c;可…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023