代码随想录-Day49

news2024/9/22 13:39:06

300. 最长递增子序列

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的
子序列
。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。
示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4
示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1
在这里插入图片描述

class Solution {
    public int lengthOfLIS(int[] nums) {
        if (nums.length <= 1) return nums.length;
        int[] dp = new int[nums.length];
        int res = 1;
        Arrays.fill(dp, 1);
        for (int i = 1; i < dp.length; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

这段代码是用于解决「最长递增子序列」(Longest Increasing Subsequence, LIS)问题的Java实现。给定一个整数数组 nums，目标是找到其中最长的严格递增子序列的长度。这里所说的子序列是指原序列中删除一些或不删除元素且保持剩余元素的相对顺序不变形成的序列。

代码解析

  1. 边界情况处理:

    • 如果 nums 的长度小于等于1，那么最长递增子序列的长度就是数组的长度本身，因为单个元素或空数组本身就是递增的。

  2. 初始化动态规划数组:

    • 创建一个与 nums 长度相等的数组 dp，其中 dp[i] 代表以 nums[i] 结尾的最长递增子序列的长度。初始化 dp 数组的所有元素为1，因为至少每个元素自身都可以构成长度为1的递增子序列。

  3. 动态规划迭代:

    • 从数组的第二个元素开始迭代，对于每一个元素 nums[i]（从索引1开始），遍历其前面的所有元素 nums[j]（从索引0到 i-1）。
    • 如果当前元素 nums[i] 大于前面的某个元素 nums[j]，那么可以尝试构建一个新的递增子序列，其长度为以 nums[j] 结尾的最长递增子序列的长度加1，即 dp[j] + 1。
    • 更新 dp[i] 为所有可能的递增子序列长度中的最大值，这确保了 dp[i] 始终保存的是以 nums[i] 结尾的最长递增子序列的长度。

  4. 记录结果:

    • 在每次更新 dp[i] 后，同时更新全局最大值 res，以确保在整个迭代过程中始终保存最长递增子序列的长度。

  5. 返回结果:

    • 最后返回 res，即整个数组中的最长递增子序列的长度。

时间复杂度和空间复杂度

  • 时间复杂度: O(n^2)，其中 n 是数组 nums 的长度。这是因为对于数组中的每个元素，都需要遍历其前面的所有元素来计算最长递增子序列的长度。
  • 空间复杂度: O(n)，需要一个长度为 n 的动态规划数组 dp 来存储中间结果。

总结

这段代码通过动态规划的方法，有效地解决了最长递增子序列问题。尽管时间复杂度为 O(n^2)，但在许多实际应用场景中，这样的性能通常是可接受的。如果需要更高效的算法（如 O(n log n) 的时间复杂度），则可以采用更复杂的算法，例如结合二分查找的优化版本。

674. 最长连续递增序列

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], …, nums[r - 1], nums[r]] 就是连续递增子序列。

示例 1：

输入：nums = [1,3,5,4,7]
输出：3
解释：最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。
示例 2：

输入：nums = [2,2,2,2,2]
输出：1
解释：最长连续递增序列是 [2], 长度为1。
在这里插入图片描述

方法一：动态规划

 /**
     * 1.dp[i] 代表当前下标最大连续值
     * 2.递推公式 if（nums[i+1]>nums[i]） dp[i+1] = dp[i]+1
     * 3.初始化 都为1
     * 4.遍历方向，从其那往后
     * 5.结果推导 。。。。
     * @param nums
     * @return
     */
    public static int findLengthOfLCIS(int[] nums) {
        int[] dp = new int[nums.length];
        for (int i = 0; i < dp.length; i++) {
            dp[i] = 1;
        }
        int res = 1;
	//可以注意到，這邊的 i 是從 0 開始，所以會出現和卡哥的C++ code有差異的地方，在一些地方會看到有 i + 1 的偏移。
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i + 1] > nums[i]) {
                dp[i + 1] = dp[i] + 1;
            }
            res = res > dp[i + 1] ? res : dp[i + 1];
        }
        return res;
    }

这段代码是用于解决「最长连续递增序列」(Longest Continuous Increasing Subsequence, LCIS)问题的Java实现。给定一个整数数组 nums，目标是找到其中最长的连续严格递增序列的长度。

