基础暴力算法

线性枚举

线性枚举（Linear Enumeration）是一种暴力枚举的方法，它逐一检查每个可能的解，适用于搜索和枚举问题。

其核心思路是：对问题的所有可能情况逐一进行遍历，并针对每种情况判断是否满足条件，从而得到解答。

线性枚举是一种顺序搜索算法，从线性表的第一个元素开始，根据特定的判断条件，做出相应的行为。变种比较多，最常见的就是求最值、求和等等。比如：

  1. 求最大值，伪代码

    最大值 = 非常小的数
for 当前元素 in 给定的线性表:
    if 当前元素 > 最大值:
        最大值 = 当前元素
返回 最大值 的值

  2. 求和，伪代码

    求和 = 0
for 当前元素 in 给定的线性表:
    求和 = 求和 + 当前元素
返回 求和 的值

时间复杂度

线性枚举需要遍历列表中的每个元素。

线性枚举的时间复杂度为 O (nm)，其中 n 是线性表的长度，m 是每次操作的量级。

对于求最大值和求和来说，因为操作比较简单，所以 m 为 1，则整体的时间复杂度是 O (n) 的。

线性枚举是一种简单而有效的算法思想，它可以用于解决许多基本的算法问题。虽然它的时间复杂度较高，但在处理小型数据集时仍然是一种常用的算法。

线性枚举的优化

对于线性枚举，有很多优化算法：

  1. 二分查找：如果线性表已经排序，可以使用二分搜索来提高搜索效率。
  2. 哈希表：可以使用哈希表来存储已经搜索过的元素，避免重复搜索。
  3. 前缀和：可以存储前 i 个元素的和，避免重复计算。
  4. 双指针：可以从两头开始搜索，提升搜索效率。
  5. …

实战

存在连续三个奇数的数组

力扣链接

给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。

示例 1：

输入：arr = [2,6,4,1]
输出：false
解释：不存在连续三个元素都是奇数的情况。

示例 2：

输入：arr = [1,2,34,3,4,5,7,23,12]
输出：true
解释：存在连续三个元素都是奇数的情况，即 [5,7,23] 。

提示：

  • 1 <= arr.length <= 1000
  • 1 <= arr[i] <= 1000
题解
class Solution {
public:
    bool threeConsecutiveOdds(vector<int>& arr) {
        int count = 0; // 计数器：记录连续的奇数个数
        for (int i = 0; i < arr.size(); ++i){	
            if (arr[i] % 2 != 0){ // 取模判断是否为奇数
                count ++;
                if (count == 3){
                    return true; // 当计数器为3时直接返回
                }
            }else{
                count = 0; // 遇到偶数重置计数器
            }
        }
        return false;
    }
};
官方题解
class Solution {
public:
    bool threeConsecutiveOdds(vector<int>& arr) {
        int n = arr.size();
        for (int i = 0; i <= n - 3; ++i) {
            if ((arr[i] & 1) && (arr[i + 1] & 1) && (arr[i + 2] & 1)) {
                return true;
            }
        }
        return false;
    }
};
Note
  • 判断奇数可以用按位与运算符 &，arr[i] & 1：如果 arr[i] 是奇数，则其最低位是 1，因此 arr[i] & 1 结果为 1（真）；如果是偶数，则结果为 0（假）。

最大连续 1 的个数

给定一个二进制数组 nums ，计算其中最大连续 1 的个数。

示例 1：

输入：nums = [1,1,0,1,1,1]
输出：3
解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3.

示例 2:

输入：nums = [1,0,1,1,0,1]
输出：2

提示：

  • 1 <= nums.length <= 105
  • nums[i] 不是 0 就是 1.
官方题解
class Solution {
public:
    int findMaxConsecutiveOnes(vector<int>& nums) {
        int maxCount = 0, count = 0;
        int n = nums.size();
        for (int i = 0; i < n; i++) {
            if (nums[i] == 1) {
                count++;
            } else {
                maxCount = max(maxCount, count);	// 刷新最大计数
                count = 0;
            }
        }
        // 如果数组末位为1不会触发刷新最大计数，需要手动刷新一次最大计数
        maxCount = max(maxCount, count);
        return maxCount;
    }
};

