代码随想录-Day53

739. 每日温度

给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。

示例 1:

输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]
示例 2:

输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]
示例 3:

输入: temperatures = [30,60,90]
输出: [1,1,0]
在这里插入图片描述
在这里插入图片描述

方法一：

class Solution {
  // 版本 1
    public int[] dailyTemperatures(int[] temperatures) {

        int lens=temperatures.length;
        int []res=new int[lens];

        /**
        如果当前遍历的元素 大于栈顶元素，表示 栈顶元素的 右边的最大的元素就是 当前遍历的元素，
        	所以弹出 栈顶元素，并记录
        	如果栈不空的话，还要考虑新的栈顶与当前元素的大小关系
        否则的话，可以直接入栈。
        注意，单调栈里 加入的元素是 下标。
        */
        Deque<Integer> stack=new LinkedList<>();
        stack.push(0);
        for(int i=1;i<lens;i++){

            if(temperatures[i]<=temperatures[stack.peek()]){
                stack.push(i);
            }else{
                while(!stack.isEmpty()&&temperatures[i]>temperatures[stack.peek()]){
                    res[stack.peek()]=i-stack.peek();
                    stack.pop();
                }
                stack.push(i);
            }
        }

        return  res;
    }

这段代码是用于解决「每日温度」问题的Java实现，这个问题的目标是给定一个整数数组 temperatures，其中每个元素表示每天的温度，返回一个新的数组，其中每个元素表示直到未来几天才会出现更高的温度的天数。如果不存在未来几天会出现更高的温度，那么该位置的值为0。

代码解析

  1. 初始化:

    • 创建一个与 temperatures 长度相同的数组 res，用于存放结果。
    • 使用一个单调栈 stack，数据结构为 Deque，在Java中通常使用 LinkedList 实现，用于存储下标。

  2. 遍历并维护单调栈:

    • 遍历 temperatures 数组中的每个元素。
    • 对于当前遍历到的元素 temperatures[i]：
      • 如果该元素小于等于栈顶元素对应的温度，即 temperatures[i] <= temperatures[stack.peek()]，则将当前下标 i 入栈。
      • 否则，进入一个while循环：
        • 当栈不为空且当前元素大于栈顶元素对应的温度时，弹出栈顶元素，并计算栈顶元素下标到当前下标 i 的距离，即 i - stack.peek()，并将这个距离存入结果数组 res 的对应位置。
        • 继续循环，直到栈为空或当前元素不大于栈顶元素对应的温度。
      • 最后，将当前下标 i 入栈。

  3. 返回结果:

    • 返回结果数组 res，其中每个元素表示直到未来几天才会出现更高的温度的天数。

时间复杂度和空间复杂度

  • 时间复杂度: O(n)，其中 n 是数组 temperatures 的长度。每个元素至多被放入和弹出栈一次。
  • 空间复杂度: O(n)，需要一个大小为 n 的结果数组 res 和一个单调栈 stack。

总结

这段代码通过使用单调栈的策略，有效地解决了每日温度问题，能够快速找到每个温度元素右边第一个比它大的温度元素的位置。单调栈是一种常用的数据结构，在处理与单调性相关的数组或序列问题时非常有用，例如寻找最近的更大或更小的元素、股票价格波动分析等。在实际应用中，掌握单调栈的原理和使用方法能够帮助解决一系列经典问题，提高代码效率。

方法二：

    //--------这 是一条分界线
    // 版本 2
    class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int lens=temperatures.length;
        int []res=new int[lens];
        Deque<Integer> stack=new LinkedList<>();
        for(int i=0;i<lens;i++){

           while(!stack.isEmpty()&&temperatures[i]>temperatures[stack.peek()]){
                    res[stack.peek()]=i-stack.peek();
                    stack.pop();
                }
                stack.push(i);
        }

        return  res;
    }

这段代码同样是用于解决「每日温度」问题的Java实现，其目标与前一版本相同，即给定一个整数数组 temperatures，返回一个新的数组，其中每个元素表示直到未来几天才会出现更高的温度的天数。如果不存在未来几天会出现更高的温度，那么该位置的值为0。

