第九课 排序

news2024/11/24 12:38:19

文章目录

  • 第九课 排序
    • 排序算法
    • lc912.排序数组--中等
      • 题目描述
      • 代码展示
    • lc1122.数组的相对排序--简单
      • 题目描述
      • 代码展示
    • lc56.合并区间--中等
      • 题目描述
      • 代码展示
    • lc215.数组中的第k个最大元素--中等
      • 题目描述
      • 代码展示
    • acwing104.货仓选址--简单
      • 题目描述
      • 代码展示
    • lc493.翻转树--困难
      • 题目描述
      • 代码展示
    • lc327.区间个数--困难
      • 题目描述
      • 代码展示

第九课 排序

排序算法

image-20231007161146336

image-20231007161221689

image-20231007161255331

image-20231007161345682

img

image-20231007161402458

image-20231007161428771

image-20231007161441532

image-20231007161454299

image-20231007161510826

快速排序算法动画演示_哔哩哔哩_bilibili

image-20231007161539374

image-20231007161558662

image-20231007161616925

image-20231007161640929

lc912.排序数组–中等

题目描述

给你一个整数数组 nums，请你将该数组升序排列。

示例 1：

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

示例 2：

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

提示：

  • 1 <= nums.length <= 5 * 104
  • -5 * 104 <= nums[i] <= 5 * 104

代码展示

class Solution {
public:       //堆排序——不会超时
    vector<int> sortArray(vector<int>& nums) {
        heapSort(nums);
        return nums;
    }

private:
    void heapify(vector<int>& nums, int n, int i) {
        int largest = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;

        if (left < n && nums[left] > nums[largest])
            largest = left;

        if (right < n && nums[right] > nums[largest])
            largest = right;

        if (largest != i) {
            swap(nums[i], nums[largest]);
            heapify(nums, n, largest);
        }
    }

    void heapSort(vector<int>& nums) {
        int n = nums.size();

        // 建立最大堆
        for (int i = n / 2 - 1; i >= 0; i--)
            heapify(nums, n, i);

        // 逐步提取元素
        for (int i = n - 1; i > 0; i--) {
            swap(nums[0], nums[i]);
            heapify(nums, i, 0);
        }
    }
};

class Solution {
public:       //归并排序也可以
    vector<int> sortArray(vector<int>& nums) {
        vector<int> tmp(nums.size());
        mergeSort(nums, tmp, 0, nums.size() - 1);
        return nums;
    }

private:
    void merge(vector<int>& nums, vector<int>& tmp, int left, int mid, int right) {
        int i = left;
        int j = mid + 1;
        int k = left;

        while (i <= mid && j <= right) {
            if (nums[i] <= nums[j]) {
                tmp[k++] = nums[i++];
            } else {
                tmp[k++] = nums[j++];
            }
        }

        while (i <= mid) {
            tmp[k++] = nums[i++];
        }

        while (j <= right) {
            tmp[k++] = nums[j++];
        }

        for (int l = left; l <= right; l++) {
            nums[l] = tmp[l];
        }
    }

    void mergeSort(vector<int>& nums, vector<int>& tmp, int left, int right) {
        if (left < right) {
            int mid = left + (right - left) / 2;
            mergeSort(nums, tmp, left, mid);
            mergeSort(nums, tmp, mid + 1, right);
            merge(nums, tmp, left, mid, right);
        }
    }
};

lc1122.数组的相对排序–简单

题目描述

给你两个数组，arr1 和 arr2，arr2 中的元素各不相同，arr2 中的每个元素都出现在 arr1 中。

对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。

示例 1：

输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
输出：[2,2,2,1,4,3,3,9,6,7,19]

示例 2:

输入：arr1 = [28,6,22,8,44,17], arr2 = [22,28,8,6]
输出：[22,28,8,6,17,44]

提示：

  • 1 <= arr1.length, arr2.length <= 1000
  • 0 <= arr1[i], arr2[i] <= 1000
  • arr2 中的元素 arr2[i] 各不相同
  • arr2 中的每个元素 arr2[i] 都出现在 arr1 中

image-20231007162610016

代码展示

