【算法系列篇】与链表相关的算法

news2024/10/7 10:16:55

在这里插入图片描述

文章目录

  • 前言
  • 1. 两数相加
    • 1.1 题目要求
    • 1.2 做题思路
    • 1.3 Java代码实现
  • 2. 两两交换链表中的节点
    • 2.1 题目要求
    • 2.2 做题思路
    • 2.3 Java代码实现
  • 3. 重排链表
    • 3.1 题目要求
    • 3.2 做题思路
    • 3.3 Java代码实现
  • 4. 合并 k 个升序链表
    • 4.1 题目要求
    • 4.2.1 做题思路一
    • 4.3.1 方法一Java代码实现
    • 4.2.2 做题思路二
    • 4.3.2 方法二Java代码实现
  • 5. k 个一组翻转链表
    • 5.1 题目要求
    • 5.2 做题思路
    • 5.3 Java代码实现
  • 总结

前言

链表是我们在日常生活中使用较为广泛的一种数据结构，链表因为其可扩展性高和方便插入、删除的特性在一些领域发挥着很大的作用。但是因为链表独特的结构，在内存上的逻辑连续而不是物理连续的特性，也使得当一些算法的作用对象是链表的时候就有些许的差别，那么今天我将为大家分享关于链表的一些常用算法。

在这里插入图片描述

1. 两数相加

https://leetcode.cn/problems/add-two-numbers/?envType=list&envId=9Lulrn6r

1.1 题目要求

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：
在这里插入图片描述

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：

每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零

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

    }
}

1.2 做题思路

这个题目用的就是模拟算法的思路，就像平时我们加法一样，将两个数从个位开始相加，并且注意有没有进位，一直加到最后一位就可以了。这道题目给的链表是倒序的，所以我们可以直接从链表的头结点开始相加，用一个变量来记住进位，每次相同位相加然后再加上这个进位就得到了该位的相加结果。

在这里插入图片描述
当某一个链表提前到达尾部的时候，我们不停止相加，而是将这个为null的节点当作0与另一个节点相加，并且还需要注意的是，当两个链表都到达尾部的时候，如果进位不为0的话，就还需要创建一个节点记录这个进位。

1.3 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 addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode head = new ListNode();
        ListNode cur = head;
        int t = 0; //用来表示进位
        while(l1 != null || l2 != null || t != 0) {
            int sum = (l1 == null ? 0 : l1.val) + (l2 == null ? 0 : l2.val) + t;
            ListNode node = new ListNode(sum % 10);
            cur.next = node;
            cur = cur.next;
            t = sum / 10;

            l1 = (l1 == null ? null : l1.next);
            l2 = (l2 == null ? null : l2.next);
        }

        return head.next;
    }
}

在这里插入图片描述
这里为什么会选择创建一个head节点呢？这个节点类似于一个哨兵位，有了这个哨兵位就可以减少当返回的链表头结点为空时的判断。做链表相关的题目的时候，我们不要吝啬内存空间，通过创建额外的节点，可以省去很多不必要的麻烦。
在这里插入图片描述

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

https://leetcode.cn/problems/swap-nodes-in-pairs/?envType=list&envId=9Lulrn6r

2.1 题目要求

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：
在这里插入图片描述

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

提示：

链表中节点的数目在范围 [0, 100] 内
0 <= Node.val <= 100

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

    }
}

2.2 做题思路

这道题目每两个相邻的节点进行交换去，而不是整个链表的逆序，所以每次交换的时候就需要知道交换的是哪两个节点，并且还需要记住这两个节点的后一个节点，否则当我们交换完成之后，就不知道后面节点的内容了。
在这里插入图片描述

2.3 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 swapPairs(ListNode head) {
        if(head == null || head.next == null) return head;
        ListNode newHead = new ListNode();
        ListNode prev = newHead, cur = head, next = head.next, nnext = next.next;
        //当链表的节点数为偶数的时候，循环结束的条件就是cur为null；
        //如果节点数为奇数的时候，循环结束的条件是next为null
        while(cur != null && next != null) {
            //交换相邻两个链表
            prev.next = next;
            next.next = cur;
            cur.next = nnext;

            //更新prev cur next 和nnext的信息
            prev = cur;
            cur = nnext;
            if(cur != null) next = cur.next;
            if(next != null) nnext = next.next;
        }

        return newHead.next;
    }
}