代码解析

  1. 初始化:

    • 创建一个与 temperatures 长度相同的数组 res，用于存放结果。
    • 使用一个单调栈 stack，数据结构为 Deque，在Java中通常使用 LinkedList 实现，用于存储下标。

  2. 遍历并维护单调栈:

    • 遍历 temperatures 数组中的每个元素。
    • 对于当前遍历到的元素 temperatures[i]：
      • 进入一个while循环，只要栈不为空且当前元素大于栈顶元素对应的温度，执行以下操作：
        • 计算栈顶元素下标到当前下标 i 的距离，即 i - stack.peek()，并将这个距离存入结果数组 res 的对应位置。
        • 弹出栈顶元素。
      • 将当前下标 i 入栈。

  3. 返回结果:

    • 返回结果数组 res，其中每个元素表示直到未来几天才会出现更高的温度的天数。

时间复杂度和空间复杂度

  • 时间复杂度: O(n)，其中 n 是数组 temperatures 的长度。每个元素至多被放入和弹出栈一次。
  • 空间复杂度: O(n)，需要一个大小为 n 的结果数组 res 和一个单调栈 stack。

版本对比

相比于版本1，版本2的代码在遍历过程中直接从头开始，简化了代码逻辑，将入栈操作放在了while循环的外部。这种写法同样有效，且逻辑上更清晰，因为它避免了不必要的条件判断（如版本1中的 temperatures[i] <= temperatures[stack.peek()]）。每次遍历到新元素时，代码首先处理栈中所有比当前元素小的元素，然后将当前元素入栈，这一过程确保了栈内的元素始终按温度递减的顺序排列，即形成了一个单调递减栈。

总结

通过使用单调栈的策略，版本2的代码同样有效地解决了每日温度问题。这种实现方式不仅保持了良好的时间复杂度和空间复杂度，而且在代码结构上更为精简和直观，有助于提高代码的可读性和维护性。单调栈在处理与单调性相关的数组或序列问题时是一种非常有用的工具，熟练掌握其使用方法对于解决一系列经典问题具有重要意义。

496. 下一个更大元素 I

nums1 中数字 x 的 下一个更大元素 是指 x 在 nums2 中对应位置 右侧 的 第一个 比 x 大的元素。

给你两个 没有重复元素 的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。

对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是 -1 。

返回一个长度为 nums1.length 的数组 ans 作为答案，满足 ans[i] 是如上所述的 下一个更大元素 。

示例 1：

输入：nums1 = [4,1,2], nums2 = [1,3,4,2].
输出：[-1,3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：

  • 4 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。
  • 1 ，用加粗斜体标识，nums2 = [1,3,4,2]。下一个更大元素是 3 。
  • 2 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。
    示例 2：

输入：nums1 = [2,4], nums2 = [1,2,3,4].
输出：[3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：

  • 2 ，用加粗斜体标识，nums2 = [1,2,3,4]。下一个更大元素是 3 。
  • 4 ，用加粗斜体标识，nums2 = [1,2,3,4]。不存在下一个更大元素，所以答案是 -1 。

方法一：

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Stack<Integer> temp = new Stack<>();
        int[] res = new int[nums1.length];
        Arrays.fill(res,-1);
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        for (int i = 0 ; i< nums1.length ; i++){
            hashMap.put(nums1[i],i);
        }
        temp.add(0);
        for (int i = 1; i < nums2.length; i++) {
            if (nums2[i] <= nums2[temp.peek()]) {
                temp.add(i);
            } else {
                while (!temp.isEmpty() && nums2[temp.peek()] < nums2[i]) {
                    if (hashMap.containsKey(nums2[temp.peek()])){
                        Integer index = hashMap.get(nums2[temp.peek()]);
                        res[index] = nums2[i];
                    }
                    temp.pop();
                }
                temp.add(i);
            }
        }

        return res;
    }
}

这段代码是用于解决「下一个更大元素 I」问题的Java实现。给定两个没有重复元素的数组 nums1 和 nums2，其中 nums1 是 nums2 的一个子集，目标是对于 nums1 中的每一个元素，找到在 nums2 中下一个更大的元素的值。如果没有这样的元素，那么输出 -1。