代码解析

  1. 初始化动态规划数组:

    • 创建一个与 nums 长度相等的数组 dp，其中 dp[i] 代表以 nums[i] 结尾的最长连续递增序列的长度。初始化 dp 数组的所有元素为1，因为至少每个元素自身都可以构成长度为1的连续递增序列。

  2. 动态规划迭代:

    • 从数组的第一个元素开始迭代，直到倒数第二个元素（因为需要比较当前元素与其下一个元素的关系），对于每一个元素 nums[i]（从索引0开始到 nums.length - 2）。
    • 如果当前元素 nums[i] 小于其下一个元素 nums[i + 1]，那么可以构建一个新的连续递增序列，其长度为以 nums[i] 结尾的最长连续递增序列的长度加1，即 dp[i] + 1。
    • 更新 dp[i + 1] 为这个新的连续递增序列的长度。

  3. 记录结果:

    • 在每次更新 dp[i + 1] 后，同时更新全局最大值 res，以确保在整个迭代过程中始终保存最长连续递增序列的长度。

  4. 返回结果:

    • 最后返回 res，即整个数组中的最长连续递增序列的长度。

特别注意

在迭代过程中，由于 dp 数组的更新是基于前一个元素的值，因此迭代的方向是从前往后，这确保了在更新 dp[i + 1] 时，dp[i] 已经包含了正确的信息。

时间复杂度和空间复杂度

  • 时间复杂度: O(n)，其中 n 是数组 nums 的长度。这是因为只需要遍历数组一次来计算最长连续递增序列的长度。
  • 空间复杂度: O(n)，需要一个长度为 n 的动态规划数组 dp 来存储中间结果。

总结

这段代码通过动态规划的方法，有效地解决了最长连续递增序列问题。相比于最长递增子序列问题，最长连续递增序列问题的时间复杂度更低，因为不需要对每个元素都进行前面所有元素的比较，只需关注相邻元素之间的关系。

方法二：动态规划状态压缩

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        // 记录以 前一个元素结尾的最长连续递增序列的长度 和 以当前 结尾的......
        int beforeOneMaxLen = 1, currentMaxLen = 0;
        // res 赋最小值返回的最小值1
        int res = 1;
        for (int i = 1; i < nums.length; i ++) {
            currentMaxLen = nums[i] > nums[i - 1] ? beforeOneMaxLen + 1 : 1;
            beforeOneMaxLen = currentMaxLen;
            res = Math.max(res, currentMaxLen);
        }
        return res;
    }
}

这段代码是解决「最长连续递增序列」(Longest Continuous Increasing Subsequence, LCIS)问题的另一种高效实现，它采用了空间优化的动态规划方法。给定一个整数数组 nums，目标是找到其中最长的连续严格递增序列的长度。

代码解析

  1. 初始化变量:

    • beforeOneMaxLen：表示以当前元素的前一个元素结尾的最长连续递增序列的长度。
    • currentMaxLen：表示以当前元素结尾的最长连续递增序列的长度。初始化时，这个变量没有实际意义，因为真正的计算在循环中进行。
    • res：用于记录整个数组中的最长连续递增序列的长度，初始化为1，因为至少每个元素自身都可以构成长度为1的连续递增序列。

  2. 动态规划迭代:

    • 从数组的第二个元素开始迭代，对于每一个元素 nums[i]（从索引1开始到 nums.length - 1）。
    • 如果当前元素 nums[i] 大于其前一个元素 nums[i - 1]，那么可以构建一个新的连续递增序列，其长度为以 nums[i - 1] 结尾的最长连续递增序列的长度加1，即 beforeOneMaxLen + 1。
    • 如果当前元素不大于其前一个元素，那么以当前元素结尾的最长连续递增序列的长度重置为1，因为连续递增被中断，新的连续递增序列从当前元素开始。
    • 更新 beforeOneMaxLen 为 currentMaxLen，以准备下一次迭代。

  3. 记录结果:

    • 在每次更新 currentMaxLen 后，同时更新全局最大值 res，以确保在整个迭代过程中始终保存最长连续递增序列的长度。

  4. 返回结果:

    • 最后返回 res，即整个数组中的最长连续递增序列的长度。

特别注意

与之前版本相比，这段代码在空间复杂度上进行了优化，不再需要一个与输入数组相同长度的动态规划数组 dp，而是仅使用几个变量来保存必要的状态信息，这大大减少了空间占用。

时间复杂度和空间复杂度

  • 时间复杂度: O(n)，其中 n 是数组 nums 的长度。这是因为只需要遍历数组一次来计算最长连续递增序列的长度。
  • 空间复杂度: O(1)，仅使用了固定数量的变量，与输入数组的大小无关。

总结