有序数组中的单一元素

给你一个仅由整数组成的有序数组，其中每个元素都会出现两次，唯有一个数只会出现一次。

请你找出并返回只出现一次的那个数。

你设计的解决方案必须满足 O(log n) 时间复杂度和 O(1) 空间复杂度。

示例 1:

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

示例 2:

输入: nums =  [3,3,7,7,10,11,11]
输出: 10
题解

暴力求解很简单，但时间复杂度不满足要求，没想出标准答案。数组有序，复杂度要求为 O (logn)，就是在暗示用二分法。

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        // 遍历前n-1个元素
        for (int i = 0; i < nums.size()-1; i += 2) {
            if (nums[i] != nums[i+1]){
                return nums[i];
            }
        }
        // 默认返回数组最后一个元素
        return nums.back();
    }
};
官方题解
class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        int low = 0, high = nums.size() - 1;
        while (low < high) {
            int mid = (high - low) / 2 + low;
            if (nums[mid] == nums[mid ^ 1]) {
                low = mid + 1;
            } else {
                high = mid;
            }
        }
        return nums[low];
    }
};

先找规律：

(0,1),2,(3,4),(5,6),(7,8) // 索引
(1,1),2,(3,3),(4,4),(8,8) // 数组

数组有序，且两两为一对。可以观察到，在单身狗 2 的左侧，每一对相同元素的前一个元素的索引都是偶数（规律 1）, 比如 0；直到单身狗打破规律，因为它是单独的一个，没有人和它一对，所以从这个单身狗以后的右侧，每一对相同元素的前一个元素的索引就变成了奇数（规律 2），比如 3，5，7。

假设要找的数的索引为 x，我们把符合规律 1 的称为”正常的“，这些数全在 x 的左边，那么”不正常的“就是符合规律 2 的，这些数全在 x 的右边。

使用二分查找，目标是找到 x：

  • 如果 mid 是偶数，就比较 nums[mid] 和 nums[mid+1]，如果相等，说明是正常的符合规律 1，x 在 mid 的右边，此时更新 low=mid；如果不相等，说明规律 1 被打破，那么 x 就在 mid 的左边，此时更新 high=mid。

  • 如果 mid 是奇数，就比较 nums[mid-1] 和 nums[mid]，如果相等，说明是正常的符合规律 1，x 在 mid 的右边，此时更新 low=mid；如果不相等，说明规律 1 被打破，那么 x 就在 mid 的左边，此时更新 high=mid。

这样，不断缩小区间，直到 low=high，就是 x 的索引。

细节

官方题解中没有分奇偶数考虑比较的数，而是使用了 nums[mid] == nums[mid ^ 1]。按位异或运算符 ^ 是一个二元运算符，它对两个操作数的每一位进行比较。如果两个对应的位不同，则结果为 1；如果相同，则结果为 0。

  1. 当 mid 是偶数时，mid + 1 = mid ^ 1

    • 如果 mid 是偶数，它的二进制表示的最低位是 0。

    • mid ^ 1 会将最低位从 0 变成 1，而其他位保持不变。

    • 这等价于将 mid 加上 1。

  2. 当 mid 是奇数时，mid - 1 = mid ^ 1

    • 如果 mid 是奇数，它的二进制表示的最低位是 1。
    • mid ^ 1 会将最低位从 1 变成 0，而其他位保持不变。
    • 这等价于将 mid 减去 1。

模拟

前言

模拟算法是一类通过模仿自然现象或物理过程来解决复杂问题的计算方法。

模拟算法其实就是根据题目做，题目要求什么，就做什么。一些复杂的模拟题其实还是把一些简单的操作组合了一下，所以模拟题是最锻炼耐心的，也是训练编码能力的最好的暴力算法。