代码解析

  1. 初始化:

    • 创建一个单调栈 temp，数据结构为 Stack，用于存储 nums2 中元素的下标。
    • 创建一个结果数组 res，初始化所有元素为 -1，长度与 nums1 相同。
    • 创建一个哈希映射 hashMap，用于存储 nums1 中元素及其在 res 数组中的下标，以便快速查找和更新结果。

  2. 遍历并维护单调栈:

    • 遍历 nums2 数组中的每个元素。
    • 对于当前遍历到的元素 nums2[i]：
      • 如果该元素小于等于栈顶元素对应的值，即 nums2[i] <= nums2[temp.peek()]，则将当前下标 i 入栈。
      • 否则，进入一个while循环：
        • 当栈不为空且当前元素大于栈顶元素对应的值时，检查栈顶元素是否在 nums1 中，如果是，则获取该元素在 res 中的下标，并将当前元素的值赋给 res 的对应位置。
        • 继续循环，直到栈为空或当前元素不大于栈顶元素对应的值。
      • 最后，将当前下标 i 入栈。

  3. 返回结果:

    • 返回结果数组 res，其中每个元素表示 nums1 中对应元素在 nums2 中的下一个更大元素的值，若不存在则为 -1。

时间复杂度和空间复杂度

  • 时间复杂度: O(m + n)，其中 m 和 n 分别是数组 nums1 和 nums2 的长度。每个元素至多被放入和弹出栈一次，哈希表的查找操作平均时间复杂度为 O(1)。
  • 空间复杂度: O(n)，需要一个大小为 n 的单调栈 temp 和一个哈希映射 hashMap，以及一个结果数组 res。

总结

这段代码通过使用单调栈和哈希映射的策略，有效地解决了下一个更大元素问题，能够快速找到 nums1 中每个元素在 nums2 中下一个更大元素的值。单调栈是一种常用的数据结构，在处理与单调性相关的数组或序列问题时非常有用，结合哈希映射能够进一步提高查找效率。在实际应用中，掌握这些数据结构和算法原理能够帮助解决一系列经典问题，提高代码效率和性能。

方法二：

// 版本2
class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums1.length; i++) {
            map.put(nums1[i], i);
        }

        int[] res = new int[nums1.length];
        Stack<Integer> stack = new Stack<>();
        Arrays.fill(res, -1);

        for (int i = 0; i < nums2.length; i++) {
            while (!stack.isEmpty() && nums2[stack.peek()] < nums2[i]) {
                int pre = nums2[stack.pop()];
                if (map.containsKey(pre)) {
                    res[map.get(pre)] = nums2[i];
                }
            }
            stack.push(i);
        }

        return res;
    }
}

这段代码是用于解决「下一个更大元素 I」问题的另一种Java实现，其实现思路与之前解析的版本相似，但代码结构和变量命名有所不同，旨在解决给定两个没有重复元素的数组 nums1 和 nums2，其中 nums1 是 nums2 的一个子集，对于 nums1 中的每一个元素，找到在 nums2 中下一个更大的元素的值。如果没有这样的元素，那么输出 -1。

代码解析

  1. 初始化:

    • 创建一个哈希映射 map，用于存储 nums1 中元素及其在 nums1 中的下标，以便快速查找和更新结果。
    • 创建一个结果数组 res，初始化所有元素为 -1，长度与 nums1 相同。
    • 创建一个单调栈 stack，数据结构为 Stack，用于存储 nums2 中元素的下标。

  2. 构建哈希映射:

    • 遍历 nums1 数组，将每个元素及其在 nums1 中的下标存储在 map 中。

  3. 遍历并维护单调栈:

    • 遍历 nums2 数组中的每个元素。
    • 对于当前遍历到的元素 nums2[i]：
      • 如果栈不为空并且栈顶元素对应的值小于当前元素，即 nums2[stack.peek()] < nums2[i]，则：
        • 弹出栈顶元素，并获取其值。
        • 如果弹出的元素在 nums1 中，即 map 中存在该元素，那么在 res 数组的对应位置填入当前元素的值。
      • 继续这个过程，直到栈为空或者栈顶元素对应的值不再小于当前元素。
      • 最后，将当前下标 i 入栈。

  4. 返回结果:

    • 返回结果数组 res，其中每个元素表示 nums1 中对应元素在 nums2 中的下一个更大元素的值，若不存在则为 -1。

时间复杂度和空间复杂度

  • 时间复杂度: O(m + n)，其中 m 和 n 分别是数组 nums1 和 nums2 的长度。每个元素至多被放入和弹出栈一次，哈希表的查找操作平均时间复杂度为 O(1)。
  • 空间复杂度: O(n)，需要一个大小为 n 的单调栈 stack 和一个哈希映射 map，以及一个结果数组 res。

总结