这段代码通过动态规划的方法，有效地解决了最长连续递增序列问题，同时在空间复杂度方面进行了优化，使得算法更加高效。相比于传统的动态规划实现，这种空间优化的方法在处理大规模数据时表现更佳。

方法三：贪心法

public static int findLengthOfLCIS(int[] nums) {
    if (nums.length == 0) return 0;
    int res = 1; // 连续子序列最少也是1
    int count = 1;
    for (int i = 0; i < nums.length - 1; i++) {
        if (nums[i + 1] > nums[i]) { // 连续记录
            count++;
        } else { // 不连续，count从头开始
            count = 1;
        }
        if (count > res) res = count;
    }
    return res;
}

这段代码是解决「最长连续递增序列」(Longest Continuous Increasing Subsequence, LCIS)问题的简洁实现。给定一个整数数组 nums，目标是找到其中最长的连续严格递增序列的长度。

代码解析

  1. 边界情况处理:

    • 如果 nums 的长度为0，那么最长连续递增序列的长度自然为0。

  2. 初始化变量:

    • res：用于记录整个数组中的最长连续递增序列的长度，初始化为1，因为至少每个元素自身都可以构成长度为1的连续递增序列。
    • count：表示当前正在统计的连续递增序列的长度，初始化为1。

  3. 动态检查与更新:

    • 从数组的第一个元素开始迭代，直到倒数第二个元素，对于每一个元素 nums[i]（从索引0开始到 nums.length - 2）。
    • 如果当前元素 nums[i] 小于其下一个元素 nums[i + 1]，那么当前正在统计的连续递增序列的长度 count 加1。
    • 如果当前元素不小于其下一个元素，那么当前连续递增序列被中断，count 重置为1，从下一个元素重新开始统计新的连续递增序列的长度。

  4. 记录结果:

    • 在每次更新 count 后，同时更新全局最大值 res，以确保在整个迭代过程中始终保存最长连续递增序列的长度。

  5. 返回结果:

    • 最后返回 res，即整个数组中的最长连续递增序列的长度。

时间复杂度和空间复杂度

  • 时间复杂度: O(n)，其中 n 是数组 nums 的长度。这是因为只需要遍历数组一次来计算最长连续递增序列的长度。
  • 空间复杂度: O(1)，仅使用了固定数量的变量，与输入数组的大小无关。

总结

这段代码通过简单直观的方式，有效地解决了最长连续递增序列问题。相比于使用动态规划数组的传统方法，这段代码不仅易于理解和实现，而且在空间复杂度方面表现出色，仅使用了几个变量，非常适合处理大规模数据集。此外，这种方法避免了动态规划中可能存在的冗余计算，提高了算法的效率。

718. 最长重复子数组

给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、长度最长的子数组的长度 。

示例 1：

输入：nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
输出：3
解释：长度最长的公共子数组是 [3,2,1] 。
示例 2：

输入：nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
输出：5
在这里插入图片描述

方法一：

// 版本一
class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int result = 0;
        int[][] dp = new int[nums1.length + 1][nums2.length + 1];
        
        for (int i = 1; i < nums1.length + 1; i++) {
            for (int j = 1; j < nums2.length + 1; j++) {
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    result = Math.max(result, dp[i][j]);
                }
            }
        }
        
        return result;
    }
}

这段代码是用于解决「两个数组的最长相同子数组」问题的Java实现。给定两个整数数组 nums1 和 nums2，目标是找到在这两个数组中都出现的最长连续相同子数组的长度。

代码解析

  1. 初始化动态规划数组:

    • 创建一个二维数组 dp，其大小为 (nums1.length + 1) x (nums2.length + 1)。dp[i][j] 的值代表以 nums1[i-1] 和 nums2[j-1] 结尾的最长连续相同子数组的长度。额外的一列和一行是为了方便边界条件的处理。

  2. 动态规划迭代:

    • 从数组的第一个有效元素开始迭代，对于每一个元素 nums1[i-1] 和 nums2[j-1]（从索引1开始到 nums1.length 和 nums2.length）。
    • 如果 nums1[i-1] 等于 nums2[j-1]，那么以它们结尾的最长连续相同子数组的长度等于以它们的前一个元素结尾的最长连续相同子数组的长度加1，即 dp[i-1][j-1] + 1。
    • 如果两个元素不相等，那么 dp[i][j] 的值为0，因为当前元素不能扩展任何一个连续相同子数组。

  3. 记录结果:

    • 在每次更新 dp[i][j] 后，同时更新全局最大值 result，以确保在整个迭代过程中始终保存最长连续相同子数组的长度。

  4. 返回结果:

    • 最后返回 result，即两个数组中都出现的最长连续相同子数组的长度。