数据结构

​ 对于模拟题而言，最关键的其实是数据结构，看到一个问题，选择合适的数据结构，然后根据问题来实现对应的功能。模拟题的常见数据结构主要就是：数组、字符串、矩阵、链表、二叉树 等等。

1、基于数组

​ 利用数组的数据结构，根据题目要求，去实现算法，如：1920.基于排列构建数组、1389.按既定顺序创建目标数组、1603.设计停车系统、2149.按符号重排数组、2221.数组的三角和

2、基于字符串

​ 利用字符串的数据结构，根据题目要求，去实现算法，如：2011.执行操作后的变量值、2744.最大字符串配对数目、LCP 17.速算机器人、537.复数乘法

3、基于链表

​ 利用链表的数据结构，根据题目要求，去实现算法，如：2181.合并零之间的节点、1823.找出游戏的获胜者

4、基于矩阵

​ 利用矩阵的数据结构，根据题目要求，去实现算法，如：2120.执行所有后缀指令、1252.奇数值单元格的数目、832.翻转图像、657.机器人能否返回原点、289.生命游戏、59.螺旋矩阵 II、885.螺旋矩阵 III

5、基于栈

​ 利用栈的数据结构，如：1441.用栈操作构建数组

6、基于队列

​ 利用队列的数据结构，如：1700.无法吃午餐的学生数量

算法技巧

​ 模拟时一般会用到一些算法技巧，或者说混合算法，比如 排序、递归、迭代 等等。

1、排序

​ 排序后，干一件事情，如：950.按递增顺序显示卡牌

2、递归

​ 需要借助递归来实现，如：1688.比赛中的配对次数 、2169.得到 0 的操作数、258.各位相加

3、迭代

​ 不断迭代求解，其实就是利用 while 循环来实现功能，如：1860.增长的内存泄露、258.各位相加

实战

交换数字

交换数字

编写一个函数，不用临时变量，直接交换numbers = [a, b]中a与b的值。

示例：

输入: numbers = [1,2]
输出: [2,1]

提示：

  • numbers.length == 2
  • -2147483647 <= numbers[i] <= 2147483647
题解

不正确的解法：

class Solution {
public:
    vector<int> swapNumbers(vector<int>& numbers) {
        numbers[0] = numbers[1] - numbers[0];
        numbers[1] = numbers[1] - numbers[0];
        numbers[0] = numbers[1] + numbers[0];
        return numbers;
    }
};

最直接的想法就是使用加减法，通过记录两个数的和或者差来消除中间变量。可以通过绝大多数测试用例，但是有溢出风险，如果：

numbers = [-2147483647,2147483647]

对这两个数进行加减就会溢出，需要强转类型。

实际上这个题的考点在于按位异或^的巧用，异或即：相同为0，不同为1，那么一个数异或上它自己就是0，即：a ^ a = 0;

正确解法如下：

class Solution {
public:
    vector<int> swapNumbers(vector<int>& numbers) {
        numbers[0] = numbers[0] ^ numbers[1];
        numbers[1] = numbers[0] ^ numbers[1]; // 此时number[1] = number[0]
        numbers[0] = numbers[0] ^ numbers[1];
        return numbers;
    }
};
STEPnumbers[0]numbers[1]
1numbers[0] ^ numbers[1]numbers[1]
2numbers[0] ^ numbers[1]numbers[0] ^ (numbers[1] ^ numbers[1])= numbers[0]
3numbers[0] ^ numbers[1] ^ numbers[0] = numbers[1]numbers[0]

位1的个数

位1的个数

编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为 汉明重量).）。

提示：

  • 请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
  • 在 Java 中，编译器使用 二进制补码 记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号整数 -3。

示例 1：

输入：n = 11 (控制台输入 00000000000000000000000000001011)
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。

示例 2：

输入：n = 128 (控制台输入 00000000000000000000000010000000)
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。