这段代码同样通过使用单调栈和哈希映射的策略，有效地解决了下一个更大元素问题，能够快速找到 nums1 中每个元素在 nums2 中下一个更大元素的值。代码结构清晰，逻辑直观，是解决这类问题的一种典型且高效的方法。掌握这些数据结构和算法原理能够帮助解决一系列经典问题，提高代码效率和性能。在实际应用中，根据具体需求和场景选择合适的数据结构和算法是非常重要的。

503. 下一个更大元素 II

给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的 下一个更大元素 。

数字 x 的 下一个更大的元素 是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1 。

示例 1:

输入: nums = [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数；
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。
示例 2:

输入: nums = [1,2,3,4,3]
输出: [2,3,4,-1,4]

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        //边界判断
        if(nums == null || nums.length <= 1) {
            return new int[]{-1};
        }
        int size = nums.length;
        int[] result = new int[size];//存放结果
        Arrays.fill(result,-1);//默认全部初始化为-1
        Stack<Integer> st= new Stack<>();//栈中存放的是nums中的元素下标
        for(int i = 0; i < 2*size; i++) {
            while(!st.empty() && nums[i % size] > nums[st.peek()]) {
                result[st.peek()] = nums[i % size];//更新result
                st.pop();//弹出栈顶
            }
            st.push(i % size);
        }
        return result;
    }
}

这段代码是用于解决「下一个更大元素 II」问题的Java实现。给定一个循环数组 nums（数组中元素的下一个元素是数组的第一个元素），目标是返回一个数组，其中每个元素是原数组中下一个更大元素的值，如果没有更大的元素，则对应位置的值为 -1。

代码解析

  1. 初始化:

    • 创建一个单调栈 st，数据结构为 Stack，用于存储 nums 中元素的下标。
    • 创建一个结果数组 result，初始化所有元素为 -1，长度与 nums 相同。

  2. 遍历并维护单调栈:

    • 遍历 nums 数组两次，即遍历 2 * nums 的长度（考虑到循环数组的性质），使用模运算 i % size 来获取实际数组下标。
    • 对于当前遍历到的元素 nums[i % size]：
      • 如果栈不为空并且栈顶元素对应的值小于当前元素，即 nums[st.peek()] < nums[i % size]，则：
        • 更新 result 数组中对应位置的值为当前元素的值。
        • 弹出栈顶元素。
      • 继续这个过程，直到栈为空或者栈顶元素对应的值不再小于当前元素。
      • 最后，将当前下标 i % size 入栈。

  3. 返回结果:

    • 返回结果数组 result，其中每个元素表示原数组 nums 中对应元素的下一个更大元素的值，若不存在则为 -1。

时间复杂度和空间复杂度

  • 时间复杂度: O(n)，其中 n 是数组 nums 的长度。虽然代码中遍历了 2 * nums 的长度，但是每个元素至多被放入和弹出栈一次，因此总的时间复杂度为 O(n)。
  • 空间复杂度: O(n)，需要一个大小为 n 的单调栈 st 和一个结果数组 result。

总结

这段代码通过使用单调栈的策略，有效地解决了下一个更大元素 II 问题，能够处理循环数组并找到每个元素的下一个更大元素的值。代码逻辑清晰，通过两次遍历数组并使用模运算处理循环数组的特点，实现了高效的解题策略。单调栈在处理这类问题时表现出了强大的能力，能够快速找到特定条件下下一个更大的元素，是解决此类问题的经典方法。在实际应用中，了解和掌握单调栈的使用方法对于解决与单调性相关的数组或序列问题具有重要意义。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【渗透测试】利用hook技术破解前端JS加解密 - JS-Forward

【渗透测试】利用hook技术破解前端JS加解密 - JS-Forward

前言 在做渗透测试项目时&#xff0c;尤其是金融方面&#xff0c;经常会遇到前端JS加解密技术&#xff0c;看着一堆堆密密麻麻的密文&#xff0c;会给人一种无力感。Hook技术则会帮助我们无需获取加解密密钥的前提下&#xff0c;获取明文进行渗透测试 环境准备 JS-Forward Burp…
阅读更多...
（附源码）c#+winform实现远程开机（广域网可用）

（附源码）c#+winform实现远程开机（广域网可用）

实现逻辑 利用UDP协议发送特定格式的魔术包&#xff0c;以远程唤醒具有特定MAC地址的目标计算机。目标计算机的BIOS和网络配置需要支持Wake-on-LAN&#xff08;WOL&#xff09;功能&#xff0c;并且需要在目标计算机上配置正确的网络唤醒设置。 源码在最后 准备工作 进入Bio…
阅读更多...
NB！小哥竟然绕过了安全启动，Dump了SoC的BootROM。