你可以使用自定义比较函数来解决这个问题，首先建立一个哈希表，将arr2中的元素与其对应的位置映射起来。然后，使用自定义的比较函数对arr1进行排序，排序规则如下：

  1. 如果a和b都在arr2中，比较它们在arr2中的位置，位置靠前的元素排在前面。
  2. 如果a和b都不在arr2中，直接比较它们的大小。

以下是示例代码：

class Solution {
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        unordered_map<int, int> position;
        for (int i = 0; i < arr2.size(); i++) {
            position[arr2[i]] = i;
        }
        
        sort(arr1.begin(), arr1.end(), [&](int a, int b) {
            if (position.count(a) && position.count(b)) {
                return position[a] < position[b];
            } else if (position.count(a)) {
                return true;
            } else if (position.count(b)) {
                return false;
            } else {
                return a < b;
            }
        });
        
        return arr1;
    }
};

这段代码首先建立了一个哈希表 position，将arr2中的元素与其对应的位置映射起来。然后，使用自定义的比较函数对arr1进行排序，按照上述规则进行比较。这样就能够保证arr1中的元素按照arr2中的相对顺序排列，未在arr2中出现的元素按照升序排在末尾。

如果你想自己实现排序函数，你可以使用计数排序的方法，首先统计arr1中每个元素的出现次数，然后根据arr2的顺序构建排序后的结果。

以下是示例代码：

class Solution {
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        // 统计arr1中每个元素的出现次数
        vector<int> count(1001, 0);
        for (int num : arr1) {
            count[num]++;
        }
        
        vector<int> result;
        // 根据arr2的顺序构建排序后的结果
        for (int num : arr2) {
            while (count[num] > 0) {
                result.push_back(num);
                count[num]--;
            }
        }
        
        // 处理arr2中没有的元素
        for (int i = 0; i <= 1000; i++) {
            while (count[i] > 0) {
                result.push_back(i);
                count[i]--;
            }
        }
        
        return result;
    }
};

这段代码首先使用 count 数组统计了arr1中每个元素的出现次数。然后，根据arr2的顺序构建了排序后的结果，并将结果存储在 result 数组中。最后，处理arr2中没有的元素，将它们按照升序添加到 result 数组中。

这样就能够实现按照arr2的相对顺序对arr1进行排序。

lc56.合并区间–中等

题目描述

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

提示：

  • 1 <= intervals.length <= 104
  • intervals[i].length == 2
  • 0 <= starti <= endi <= 104

image-20231007162657349

代码展示

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        if (intervals.empty()) {
            return {};
        }

        // 对区间进行双关键字排序（按左端点升序，右端点升序）
        sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b) {
            return a[0] == b[0] ? a[1] < b[1] : a[0] < b[0];
        });

        vector<vector<int>> mergedIntervals;
        mergedIntervals.push_back(intervals[0]);

        // 扫描合并
        for (int i = 1; i < intervals.size(); i++) {
            vector<int>& currentInterval = intervals[i];
            vector<int>& previousInterval = mergedIntervals.back();

            if (currentInterval[0] <= previousInterval[1]) {
                // 当前区间和前一个区间重叠，合并区间
                previousInterval[1] = max(previousInterval[1], currentInterval[1]);
            } else {
                // 当前区间和前一个区间不重叠，将当前区间添加到结果中
                mergedIntervals.push_back(currentInterval);
            }
        }

        return mergedIntervals;
    }
};

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        /*[1, 5]  [2, 6] [3, 4] [6, 10]  [11 12]
           1 2 3 4 5 6 7 8 9 10 11 12
           1 1 1 1 1
             1 1 1 1 1
               1 1
                     1 1 1 1  1
                                  1 1
           
           +1      -1
             +1      -1
               +1-1
                     +1        -1
                               +1 -1
         count: 0
        把从1覆盖到5这个区间，看作2个事件：
        (a) 在1处，有一个事件：开始覆盖（次数+1）
        (b) 在5处，有一个事件：结束覆盖（次数-1）
        */
        // 产生2n个事件
        // 时间位置，时间情况(+1/-1)
        vector<pair<int,int>> events;
        for (vector<int>& interval : intervals) {
            // 差分
            events.push_back(make_pair(interval[0], 1));
            events.push_back(make_pair(interval[1], -1));
        }
        sort(events.begin(), events.end(),
             [](pair<int,int>& a, pair<int,int>& b) {
                 // 1 在 -1 之前（如果差分是闭区间[1,5]而不是前闭后开[1,6)的话
                 return a.first < b.first || (a.first == b.first && a.second > b.second);
             });
        int count = 0;
        int left;
        vector<vector<int>> ans;
        for (pair<int,int>& event : events) {
            if (count == 0) // 加之前是0，加之后是非0
                left = event.first;  // 一个段的产生
            count += event.second;
            if (count == 0) // 非零变零，一个段的结束
                ans.push_back({left, event.first});
        }
        return ans;
    }
};