示例 3：

输入：n = 4294967293 (控制台输入 11111111111111111111111111111101，部分语言中 n = -3）
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。

提示：

  • 输入必须是长度为 32 的 二进制串 。
题解
解法一

和整数按位取值的思路一样，当n不为0时（不为0说明一定有1在），取出低位进行判断：

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int count = 0;
        while (n > 0) {
            if (n % 2) count++;
            n = n / 2;	
        }
        return count;
    }
};
解法二

直接循环检查给定整数 n 的二进制位的每一位是否为 1。当检查第 i 位时，我们可以让 n 与 $2^i $ 进行与运算，根据结果判断这一位是否为1，如果这一位是1，那么与运算的结果就是1，反之为0。

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int ret = 0;
        for (int i = 0; i < 32; i++) {
            if (n & (1 << i)) {
                ret++;
            }
        }
        return ret;
    }
};

找到数组的中间位置

找到数组的中间位置

给你一个下标从 0 开始的整数数组 nums ，请你找到 最左边 的中间位置 middleIndex （也就是所有可能中间位置下标最小的一个）。

中间位置 middleIndex 是满足 nums[0] + nums[1] + ... + nums[middleIndex-1] == nums[middleIndex+1] + nums[middleIndex+2] + ... + nums[nums.length-1] 的数组下标。

如果 middleIndex == 0 ，左边部分的和定义为 0 。类似的，如果 middleIndex == nums.length - 1 ，右边部分的和定义为 0 。

请你返回满足上述条件 最左边 的 middleIndex ，如果不存在这样的中间位置，请你返回 -1 。

示例 1：

输入：nums = [2,3,-1,8,4]
输出：3
解释：
下标 3 之前的数字和为：2 + 3 + -1 = 4
下标 3 之后的数字和为：4 = 4

示例 2：

输入：nums = [1,-1,4]
输出：2
解释：
下标 2 之前的数字和为：1 + -1 = 0
下标 2 之后的数字和为：0

示例 3：

输入：nums = [2,5]
输出：-1
解释：
不存在符合要求的 middleIndex 。

示例 4：

输入：nums = [1]
输出：0
解释：
下标 0 之前的数字和为：0
下标 0 之后的数字和为：0

提示：

  • 1 <= nums.length <= 100
  • -1000 <= nums[i] <= 1000
题解
解法一：暴力求解
class Solution {
public:
    int findMiddleIndex(vector<int>& nums) {
        // 遍历数组，检查是否满足左侧和等于右侧和
        for (int i = 0; i < nums.size(); ++i) {
            int l = 0, r = 0;
            for (int j = 0; j < i; ++j){	// 计算 i 的左侧和
                l += nums[j];
            }
            for (int k = i+1; k < num.size(); ++k){	// 计算 i 的右侧和
                r += nums[k];
            }
            if( l == r){
                return i;
            }
        }
        return -1; // 如果没有找到中间索引
    }
};

解法二：前缀和

class Solution {
public:
    int findMiddleIndex(vector<int>& nums) {
        int totalSum = 0, leftSum = 0;
        
        // 计算数组的总和
        for (int num : nums) {totalSum += num;}
        
        // 遍历数组，检查是否满足左侧和等于右侧和
        for (int i = 0; i < nums.size(); ++i) {
            // 右侧和 = 总和 - 左侧和 - 当前元素
            int rightSum = totalSum - leftSum - nums[i];
            if (leftSum == rightSum) {
                return i;
            }
            leftSum += nums[i]; // 更新左侧和
        }
        
        return -1; // 如果没有找到中间索引
    }
};

递推

递推算法是一种通过已知条件和特定递推关系式，逐步推导出问题结果的算法。它通常以一个明确的初始条件（或边界条件）开始，然后通过递推公式逐步求解后续结果。

递推算法的结构

  1. 初始条件
    • 给定问题的边界或起点。
  2. 递推关系
    • 根据问题规律，确定如何通过前面的结果推导当前结果。
  3. 终止条件
    • 决定何时停止递推。