NB！小哥竟然绕过了安全启动，Dump了SoC的BootROM。

原文&#xff1a;Amlogic S905 SoC: bypassing the (not so) Secure Boot to dump the BootROM译者&#xff1a;TrustZone 推荐语&#xff1a; 这是一篇关于如何绕过安全启动&#xff0c;然后实现破解BootRom的文章。通过这篇文章&#xff0c;可以让你对于ATF、安全启动等有个…
阅读更多...
快人一步：预防勒索病毒的利器

快人一步：预防勒索病毒的利器

在当今日益复杂的网络安全环境中&#xff0c;各种病毒、勒索软件层出不穷&#xff0c;对个人电脑、企业服务器甚至国家信息安全构成严重威胁。而白名单可信机制作为一种有效的安全防护手段&#xff0c;在防勒索病毒中发挥着至关重要的作用。 一、白名单可信机制概述 白名单可信…
阅读更多...
3Python的Pandas：数据选取

3Python的Pandas：数据选取

1.数据选取操作 1.1. 选取单列 df[Q1]df[Q2]1.2. 选取多列 df[[team,Q1]]df.loc[:,[team,Q1]]1.3.选择行 使用指定索引选择 df[df.indexAck]选择前n行 df[0:3]df.iloc[:10,:]1.4. 前n行&#xff0c;每隔m选择一个 df[0:10:3]1.5. 条件选择 df[df.Q1>90]df[(df.teamC…
阅读更多...
C#知识|账号管理系统：使用带参数的SQL语句编程添加账号的方法。

C#知识|账号管理系统：使用带参数的SQL语句编程添加账号的方法。