lc215.数组中的第k个最大元素–中等

题目描述

给定整数数组 nums 和整数 k，请返回数组中第 **k** 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例 1:

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

示例 2:

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

提示：

  • 1 <= k <= nums.length <= 105
  • -104 <= nums[i] <= 104

代码展示

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        int left = 0;
        int right = nums.size() - 1;
        
        while (left <= right) {
            int pivotIndex = partition(nums, left, right);
            if (pivotIndex == k - 1) {
                return nums[pivotIndex];
            } else if (pivotIndex < k - 1) {
                left = pivotIndex + 1;
            } else {
                right = pivotIndex - 1;
            }
        }
        
        return -1; // 如果输入无效或 k 超出范围，可以返回一个特殊值
    }

    int partition(vector<int>& nums, int left, int right) {
        int pivot = nums[left];
        int l = left + 1;
        int r = right;
        
        while (l <= r) {
            if (nums[l] < pivot && nums[r] > pivot) {
                swap(nums[l++], nums[r--]);
            }
            if (nums[l] >= pivot) l++;
            if (nums[r] <= pivot) r--;
        }
        
        swap(nums[left], nums[r]);
        return r;
    }
};

acwing104.货仓选址–简单

题目描述

image-20231007163635776

代码展示

#include <algorithm>

using namespace std;

const int N = 100005;

int n, res;
int a[N];

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);

    sort(a, a + n);

    for (int i = 0; i < n; i ++ ) res += abs(a[i] - a[n >> 1]);
    printf("%d\n", res);

    return 0;
}

lc493.翻转树–困难

题目描述

给定一个数组 nums ，如果 i < j 且 nums[i] > 2*nums[j] 我们就将 (i, j) 称作一个*重要翻转对*。

你需要返回给定数组中的重要翻转对的数量。

示例 1:

输入: [1,3,2,3,1]
输出: 2

示例 2:

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

注意:

  1. 给定数组的长度不会超过50000。
  2. 输入数组中的所有数字都在32位整数的表示范围内。

代码展示

class Solution {
public:
    int reversePairs(vector<int>& nums) {
        int n = nums.size();
        if (n <= 1) {
            return 0; // 如果数组长度小于等于1，不存在翻转对
        }

        vector<int> temp(n); // 用于归并排序的辅助数组
        return mergeSort(nums, temp, 0, n - 1);
    }