经典示例：斐波那契数列

斐波那契数列的定义：

F(0) = 0
F(1) = 1
F(n) = F(n−1) + F(n−2) (n≥2)

采用递推算法：

int fibonacci(int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;

    int prev1 = 0, prev2 = 1; // 初始化 F(0) 和 F(1)
    int current;
    for (int i = 2; i <= n; ++i) {
        current = prev1 + prev2; // F(i) = F(i-1) + F(i-2)
        prev1 = prev2;
        prev2 = current;
    }
    return current;
}

递归算法也可以，更容易理解，但有重复计算，可能会超时：

int fibonacci(int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

实战

爬楼梯

爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

提示：

  • 1 <= n <= 45
题解

这道题其实是斐波那契数列的变形。

由于每次可以只能爬1个或2个台阶，所以，如果处在第 i 阶台阶，那么它只能是从第 i-1或者第i-2阶台阶爬上来的，那么就有 f(i) = f(i-1) + f(i-2)。

class Solution {
public:
    int climbStairs(int n) {
        int f = 0, f1 = 1, f2 = 2;

        if (n == 1)
            return f1;
        if (n == 2)
            return f2;

        for (int i = 3; i <= n; ++i) {
            f = f1 + f2;
            f1 = f2;
            f2 = f;
        }
        return f;
    }
};

杨辉三角

杨辉三角

给定一个非负整数 *numRows，*生成「杨辉三角」的前 numRows 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

在这里插入图片描述

示例 1:

输入: numRows = 5
输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]

示例 2:

输入: numRows = 1
输出: [[1]]

提示:

  • 1 <= numRows <= 30
题解
class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> ret(numRows);
        for (int i = 0; i < numRows; ++i) {
            ret[i].resize(i + 1);	// 每一行有 i+1 个元素
            ret[i][0] = ret[i][i] = 1;	// 首尾固定为 1
            // 处理中间元素
            for (int j = 1; j < i; ++j) {
                ret[i][j] = ret[i - 1][j] + ret[i - 1][j - 1]; // 递推关系式
            }
        }
        return ret;
    }
};

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

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

相关文章

第9章：CSS动画和过渡 --[CSS零基础入门]

第9章：CSS动画和过渡 --[CSS零基础入门]

1.过渡 CSS 过渡&#xff08;Transitions&#xff09;是一种简单而有效的方法&#xff0c;用于在元素的状态发生变化时创建平滑的视觉效果。以下是五个具体的例子&#xff0c;展示了如何使用过渡来增强用户交互体验。 示例 1: 按钮颜色和大小变化 这个例子展示了当用户将鼠标…
阅读更多...
如何解决压测过程中JMeter堆内存溢出问题

如何解决压测过程中JMeter堆内存溢出问题

如何解决压测过程中JMeter堆内存溢出问题 背景一、为什么会堆内存溢出&#xff1f;二、解决堆内存溢出措施三、堆内存参数应该怎么调整&#xff1f;四、堆内存大小配置建议 背景 Windows环境下使用JMeter压测运行一段时间后&#xff0c;JMeter日志窗口报错“java.lang.OutOfMe…
阅读更多...
java问题解决_idea导入java项目时包名路径报错解决

java问题解决_idea导入java项目时包名路径报错解决

第一个问题&#xff1a;idea导入java项目时包名路径报错解决 问题1&#xff1a;导入项目之后&#xff0c;没有运行导航 | 软件包名称 graph 与文件路径 src.graph 不对应 解决问题1&#xff1a; 打开项目结构 找到板块中的源代码目录 右键选择源代码 高亮之后就OK了 点击应用…
阅读更多...
【青牛科技】拥有两个独立的、高增益、内部相位补偿的双运算放大器，可适用于单电源或双电源工作——D4558

【青牛科技】拥有两个独立的、高增益、内部相位补偿的双运算放大器，可适用于单电源或双电源工作——D4558