哈喽，你好啊，我是雷工！ 前边学习了登录窗体的实现，接下来接着学习使用带参数的SQL语句编程添加账号的方法。 以下为学习笔记。 01 非带参数方法 在DAL数据访问层编写AccountServer.cs类代码。 按照前面的练习，写法如下： public int AddAccount(Account account) {//定义S…
阅读更多...
【关于车载测试的基础知识的认知详解】

【关于车载测试的基础知识的认知详解】

目录 一、目前车企的趋势 1. 电动化&#xff1a; 2. 自动驾驶技术&#xff1a; 3. 车联网&#xff08;Connected Cars&#xff09;&#xff1a; 4. 智能化和数字化&#xff1a; 5. 安全性&#xff1a; 6. 轻量化&#xff1a; 7. 个性化和定制化&#xff1a; 8. 供应链…
阅读更多...
HTML(27)——渐变

HTML(27)——渐变

渐变是多个颜色逐渐变化的效果&#xff0c;一般用于设置盒子模型 线性渐变 属性&#xff1a;background-image : linear-gradient( 渐变方向 颜色1 终点位置, 颜色2 终点位置, ......&#xff09;&#xff1b; 取值: 渐变方向:可选 to 方位名词角度度数 终点位置:可选 百分…
阅读更多...
kafka的副本replica

kafka的副本replica

指定topic的分区和副本 通过kafka命令行工具 kafka-topics.sh --create --topic myTopic --partitions 3 --replication-factor 1 --bootstrap-server localhost:9092 执行代码时指定分区个数
阅读更多...
榨汁机脱毛仪25N60-NMOS管 惠海HC031N06L60V25A 沟槽工艺低RDS 高功率

榨汁机脱毛仪25N60-NMOS管 惠海HC031N06L60V25A 沟槽工艺低RDS 高功率

NMOS管的工作原理&#xff1a;NMOS管是利用VGS&#xff08;栅极-源极电压&#xff09;来控制“感应电荷”的多少&#xff0c;以改变由这些“感应电荷”形成的导电沟道的状况&#xff0c;从而达到控制漏极电流的目的1。在制造管子时&#xff0c;通过工艺使绝缘层中出现大量正离子…
阅读更多...
虚拟现实3d场景漫游体验实现了“所见即所得”

虚拟现实3d场景漫游体验实现了“所见即所得”

如今&#xff0c;从实体店铺到工厂企业&#xff0c;再到政府单位&#xff0c;各行各业都已纷纷加入VR数字化升级的行列&#xff0c;相比传统的2D商品展示&#xff0c;三维交互展示成为商企客户交流的主流方式。产品展示、服务介绍、考察洽谈等都可以通过在3D虚拟场景网站中真实…
阅读更多...
最新版萌新Python看过最好的电子书？

最新版萌新Python看过最好的电子书？

我之前写过一篇 Python 入门看哪些书的文章&#xff0c;文章中罗列了 5 位大佬的书单推荐&#xff0c;在这个基础上我总结了自己看过的书单。你要是不知道学 Python 看什么书好&#xff0c;不妨参考一下&#xff1a; 一晃就到了月末&#xff0c;2020年也过去了 2 个月&#xf…
阅读更多...
【解决ERROR】usage:conda [-h][-V] command... conda:error:unrecognized arguments

【解决ERROR】usage:conda [-h][-V] command... conda:error:unrecognized arguments

解决方法 conda env create --file conda3_520_env_deepPath.yml
阅读更多...
AI：助力开发者翱翔，而非抢夺其舞台

AI：助力开发者翱翔，而非抢夺其舞台

在当今这个科技飞速发展的时代&#xff0c;人工智能&#xff08;AI&#xff09;犹如一股春风&#xff0c;悄然渗透进全球各个行业&#xff0c;尤其在软件开发领域&#xff0c;其影响力日益显著。从初创企业到跨国巨头&#xff0c;无一不在积极探索AI如何重塑编程的面貌&#xf…
阅读更多...
springboot校园服装租赁系统-计算机毕业设计源码30824

springboot校园服装租赁系统-计算机毕业设计源码30824

目 录 摘要 1 绪论 1.1 研究背景与意义 1.2国内外研究现状 1.3论文结构与章节安排 2 校园服装租赁系统分析 2.1 可行性分析 2.1.1 技术可行性分析 2.1.2 经济可行性分析 2.1.3 法律可行性分析 2.2 系统功能分析 2.2.1 功能性分析 2.2.2 非功能性分析 2.3 系统用例…
阅读更多...
Hadoop-20 Flume 采集数据双写至本地+HDFS中 监控目录变化 3个Agent MemoryChannel Source对比

Hadoop-20 Flume 采集数据双写至本地+HDFS中 监控目录变化 3个Agent MemoryChannel Source对比

章节内容 上一节完成了如下的内容&#xff1a; 编写Agent Conf配置文件收集Hive数据汇聚到HDFS中测试效果 背景介绍 这里是三台公网云服务器&#xff0c;每台 2C4G&#xff0c;搭建一个Hadoop的学习环境&#xff0c;供我学习。 之前已经在 VM 虚拟机上搭建过一次&#xff0…
阅读更多...
网页提示“非私密连接”怎么办？

网页提示“非私密连接”怎么办？

当网页提示“非私密连接”或“您与该网站的连接不是私密连接”&#xff0c;这通常意味着浏览器无法建立一个安全的HTTPS连接。HTTPS协议是HTTP协议的安全版本&#xff0c;通过SSL协议加密数据传输&#xff0c;以保护用户的数据免受中间人攻击或监听。主要有下面几个原因&#x…
阅读更多...
vue3自自定义插件注册全局事件

vue3自自定义插件注册全局事件

一. 首先在components中定义自定义组件 二. 然后在components下建立一个index.ts文件 index.ts中的代码如下 // 引入项目中全部的全局组件 import SvgIcon from ./SvgIcon/index.vue import pagination from ./pagination/index.vue // 全局对象 const allGloablComponen…
阅读更多...
66条AI共创文章润色秘诀，一键提升你的写作水平

66条AI共创文章润色秘诀，一键提升你的写作水平

猫头虎 &#x1f42f; 建联猫头虎&#xff0c;商务合作&#xff0c;产品评测&#xff0c;产品推广&#xff0c;个人自媒体创作&#xff0c;超级个体&#xff0c;涨粉秘籍&#xff0c;一起探索编程世界的无限可能&#xff01; 掌握这些提示词和指令&#xff0c;让你的AI创作更…
阅读更多...
centos7停服之后换阿里云的源

centos7停服之后换阿里云的源

原因&#xff1a; Centos7停止维护 CentOS 7 官方支持在2024年6月30日结束。如果您正在使用CentOS 7&#xff0c;建议迁移到另一个仍在维护的Linux发行版&#xff0c;如CentOS Stream、AlmaLinux、Rocky Linux或者转换到使用Debian或Ubuntu。国产的华为的&#xff1a;openEule…
阅读更多...
最新文章

Copyright @ 2022~2023