时间复杂度和空间复杂度

  • 时间复杂度: O(m * n)，其中 m 和 n 分别是数组 nums1 和 nums2 的长度。这是因为需要遍历两个数组的所有可能的元素组合来计算最长连续相同子数组的长度。
  • 空间复杂度: O(m * n)，需要一个大小为 (m + 1) x (n + 1) 的动态规划数组 dp 来存储中间结果。

总结

这段代码通过动态规划的方法，有效地解决了两个数组的最长相同子数组问题。尽管时间复杂度和空间复杂度较高，但在许多实际应用场景中，这样的性能通常是可接受的，特别是当数组大小适中时。如果需要进一步优化空间复杂度，可以考虑使用滚动数组技术，将空间复杂度降低到 O(min(m, n))。

方法二：

// 版本二: 滚动数组
class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int[] dp = new int[nums2.length + 1];
        int result = 0;

        for (int i = 1; i <= nums1.length; i++) {
            for (int j = nums2.length; j > 0; j--) {
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[j] = dp[j - 1] + 1;
                } else {
                    dp[j] = 0;
                }
                result = Math.max(result, dp[j]);
            }
        }
        return result;
    }
}

这段代码是用于解决「两个数组的最长相同子数组」问题的Java实现，特别之处在于它使用了滚动数组技术来优化空间复杂度。给定两个整数数组 nums1 和 nums2，目标是找到在这两个数组中都出现的最长连续相同子数组的长度。

代码解析

  1. 初始化动态规划数组:

    • 创建一个一维数组 dp，其大小为 nums2.length + 1。dp[j] 的值代表以 nums1[i-1] 和 nums2[j-1] 结尾的最长连续相同子数组的长度，其中 i 是外层循环的索引。额外的一列是为了方便边界条件的处理。

  2. 动态规划迭代:

    • 外层循环从1到 nums1.length 遍历 nums1 的每个元素。
    • 内层循环从 nums2.length 反向遍历到1，对于每个 nums2[j-1]。
    • 如果 nums1[i-1] 等于 nums2[j-1]，那么以它们结尾的最长连续相同子数组的长度等于以 nums2[j-2] 结尾的最长连续相同子数组的长度加1，即 dp[j - 1] + 1。
    • 如果两个元素不相等，那么 dp[j] 的值为0。
    • 注意内层循环从后向前遍历的原因是为了避免在更新 dp[j] 的时候影响到尚未处理的 dp[j-1] 的值，因为外层循环中的 i 不断增加，而内层循环中的 j 不断减少，这样可以确保 dp[j-1] 总是保留着前一个状态的正确值。

  3. 记录结果:

    • 在每次更新 dp[j] 后，同时更新全局最大值 result，以确保在整个迭代过程中始终保存最长连续相同子数组的长度。

  4. 返回结果:

    • 最后返回 result，即两个数组中都出现的最长连续相同子数组的长度。

时间复杂度和空间复杂度

  • 时间复杂度: O(m * n)，其中 m 和 n 分别是数组 nums1 和 nums2 的长度。这是因为需要遍历两个数组的所有可能的元素组合来计算最长连续相同子数组的长度。
  • 空间复杂度: O(n)，其中 n 是 nums2 的长度。使用了一维数组 dp 来存储中间结果，相比于版本一的二维数组，空间复杂度显著降低。

总结

这段代码通过滚动数组的动态规划方法，有效地解决了两个数组的最长相同子数组问题，同时在空间复杂度方面进行了优化。滚动数组技术避免了使用额外的大量空间，使得算法在处理大规模数据时更加高效。

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

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

相关文章

【数据结构（邓俊辉）学习笔记】高级搜索树01——伸展树

【数据结构（邓俊辉）学习笔记】高级搜索树01——伸展树

文章目录 1. 逐层伸展1. 1 宽松平衡1. 2 局部性1. 3 自适应调整1. 4 逐层伸展1. 5 实例1. 6 一步一步往上爬1. 7 最坏情况 2. 双层伸展2.1 双层伸展2.2 子孙异侧2.3 子孙同侧2.4 点睛之笔2.5 折叠效果2.6 分摊性能2.7 最后一步 3 算法实现3.1 功能接口3.2 伸展算法3.3 四种情况…
阅读更多...
产品经理-工作流程及职能（6）

产品经理-工作流程及职能（6）