概述&#xff1a; D4558内部包括有两个独立的、高增益、内部相位补偿的双运算放大器&#xff0c;可适用于单电源或双电源工作。该电路具有电压增益高、噪声低等特点。主要应用于音频信号放大&#xff0c;有源滤波器等场合。 D4558采用DIP8、SOP8的封装形式 主要特点&#xff…
阅读更多...
qt-C++语法笔记之mapToGlobal将组件（控件）中的本地坐标系（局部坐标）映射到全局坐标系

qt-C++语法笔记之mapToGlobal将组件（控件）中的本地坐标系（局部坐标）映射到全局坐标系

qt-C语法笔记之mapToGlobal将组件&#xff08;控件&#xff09;中的本地坐标系&#xff08;局部坐标&#xff09;映射到全局坐标系 code review! 文章目录 qt-C语法笔记之mapToGlobal将组件&#xff08;控件&#xff09;中的本地坐标系&#xff08;局部坐标&#xff09;映射到…
阅读更多...
C++核心day3作业

C++核心day3作业

作业&#xff1a; 1.整理思维导图 2.整理课上代码 3.把课上类的三个练习题的构造函数写出来 函数全部类内声明&#xff0c;类外定义 定义一个矩形类Rec&#xff0c;包含私有属性length、width&#xff0c;包含公有成员方法&#xff1a; void set_length(int l); //设置长度v…
阅读更多...
基于Spring Boot库存管理系统

基于Spring Boot库存管理系统

文末获取源码和万字论文&#xff0c;制作不易&#xff0c;感谢点赞支持。 基于Spring Boot库存管理系统 当下&#xff0c;如果还依然使用纸质文档来记录并且管理相关信息&#xff0c;可能会出现很多问题&#xff0c;比如原始文件的丢失&#xff0c;因为采用纸质文档&#xff0c…
阅读更多...
FPGA 17 ，FPGA 与 SR-IOV虚拟化技术，高性能计算与虚拟化技术的结合（FPGA 与 SR-IOV 和 PCI，高性能计算与虚拟化的完美融合）

FPGA 17 ，FPGA 与 SR-IOV虚拟化技术，高性能计算与虚拟化技术的结合（FPGA 与 SR-IOV 和 PCI，高性能计算与虚拟化的完美融合）

目录 前言 一. SR-IOV 的起源与发展 1. SR-IOV 的起源与时间线 2. SR-IOV 的诞生原因 3. SR-IOV 的详细介绍 二. SR-IOV 和 PCI 之间的关系 三. PCI 的起源与演进 1. PCI 的起源与时间线 2. PCI 的关键特性 四. FPGA 的独特魅力 1. FPGA 的定义与特性 2. FPGA 的内…
阅读更多...
【深度学习】深刻理解Masked Autoencoders（MAE）

【深度学习】深刻理解Masked Autoencoders（MAE）

Masked Autoencoders (MAE) 是近年来自监督学习领域中的一项重要创新&#xff0c;尤其在计算机视觉领域取得了显著进展。随着深度学习的快速发展&#xff0c;自监督学习逐渐成为了一种重要的无监督学习方法&#xff0c;它通过从数据中学习表示而不依赖人工标签&#xff0c;极大…
阅读更多...
Oracle报错ORA-01653: 表xx无法通过 8192在表空间中扩展

Oracle报错ORA-01653: 表xx无法通过 8192在表空间中扩展

向Oracle 19g数据库中批量插入数据&#xff0c;当插入近2亿条数据后&#xff0c;报出如下错误&#xff1a; ORA-01653: 表xx无法通过 8192 (在表空间 xx_data 中) 扩展 查看表空间&#xff0c;发现表空间大小已达到32G&#xff0c;表空间无法进行自动扩展了。&#xff08;初始…
阅读更多...
图的遍历（C++实现图【2】）

图的遍历（C++实现图【2】）