    int mergeSort(vector<int>& nums, vector<int>& temp, int left, int right) {
        if (left >= right) {
            return 0; // 当子数组长度为1时，不再拆分，返回0
        }

        int mid = left + (right - left) / 2;
        int count = mergeSort(nums, temp, left, mid) + mergeSort(nums, temp, mid + 1, right);

        int i = left; // 左子数组的起始位置
        int j = mid + 1; // 右子数组的起始位置
        int k = left; // 辅助数组的起始位置

        // 统计翻转对的数量
        while (i <= mid) {
            while (j <= right && static_cast<long long>(nums[i]) > 2LL * nums[j]) {
                j++;
            }
            count += (j - (mid + 1)); // 统计右子数组中满足条件的元素数量
            i++;
        }

        // 归并排序合并两个子数组，并保持有序性
        i = left;
        j = mid + 1;
        while (i <= mid && j <= right) {
            if (nums[i] <= nums[j]) {
                temp[k++] = nums[i++];
            } else {
                temp[k++] = nums[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = nums[i++];
        }
        while (j <= right) {
            temp[k++] = nums[j++];
        }

        for (i = left; i <= right; i++) {
            nums[i] = temp[i];
        }

        return count;
    }
};

要解决这个问题，可以使用归并排序的思想来统计重要翻转对的数量。具体步骤如下：

  1. 将原始数组拆分成两个子数组。
  2. 分别对两个子数组进行排序。
  3. 遍历其中一个子数组的元素，并查找另一个子数组中满足条件的元素，以统计重要翻转对的数量。
  4. 合并两个子数组时，继续维护它们的有序性。

这段代码首先将原始数组拆分成两个子数组，然后对这两个子数组分别进行归并排序。在归并排序的过程中，统计满足条件的翻转对的数量，并在合并时维护子数组的有序性。最终，返回翻转对的数量。时间复杂度为O(n*log(n))。

lc327.区间个数–困难

题目描述

给你一个整数数组 nums 以及两个整数 lower 和 upper 。求数组中，值位于范围 [lower, upper] （包含 lower 和 upper）之内的 区间和的个数 。

区间和 S(i, j) 表示在 nums 中，位置从 i 到 j 的元素之和，包含 i 和 j (i ≤ j)。

示例 1：

输入：nums = [-2,5,-1], lower = -2, upper = 2
输出：3
解释：存在三个区间：[0,0]、[2,2] 和 [0,2] ，对应的区间和分别是：-2 、-1 、2 。

示例 2：

输入：nums = [0], lower = 0, upper = 0
输出：1

提示：

  • 1 <= nums.length <= 105
  • -231 <= nums[i] <= 231 - 1
  • -105 <= lower <= upper <= 105
  • 题目数据保证答案是一个 32 位 的整数

代码展示

class Solution {
public:
    int countRangeSum(vector<int>& nums, int lower, int upper) {
        int n = nums.size();
        vector<long long> prefixSum(n + 1, 0);
        for (int i = 0; i < n; i++) {
            prefixSum[i + 1] = prefixSum[i] + nums[i];
        }
        return countAndMerge(prefixSum, 0, n, lower, upper);
    }

    int countAndMerge(vector<long long>& prefixSum, int left, int right, int lower, int upper) {
        if (left == right) {
            return 0; // 递归结束条件
        }
        int mid = left + (right - left) / 2;
        int count = countAndMerge(prefixSum, left, mid, lower, upper) +
                    countAndMerge(prefixSum, mid + 1, right, lower, upper);

        int i = left;
        int j = mid + 1;
        int k = mid + 1;
        while (i <= mid) {
            while (j <= right && prefixSum[j] - prefixSum[i] < lower) {
                j++;
            }
            while (k <= right && prefixSum[k] - prefixSum[i] <= upper) {
                k++;
            }
            count += (k - j);
            i++;
        }

        // 归并排序
        vector<long long> sorted(right - left + 1, 0);
        int p1 = left;
        int p2 = mid + 1;
        int p = 0;
        while (p1 <= mid || p2 <= right) {
            if (p1 > mid) {
                sorted[p++] = prefixSum[p2++];
            } else if (p2 > right) {
                sorted[p++] = prefixSum[p1++];
            } else {
                if (prefixSum[p1] < prefixSum[p2]) {
                    sorted[p++] = prefixSum[p1++];
                } else {
                    sorted[p++] = prefixSum[p2++];
                }
            }
        }

        for (int i = 0; i < sorted.size(); i++) {
            prefixSum[left + i] = sorted[i];
        }

        return count;
    }
};

要解决这个问题，可以使用归并排序和前缀和的结合方法。具体步骤如下：

  1. 计算前缀和数组 prefixSum，其中 prefixSum[i] 表示 nums 数组中前 i 个元素的和。
  2. 定义一个递归函数 countAndMerge 用于统计区间和个数并归并排序 prefixSum 数组。
  3. 在 countAndMerge 函数中，首先计算中间索引 mid，然后递归计算左半部分和右半部分的区间和个数。
  4. 接下来，合并左半部分和右半部分的区间和，统计符合要求的区间和个数。
  5. 最后，返回区间和个数。

这段代码首先计算前缀和数组 prefixSum，然后使用递归函数 countAndMerge 统计区间和个数并归并排序 prefixSum 数组。在 countAndMerge 函数中，通过归并排序合并左半部分和右半部分的区间和，同时统计满足要求的区间和个数。最终，返回区间和个数。时间复杂度为O(n*log(n))。

image-20231007164248984

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

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

相关文章

保护 Web 服务器安全性

保护 Web 服务器安全性

面向公众的系统&#xff08;如 Web 服务器&#xff09;经常成为攻击者的目标&#xff0c;如果这些业务关键资源没有得到适当的保护&#xff0c;可能会导致安全攻击&#xff0c;从而导致巨大的财务后果&#xff0c;并在客户中失去良好的声誉。 什么是网络服务器审核 当有人想要…
阅读更多...
无线振弦采集仪在岩土工程中如何远程监测和远程维护

无线振弦采集仪在岩土工程中如何远程监测和远程维护

无线振弦采集仪在岩土工程中如何远程监测和远程维护 随着岩土工程施工的不断发展和科技水平的不断提高&#xff0c;远程监测和远程维护设备也得到了广泛关注和应用。无线振弦采集仪是一种广泛应用于岩土工程中的测量仪器&#xff0c;在现代化施工中扮演着重要的角色。本文将就…
阅读更多...
ChromeDriver驱动最新版下载

ChromeDriver驱动最新版下载

下载地址ChromeDriver - WebDriver for Chrome - Downloads selenium.common.exceptions.SessionNotCreatedException: Message: session not created: This version of ChromeDriver only supports Chrome version 113 Current browser version is 117.0.5938.150 with binar…
阅读更多...
2、模块传参和依赖

2、模块传参和依赖

一、模块传参 使用函数 module_param(name,type,perm); 将指定的全局变量设置成模块参数 /* name:全局变量名 type&#xff1a;使用符号 实际类型 传参方式bool bool insmod xxx.ko 变量名0 或 1invbool bool insmod xx…
阅读更多...
运营商sdwan优缺点及sdwan服务商优势

运营商sdwan优缺点及sdwan服务商优势

SD-WAN(软件定义广域网)作为一种重要的网络解决方案&#xff0c;已经受到了广泛的关注和采用。然而&#xff0c; 无论是由传统运营商提供的SD-WAN还是专门的SD-WAN服务提供商&#xff0c;都存在各自的优缺点。 运营商提供的SD-WAN的缺点&#xff1a; 1. 有限的灵活性&#xf…
阅读更多...
数据库查询详解

数据库查询详解

数据库查询操作 前置&#xff1a;首先我们创建一个练习的数据库 /* SQLyog Professional v12.09 (64 bit) MySQL - 5.6.40-log : Database - studentsys ********************************************************************* *//*!40101 SET NAMES utf8 */;/*!40101 SET …
阅读更多...
【uniapp】自定义导航栏时，设置安全距离,适配不同机型

【uniapp】自定义导航栏时，设置安全距离,适配不同机型

1、在pages.json中&#xff0c;给对应的页面设置自定义导航栏样式 {"path": "pages/index/index","style": {"navigationStyle": "custom","navigationBarTextStyle": "white","navigationBarTitl…
阅读更多...
智慧电力物联网系统引领电力行业数字化发展

智慧电力物联网系统引领电力行业数字化发展

智慧电力物联网系统是以提高用户侧电力运行安全、降低运维成本为目的的一套电力运维管理系统。综合分析采用智慧物联网、人工智能等现代化经济信息网络技术&#xff0c;配置智能采集终端、小安神童值班机器人或边缘网关&#xff0c;实现对企事业用户供配电系统的数字化远程监控…
阅读更多...
网关、网桥、路由器和交换机之【李逵与李鬼】

网关、网桥、路由器和交换机之【李逵与李鬼】

概念 网关 网关简单来说是连接两个网络的设备，现在很多局域网都是采用路由器来接入网络，因此现在网关通常指的就是路由器的IP。网关可用于家庭或者小型企业，连接局域网和Internet，也有用于工业应用的。 网桥 网桥也叫桥接器，是连接两个局域网的一种存储/转发设备，它能…
阅读更多...
Python字符串处理：掌握文本的艺术

Python字符串处理：掌握文本的艺术

更多资料获取 &#x1f913; 作者主页&#xff1a;涛哥聊Python &#x1f4da; 个人网站&#xff1a;涛哥聊Python 在Python编程中&#xff0c;字符串是一种不可或缺的数据类型&#xff0c;用于表示文本和字符数据。本文将深入探讨Python字符串的各个方面&#xff0c;从基础概…
阅读更多...
网络安全（黑客技术）—小白自学笔记

网络安全（黑客技术）—小白自学笔记

1.网络安全是什么 网络安全可以基于攻击和防御视角来分类&#xff0c;我们经常听到的 “红队”、“渗透测试” 等就是研究攻击技术&#xff0c;而“蓝队”、“安全运营”、“安全运维”则研究防御技术。 2.网络安全市场 一、是市场需求量高&#xff1b; 二、则是发展相对成熟入…
阅读更多...
缓冲流 java

缓冲流 java

字节缓冲池的默认大小 &#xff08;8192/byte&#xff09;字节输入输出流 字节缓冲输入接口也是 InputStream 读字节 实现类BufferedInputStream 字节缓冲输出接口也是 OutputStream 写字节 实现类BufferedOutputStream package BufferFlow;import CopysIO.Myconnectio…
阅读更多...
vue-next-admin本地部署

vue-next-admin本地部署

开源地址 文档 本次学习的代码地址https://gitee.com/lyt-top/vue-next-admin/tree/vue-next-admin-nest/&#xff0c;这个做了前后端分离方便学习 部署 下载代码&#xff0c;解压 后台 创建数据库 CREATE DATABASE vuenextadmin01 CHARACTER SET utf8 COLLATE utf8_bin;…
阅读更多...
25 mysql like 是否使用索引

25 mysql like 是否使用索引

前言 这里主要是 探究一下 explain $sql 中各个 type 诸如 const, ref, range, index, all 的查询的影响, 以及一个初步的效率的判断 这里会调试源码来看一下 各个类型的查询 需要 lookUp 的记录 以及 相关的差异 此系列文章建议从 mysql const 查询 开始看 测试表结构…
阅读更多...
大文件上传，前端vue 做分片上传

大文件上传，前端vue 做分片上传

html – 以弹窗的形式 <!-- 上传算法文件 --> <el-dialog title"上传算法文件" :visible.sync"uploadPop" width"60%" :close-on-click-modal"false" :before-close"closeUploadPop" append-to-body custom-class…
阅读更多...
完美收官丨深圳信驰达科技IOTE 2023第二十届国际物联网展参展回顾

完美收官丨深圳信驰达科技IOTE 2023第二十届国际物联网展参展回顾

►►►展会风采 2023年9月22日&#xff0c;为期三天的IOTE 2023第二十届国际物联网展 • 深圳站在深圳国际会展中心&#xff08;宝安馆&#xff09;9、10、11号馆圆满落幕。本届展会以“IoT构建数字经济底座”为主题&#xff0c;吸引覆盖IoT全栈生态的参展商&#xff0c;展出超…
阅读更多...
【数据结构】快排的详细讲解

【数据结构】快排的详细讲解

目录&#xff1a; 介绍 一&#xff0c;递归快排确定基准值 二&#xff0c;递归遍历 三&#xff0c;非递归的快排 四&#xff0c;快排的效率 介绍 快排是排序算法中效率是比较高的&#xff0c;快排的基本思想是运用二分思想&#xff0c;与二叉树的前序遍历类似&#xff0c;…
阅读更多...
C++ 之如何将数组传递给函数？

C++ 之如何将数组传递给函数？

在本文中&#xff0c;您将学习将数组传递给C 中的函数。您将学习如何传递一维和多维数组。 数组可以作为参数传递给函数。也可以从函数返回数组。考虑以下示例&#xff0c;将一维数组传递给函数&#xff1a; 示例1&#xff1a;将一维数组传递给函数 C 程序通过将一维数组传递…
阅读更多...
从事嵌入式工作有哪些优势?

从事嵌入式工作有哪些优势?

随着物联网和人工智能的发展&#xff0c;嵌入式技术越来越值钱&#xff0c;学嵌入式的人也越来越多&#xff0c;现在开始入行嵌入式。根据一些权威部门统计&#xff0c;我国目前嵌入式软件人才缺口每年为40万人左右&#xff0c;嵌入式人才供给一直处于供不应求的状态。 那么从…
阅读更多...
Docker私有仓库打开2375端口（linux）

Docker私有仓库打开2375端口（linux）

前言 在我们开发测试过程中&#xff0c;需要频繁的更新docker镜像&#xff0c;然而默认情况下&#xff0c;docker的2375端口是关闭的&#xff0c;下面介绍如何打开端口。 1、打开步骤 1.1、修改配置 登录docker所在服务器&#xff0c;修改docker.service文件 vi /usr/lib/sys…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023