产品经理作为互联网项目的主心骨&#xff0c;连接着团队的所有成员&#xff08;开发、设计、运营、测试、市场等&#xff09; 用合理的产品规划和清晰的产品愿景带领大家前进&#xff0c;通过满足用户需求来创造属于自己的商业利益。 在通常情况下&#xff0c;PM需要对整个产品…
阅读更多...
基于工业互联网的智慧矿山解决方案PPT(38页)

基于工业互联网的智慧矿山解决方案PPT(38页)

文章摘要 工业互联网与智慧矿山 基于工业互联网的新一代智慧矿山解决方案&#xff0c;将互联网和新一代IT技术与工业系统深度融合&#xff0c;形成关键的产业和应用生态&#xff0c;推动工业智能化发展。该方案以“四级、三层、两网、一平台”为总体框架&#xff0c;强调应用目…
阅读更多...
深圳晶彩智能ESP32-2432S028R实时观察LVGL9效果

深圳晶彩智能ESP32-2432S028R实时观察LVGL9效果

深圳晶彩智能ESP32-2432S028R概述&#xff1a; 深圳晶彩智能出品ESP32-32432S028R为2.8寸彩色屏采用分辨率320x240彩色液晶屏&#xff0c;驱动芯片是ILI9431。板载乐鑫公司出品ESP-WROOM-32&#xff0c;Flash 4M。型号尾部“R”标识电阻膜的感压式触摸屏&#xff0c;驱动芯片是…
阅读更多...
容器：stack

容器：stack

以下是关于stack容器的一些总结&#xff1a; stack容器比较简单&#xff0c;主要包括&#xff1a; 1、构造函数&#xff1a;stack [staName] 2、添加、删除元素: push() 、pop() 3、获取栈顶元素&#xff1a;top() 4、获取栈的大小&#xff1a;size() 5、判断栈是否为空&#x…
阅读更多...
深入刨析Redis存储技术设计艺术（二）

深入刨析Redis存储技术设计艺术（二）