目录 1. 图的遍历 1.1 图的广度优先遍历 2.2 图的深度优先遍历 1. 图的遍历 给定一个图G和其中任意一个顶点v0&#xff0c;从v0出发&#xff0c;沿着图中各边访问图中的所有顶点&#xff0c;且每个顶点仅被遍历一次。"遍历"即对结点进行某种操作的意思。 1.1 图的广度…
阅读更多...
群控系统服务端开发模式-应用开发-邮件发送工具类

群控系统服务端开发模式-应用开发-邮件发送工具类

一、邮件发送工具类开发 1、添加框架对应的SDK composer require phpmailer/phpmailer 2、添加工具集 在根目录下extend文件夹下创建Email文件夹&#xff0c;在Email文件夹下添加工具集控制并命名为EmailSender.php <?php /*** 邮件发送工具* User: 龙哥三年风水* Date: …
阅读更多...
如何在vue中使用ECharts

如何在vue中使用ECharts

一. 打开ECharts官网,点击快速入门 下面是ECharts官网的链接 https://echarts.apache.org/ 二.在vue中使用 1.首先先引入Echarts js文件 如下图&#xff0c;下面的第一张图片是官网的实现&#xff0c;第二章图片是我根据官网的实现 2.给ECharts 创建一个DOM容器 3. 使用ec…
阅读更多...
Java版-图论-拓扑排序与有向无环图

Java版-图论-拓扑排序与有向无环图

拓扑排序 拓扑排序说明 对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边<u,v>∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列…
阅读更多...
Nginx安装和配置详解

Nginx安装和配置详解

1.Nginx的安装 1.1运行以下脚本安装 yum install yum-utils -y rpm -Uvh http://nginx.org/packages/centos/7/noarch/RPMS/nginx-release-centos-7-0.el7.ngx.noarch.rpm# 查看所有可安装nginx版本 yum --showduplicates list available nginx yum install nginx-1.24.0 -y …
阅读更多...
Pytest测试框架

Pytest测试框架

Pytest测试框架 测试用例发现规则 默认从当前或者指定文件夹下递归查找文件名以test_开头或者_test结尾的.py文件以Test 开头且&#xff08;不继承自 unittest.TestCase或者含有init方法的类&#xff09;的类函数名以 test_ 开头的测试用例方法 自定义测试用例发现规则 我们…
阅读更多...
【OpenCV】图像阈值

【OpenCV】图像阈值

简单阈值法 此方法是直截了当的。如果像素值大于阈值&#xff0c;则会被赋为一个值&#xff08;可能为白色&#xff09;&#xff0c;否则会赋为另一个值&#xff08;可能为黑色&#xff09;。使用的函数是 cv.threshold。第一个参数是源图像&#xff0c;它应该是灰度图像。第二…
阅读更多...
idea压缩js,css

idea压缩js,css

这是需要的jar包(文章顶部也可以下载) 地址:https://download.csdn.net/download/yuzheh521/90109966?spm1001.2101.3001.9500 压缩js arguments: -jar E:\swj\jar_packages\css_js_compress\yuicompressor-2.4.8.jar --type js --charset utf-8 $FilePath$ -o $FileNameWith…
阅读更多...
css基础记录

css基础记录

基础 选择器 复合选择器 后代选择器 div p {}; 类似如上,找到div中所有的后代,注意是所有的后代 子代选择器 > div > a 只选择div的儿子中有a的 并集选择器 用逗号,分隔 p,div,span,h1 { … } 一般一行写一个 CSS元素显示模式 分为块元素,行内元素 块元素 特点…
阅读更多...
【C++】LeetCode：LCR 078. 合并 K 个升序链表

【C++】LeetCode：LCR 078. 合并 K 个升序链表

题干&#xff1a; 给定一个链表数组&#xff0c;每个链表都已经按升序排列。 请将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 解法&#xff1a;优先队列 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *ne…
阅读更多...
最新文章

Copyright @ 2022~2023