在这里插入图片描述

3. 重排链表

https://leetcode.cn/problems/reorder-list/?envType=list&envId=9Lulrn6r

3.1 题目要求

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln - 1 → Ln

请将其重新排列后变为：

L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …

不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1：

在这里插入图片描述

输入：head = [1,2,3,4]
输出：[1,4,2,3]

示例 2：

在这里插入图片描述

输入：head = [1,2,3,4,5]
输出：[1,5,2,4,3]

提示：

链表的长度范围为 [1, 5 * 104]
1 <= node.val <= 1000

/**
 * 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 void reorderList(ListNode head) {

    }
}

3.2 做题思路

根据题目的意思：需要将链表 L0 → L1 → … → Ln - 1 → Ln 重排列为 L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …，也就是第一个节点后面跟最后一个节点、然后最后一个节点后面跟第二个节点、第二个节点后面跟倒数第二个节点……但是用代码该怎么解决呢？因为链表在内存中的位置是随机的，我们不能够实现对链表的随机访问，那么该如何访问到第一个节点和最后一个节点并且同时还能记住第二个节点的位置呢？

我们可以将链表的后半部分给倒序，然后在前半部分的两个节点之间依次插入后半部分的每个节点。

在这里插入图片描述

3.3 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 void reorderList(ListNode head) {
        //1.找到链表的中间节点
        ListNode slow = head, fast = head, thead = head;
        while(fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }

        //将前半部分的最后一个节点的next置为null，防止出现环
        ListNode tmp = slow.next;
        slow.next = null;
        slow = tmp;
        
        //2.翻转slow后面部分的链表
        fast = null;
        while(slow != null) {
            ListNode next = slow.next;
            slow.next = fast;
            fast = slow;
            slow = next;
        }
        
        //3.将后半部分的链表依次加入到前半部分的两个节点之间
        slow = fast; //将slow更改为后半部分倒置后链表的第一个节点
        ListNode cur = thead;
        while(slow != null) {
            ListNode nextCur = cur.next, nextSlow = slow.next;
            slow.next = nextCur;
            cur.next = slow;
            cur = nextCur;
            slow = nextSlow;
        }
    }
}

在这里插入图片描述

这里为什么会选择翻转slow后面的部分，而不是从slow开始的后面的链表翻转呢？从slow开始到后面的链表部分翻转是可以的，但是这样会导致前半部分的链表长度短于后半部分，要想不丢失节点，就需要做出额外的判断。
在这里插入图片描述

4. 合并 k 个升序链表

https://leetcode.cn/problems/vvXgSW/?envType=list&envId=9Lulrn6r

4.1 题目要求

给定一个链表数组，每个链表都已经按升序排列。

请将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
 1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

提示：

k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4

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

    }
}

4.2.1 做题思路一

这个题目要求是合并 k 个升序链表，跟合并两个升序链表是类似的，但是如果我们单纯使用合并两个升序链表的方法来解决这个 k 个升序链表的话，时间复杂度是比较高的，那么是否有办法可以降低时间复杂度呢？

这道题目有两个方法可以降低时间复杂度：

  1. 使用优先级队列。创建一个小根堆，先将每个链表的头结点放入优先级队列中，然后取出堆顶的节点（堆顶的节点就是当前堆中所有元素中最小的），因为链表是升序排列的，所以第一个取出的就是所有链表中最小的元素，然后取出的这个节点属于哪个链表，就继续将该链表的下一个节点放入优先级队列中，继续该操作。

在这里插入图片描述

4.3.1 方法一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) {
        PriorityQueue<ListNode> heap = new PriorityQueue<>((v1, v2) -> v1.val - v2.val);
        //将每个链表的头节点放入优先级队列中
        for(ListNode l : lists) {
            if(l != null) {
                heap.offer(l);
            }
        }

        ListNode ret = new ListNode();
        ListNode cur = ret;
        while(!heap.isEmpty()) {
            //将堆顶的节点添加到返回链表中
            ListNode tmp = heap.poll();
            ListNode node = new ListNode(tmp.val);
            cur.next = node;
            cur = cur.next;
            //插入取出链表的下一个节点
            if(tmp.next != null) heap.offer(tmp.next);
        }

        return ret.next;
    }
}

在这里插入图片描述

4.2.2 做题思路二

因为前面我们知道如何合并两个有序的升序链表，但是如果使用暴力解法合并两个链表的话，时间复杂度会很高，那么我们是否有方法还是使用合并两个有序链表的思想，但是时间复杂度不至于很高的方法呢？也就是说如何用合并两个升序链表的方法合并 k 个升序链表呢？当然是有的，这种思想就是将大事化小的思想，而归并的思想也正是将大事化小，所以这个题的第二种方法就是使用归并的方法解决。

在这里插入图片描述

4.3.2 方法二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) {
        return merge(lists, 0 ,lists.length - 1);
    }

    private ListNode merge(ListNode[] lists, int left, int right) {
        //当left > right 的时候，说明传入的lists不和逻辑
        if(left > right) return null;
        //如果left == right，说明lists中只有一个链表，直接返回
        if(left == right) return lists[left]; 
        int mid = left + (right - left) / 2;

        //递归
        ListNode l1 = merge(lists, left, mid);
        ListNode l2 = merge(lists, mid  + 1, right);

        //合并连个有序链表
        return mergeTwoLists(l1,l2);
    }

    private ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null) return l2;
        if(l2 == null) return l1;

        ListNode head = new ListNode();
        ListNode cur = head; 
        while(l1 != null && l2 != null) {
            if(l1.val < l2.val) {
                cur.next = l1;
                l1 = l1.next;
            }else {
                cur.next = l2;
                l2 = l2.next;
            }
            cur = cur.next;
        }

        if(l1 != null) cur.next = l1;
        if(l2 != null) cur.next = l2;

        return head.next;
    }
}

在这里插入图片描述

5. k 个一组翻转链表

https://leetcode.cn/problems/reverse-nodes-in-k-group/

5.1 题目要求

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：
在这里插入图片描述

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

示例 2：
在这里插入图片描述

输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]

提示：

链表中的节点数目为 n
1 <= k <= n <= 5000
0 <= Node.val <= 1000

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

    }
}

进阶：你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？

5.2 做题思路

这道题目的要求是 k 个一组翻转链表，其实本质上还是翻转链表，只是将一个链表分成了 n 组，每组 k 个节点进行翻转。那么我们可以先求出要翻转多少组链表，然后每一组进行翻转链表的操作。
在这里插入图片描述

5.3 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 reverseKGroup(ListNode head, int k) {
        //1.统计出需要翻转多少组

        //先预处理一遍，统计出链表节点的个数
        int n = 0;
        ListNode cur = head;
        while(cur != null) {
            n++;
            cur = cur.next;
        }
        n /= k;  //n就是需要翻转的组数

        //翻转这n组链表
        ListNode newHead = new ListNode();
        ListNode prev = newHead;
        cur = head;
        for(int i = 0; i < n; i++) {
            ListNode tmp = cur;
            //每组翻转 k 个节点
            for(int j = 0; j < k; j++) {
                ListNode next = cur.next;
                cur.next = prev.next;
                prev.next = cur;
                cur = next;
            }
            //当翻转完成一组之后，将prev更新为翻转完成之后的最后一个节点
            prev = tmp;
        }

        prev.next = cur;
        return newHead.next;
    }
}

在这里插入图片描述

总结

在做链表相关的算法题的时候，我们不要吝啬空间的浪费，额外创建一个虚拟节点可以省去很多不必要的麻烦；因为链表的内存的随机的而不是连续的，所以需要注意保存下一个节点的位置，否则就是导致后面部分的节点丢失。

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

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

相关文章

将yolo格式数据集转换为VOC格式

将yolo格式数据集转换为VOC格式

将yolo格式数据集转换为VOC格式 背景代码 由于需要切分图象&#xff0c;将yolo转换为voc格式好处理一些 背景 代码 import xml.dom.minidom import glob from PIL import Image from math import ceil import shutil import osyolo_file rE://黄花标注//glass//train//split…
阅读更多...
Ubuntu 23.10 支持基于 TPM 的全磁盘加密

Ubuntu 23.10 支持基于 TPM 的全磁盘加密

导读即将发布的 Ubuntu23.10 增加了一项实验性功能 —— 初步支持基于 TPM 的全磁盘加密。该功能利用系统的可信平台模块 (TPM)&#xff0c;缺点是这种额外的安全性依赖于 Snaps&#xff0c;包括内核和 GRUB 引导加载器。 Ubuntu 开发商 Canonical 公司表示&#xff0c;Ubuntu…
阅读更多...
字节一面：说说HTTP 常见的状态码有哪些，适用场景？

字节一面：说说HTTP 常见的状态码有哪些，适用场景？

前言 最近博主在字节面试中遇到这样一个面试题&#xff0c;这个问题也是前端面试的高频问题&#xff0c;我们经常与网路请求打交道&#xff0c;与http打交道&#xff0c;也会根据返回的状态码来做出不同逻辑判断&#xff0c;所以作为一个前端工程师必须要深入掌握这个知识点&am…
阅读更多...
B2901A 是德科技keysight精密型电源

B2901A 是德科技keysight精密型电源

181/2461/8938Agilent B2901A精密源/测量单元(SMU)是一款单通道、紧凑且经济高效的台式SMU&#xff0c;能够采集和测量电压和电流。它功能多样&#xff0c;可以轻松、高精度地执行I/V(电流与电压)测量。四象限源和测量功能的集成使I/V测量简单易行&#xff0c;无需配置多种仪器…
阅读更多...
​我读《乡村振兴战略下传统村落文化旅游设计》许少辉八一新书

​我读《乡村振兴战略下传统村落文化旅游设计》许少辉八一新书

​我读《乡村振兴战略下传统村落文化旅游设计》许少辉八一新书 ​我读《乡村振兴战略下传统村落文化旅游设计》许少辉八一新书
阅读更多...
系统工程知识体系（SEBoK）

系统工程知识体系（SEBoK）

介绍 《系统工程知识体系》&#xff08;SEBoK&#xff09;是以一种理念设计的&#xff0c;即如果工程师有一个实时更新、实用的指南&#xff0c;他们就能做出更优秀的工作。如果你以前没有使用过这个资源&#xff0c;也没有关系&#xff1b;因为已经有一个完整的指南供你参考&…
阅读更多...
表白墙案例（前端，Java，Mysql）

表白墙案例（前端，Java，Mysql）

项目展示&#xff1a; 在输入框中输入内容&#xff0c;点击提交&#xff0c;便会在下面以字符串的形式展示出来&#xff0c;并且会将数据保存到数据库中 即使服务器重启&#xff0c;下次再打开表白墙页面&#xff0c;也能够从数据库中获取到之前的数据 使用到的相关技术 前端(…
阅读更多...
网页标签在html中的显示+单标记换行操作

网页标签在html中的显示+单标记换行操作

1&#xff0c;网页标签在html中的显示 我们在html的编写过程&#xff0c;经常会遇到设置网页title标签的问题&#xff0c;例如百度标签&#xff1b; 我们使用title来满足要求&#xff1b; <html><head><title>百度一下&#xff0c;你就知道</title>即…
阅读更多...
C++单例模式终极指南，深度解析不同应用场景，学单例这一篇就够了

C++单例模式终极指南，深度解析不同应用场景，学单例这一篇就够了

&#x1f4cb; 前言 &#x1f5b1; 博客主页&#xff1a;在下马农的碎碎念&#x1f917; 欢迎关注&#x1f50e;点赞&#x1f44d;收藏⭐️留言&#x1f4dd;✍ 本文由在下马农原创&#xff0c;首发于CSDN&#x1f4c6; 首发时间&#xff1a;2023/8/25&#x1f4c5; 最近更新时…
阅读更多...
引入嵌入和向量搜索时的三个错误

引入嵌入和向量搜索时的三个错误

将非结构化数据表示为嵌入向量以及使用向量搜索进行基于嵌入的检索 (embedding-based retrieval - EBR) 比以往任何时候都更加流行。 嵌入到底是什么&#xff1f; Roy Keyes 在《嵌入的最短定义&#xff1f;》中对此进行了很好的解释。 嵌入是学习的转换&#xff0c;使数据更有…
阅读更多...
C语言环境搭建(Win)

C语言环境搭建(Win)

一、C语言简介 1、 C语言简介 C语言是一门通用的、面向过程式的编译型语言&#xff0c;它的运行速度极快&#xff0c;仅次于汇编语言。 C语言是计算机产业的核心程序设计语言&#xff0c;操作系统、硬件驱动、关键组件、数据库等都离不开C语言&#xff0c;广泛应用于底层开发。…
阅读更多...
10CQRS

10CQRS

本系列包含以下文章&#xff1a; DDD入门DDD概念大白话战略设计代码工程结构请求处理流程聚合根与资源库实体与值对象应用服务与领域服务领域事件CQRS&#xff08;本文&#xff09; 案例项目介绍 # 既然DDD是“领域”驱动&#xff0c;那么我们便不能抛开业务而只讲技术&…
阅读更多...
SigFit—光-机-热耦合分析工具

SigFit—光-机-热耦合分析工具

美国Sigmadyne公司的SigFit软件是光机热耦合分析工具&#xff0c;可以将有限元分析得到的光学表面变形等结果文件通过多项式拟合或插值转化为光学分析软件的输入文件&#xff0c;还可实现动态响应分析、光程差分析、设计优化、主动控制/自适应控制光学系统的促动器布局及优化等…
阅读更多...
美篇作文网教学资源源码-自带作文数据

美篇作文网教学资源源码-自带作文数据

非常漂亮的UI设计和页面排版&#xff01; 自适应手机pc端 页面内容均支持自定义 可以用来做网站矩阵&#xff0c;或者增强你其他网站板块&#xff0c;或者单独运营都可以。 可以通过广告方式变现&#xff0c;或者引流等等 友好的seo&#xff0c;更容易被浏览器收录 关注青狐…
阅读更多...
软件测试面试题 —— 整理与解析（5）

软件测试面试题 —— 整理与解析（5）

&#x1f60f;作者简介&#xff1a;博主是一位测试管理者&#xff0c;同时也是一名对外企业兼职讲师。 &#x1f4e1;主页地址&#xff1a;【Austin_zhai】 &#x1f646;目的与景愿&#xff1a;旨在于能帮助更多的测试行业人员提升软硬技能&#xff0c;分享行业相关最新信息。…
阅读更多...
5153. 删除

5153. 删除

题目&#xff1a; 样例1&#xff1a; 输入 3454 输出 YES 344 样例2&#xff1a; 输入 10 输出 YES 0 样例3&#xff1a; 输入 111111 输出 NO 思路&#xff1a; 这道题就三个条件 关键条件是 能够被 8 整除。 而能被 8 整除的有一个重要的性质是 能够被 8 整除的重要…
阅读更多...
MySQL - 全表分组后，获取组内排序首条数据信息

MySQL - 全表分组后，获取组内排序首条数据信息

性能 不详!!! 不详!!! 不详!!! 请谨慎使用!!!环境 MySQL服务: 8.0版本;思路 使用8.0版本的新函数特性: row_number(): 序号函数; 顾名思义, 就是给每组中的元素从1开始按顺序加上序号;over(): 其中两个语法如下 partition: 按某字段分组;order by: 按某字段排序;注意: 两函数详…
阅读更多...
【深度学习实验】前馈神经网络（final）：自定义鸢尾花分类前馈神经网络模型并进行训练及评价

【深度学习实验】前馈神经网络（final）：自定义鸢尾花分类前馈神经网络模型并进行训练及评价

目录 一、实验介绍 二、实验环境 1. 配置虚拟环境 2. 库版本介绍 三、实验内容 0. 导入必要的工具包 1. 构建数据集&#xff08;IrisDataset&#xff09; 2. 构建模型&#xff08;FeedForward&#xff09; a. __init__(初始化) b. forward(前向传播) 3.整合训练、评估…
阅读更多...
Json文件反序列化读取

Json文件反序列化读取

Json文件 [{"name":"清华大学","location":"北京","grade":"1"},{"name":"北京大学","location":"北京","grade":"2"} ] 安装包 代码 Program.c…
阅读更多...
Redis应用（8）——Redis的项目应用：结合SpringBoot如何在Redis里面存对象 RedisUtil工具类的封装 遇到的问题

Redis应用（8）——Redis的项目应用：结合SpringBoot如何在Redis里面存对象 RedisUtil工具类的封装 遇到的问题

前言 Redis作为一款优秀的开源、高效的内存数据库&#xff0c;在各种项目中都能见到其身影&#xff0c;熟练使用Redis是程序员必备的技能之一。本系列博客结合应用场景&#xff0c;阐述Redis从安装到使用的&#xff0c;从入门到进阶的相关内容。 本篇博客介绍在Spring项目中&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023