三、Redis主存储 3.1、存储相关结构体 redisServer：服务器 server.h struct redisServer { /* General */ pid_t pid; /* Main process pid. */ pthread_t main_thread_id; /* Main thread id */ char *configfile; /* Absolut…
阅读更多...
图书管理系统 全栈项目分享

图书管理系统 全栈项目分享

文章目录 项目简要说明项目开源地址b站视频演示技术栈部分效果展示 项目简要说明 本项目是我的数据库课设&#xff0c;个人感觉做得还行&#xff0c;目前项目开源&#xff0c;README文档里有项目的介绍和使用说明&#xff0c;这里就不一一赘述了 项目开源地址 github - libr…
阅读更多...
nginx(三)—从Nginx配置熟悉Nginx功能

nginx(三)—从Nginx配置熟悉Nginx功能

一、 Nginx配置文件结构 ... #全局块events { #events块... }http #http块 {... #http全局块server #server块{ ... #server全局块location [PATTERN] #location块{...}location [PATTERN] {...}}server{...}... #http全局块 …
阅读更多...
NoSQL 之 Redis 配置与常用命令

NoSQL 之 Redis 配置与常用命令

一、关系型数据库与非关系型数据库 1、数据库概述 &#xff08;1&#xff09;关系型数据库 关系型数据库是一个结构化的数据库&#xff0c;创建在关系模型&#xff08;二维表格模型&#xff09;基础上&#xff0c;一般面向于记 录。 SQL 语句&#xff08;标准数据查询语言&am…
阅读更多...
ONLYOFFICE 8.1——全新桌面编辑器，相见恨晚

ONLYOFFICE 8.1——全新桌面编辑器，相见恨晚

目录 前言 一、链接 ONLYOFFICE 8.1版本 官网下载链接&#xff1a; ONLYOFFICE 在线工具&#xff1a; 下载版本推荐&#xff1a; 二、使用体验 1. 界面设计&#xff1a; 2. 文档编辑功能&#xff1a; 3. 电子表格功能&#xff1a; 4. 演示文稿功能&#xff1a; 5.PDF编…
阅读更多...
使用 AlphaZero 和 Tabu 搜索查找越来越大的极值图

使用 AlphaZero 和 Tabu 搜索查找越来越大的极值图

使用 AlphaZero 和 Tabu 搜索查找越来越大的极值图 AlphaZero 方法最佳研究&#xff08;第1部分&#xff09; 文章目录 一、说明二、引言三、预备知识四、方法4.1 AlphaZero4.2 禁忌搜索 五、实验与结果六、讨论七、附录A 一个例子B 问题背景 一、说明 人工智能的树和图的检索问…
阅读更多...
Nacos源码分析：心跳机制、健康检查、服务发现、AP集群

Nacos源码分析：心跳机制、健康检查、服务发现、AP集群

文章目录 心跳机制与服务健康检查NacosClient端NacosServer端NacosServer端健康检查 服务发现NacosClient端NacosServer端 AP集群从源码启动集群心跳设计原理各节点状态同步服务实例数据同步服务实例状态变动同步 心跳机制与服务健康检查 官方文档&#xff1a;发送某个实例的心…
阅读更多...
SpringBoot新手快速入门系列教程四：创建第一个SringBoot的API

SpringBoot新手快速入门系列教程四：创建第一个SringBoot的API

首先我们用IDEA新建一个项目&#xff0c;请将这些关键位置按照我的设置设置一下 接下来我将要带着你一步一步创建一个Get请求和Post请求&#xff0c;通过客户端请求的参数&#xff0c;以json格式返回该参数{“message”:"Hello"} 1,先在IDE左上角把这里改为文件模式…
阅读更多...
MySQL基础篇（三）数据库的修改 删除 备份恢复 查看连接情况

MySQL基础篇（三）数据库的修改 删除 备份恢复 查看连接情况

对数据库的修改主要指的是修改数据库的字符集&#xff0c;校验规则。 将test1数据库字符集改为gbk。 数据库的删除&#xff1a; 执行完该数据库就不存在了&#xff0c;对应数据库文件夹被删除&#xff0c;级联删除&#xff0c;里面的数据表全部被删除。 注意&#xff1a;不要随…
阅读更多...
【IO】文件操作

【IO】文件操作

&#x1f970;&#x1f970;&#x1f970;来都来了&#xff0c;不妨点个关注叭&#xff01; &#x1f449;博客主页&#xff1a;欢迎各位大佬!&#x1f448; 文章目录 1. 文件1.1 认识文件1.2 分清操作的是内存还是硬盘1.3 路径1.3.1 目录结构1.3.2 相对和绝对路径 1.4 文本文件…
阅读更多...
Kafka系列之Kafka知识超强总结

Kafka系列之Kafka知识超强总结

一、Kafka简介 Kafka是什么 Kafka是一种高吞吐量的分布式发布订阅消息系统&#xff08;消息引擎系统&#xff09;&#xff0c;它可以处理消费者在网站中的所有动作流数据。 这种动作&#xff08;网页浏览&#xff0c; 搜索和其他用户的行动&#xff09;是在现代网络上的许多社…
阅读更多...
Feign-未完成

Feign-未完成

Feign Java中如何实现接口调用&#xff1f;即如何发起http请求 前三种方式比较麻烦&#xff0c;在发起请求前&#xff0c;需要将Java对象进行序列化转为json格式的数据&#xff0c;才能发送&#xff0c;然后进行响应时&#xff0c;还需要把json数据进行反序列化成java对象。 …
阅读更多...
基于顺序表的通讯录实现

基于顺序表的通讯录实现

一、前言 基于已经学过的顺序表&#xff0c;可以实现一个简单的通讯录。 二、通讯录相关头文件 //Contact.h #pragma once#define NAME_MAX 20 #define TEL_MAX 20 #define ADDR_MAX 20 #define GENDER_MAX 20typedef struct PersonInfo {char name[NAME_MAX];char gender[G…
阅读更多...
node的下载、安装、配置和使用（node.js下载安装和配置、npm命令汇总、cnpm的使用）

node的下载、安装、配置和使用（node.js下载安装和配置、npm命令汇总、cnpm的使用）

天行健，君子以自强不息；地势坤，君子以厚德载物。 每个人都有惰性，但不断学习是好好生活的根本，共勉！ 文章均为学习整理笔记，分享记录为主，如有错误请指正，共同学习进步。 愿将腰下剑，直为斩楼兰。 ——《塞下曲》 文章目录 一、node.js的下载、安装和配置1. node.js下…
阅读更多...
Latex--制作幻灯片

Latex--制作幻灯片

目录 1.基本介绍 &#xff08;1&#xff09;案例引入 &#xff08;2&#xff09;相关说明 &#xff08;3&#xff09;控制顺序 &#xff08;4&#xff09;帧环境的创建 &#xff08;5&#xff09;内置主题 &#xff08;6&#xff09;生成标题页面 1.基本介绍 &#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023