八种常见顺序存储的算法

news2025/2/22 12:35:40

目录

1、线性枚举

1）问题描述

2）动图演示

3）示例说明

4）算法描述

5）源码详解

2、前缀和差分

1）问题描述

2）动图演示

3）样例分析

4）算法描述

5）源码详解

3、双指针

1）问题描述

2）动图演示

3）样例说明

4）算法描述

5）源码详解

4、二分枚举

1）问题描述​编辑

2）动图演示

3）样例说明

4）算法描述

5）源码详解

5、三分枚举

6、插入排序

1）问题描述

2）动图演示

3）样例说明

4）算法描述

5）源码详解

7、选择排序

1）问题描述

2）动图演示

3）样例说明

4）算法描述

5）源码详解

8、冒泡排序

1）问题描述

2）动图演示

3）样例说明

4）算法描述

5）源码详解

1、线性枚举

1）问题描述

2）动图演示

3）示例说明

  蓝色的数据代表的是数组数据，红色的数据代表当前枚举到的数据，这样就可以遍历所有的数据进行逻辑处理了。

4）算法描述

  遍历数组，进行条件判断，条件满足则执行逻辑。这里的条件就是 枚举到的数 是否小于 当前最小值，执行逻辑为 将 当前枚举到的数 赋值给 当前最小值；

5）源码详解

int findMin(int* nums, int numsSize){
    int i, min = 100000;
    for(i = 0; i < numsSize; ++i) {     // (1)
        if(nums[i] < min) {             // (2)
            min = nums[i];
        }
    }
    return min;                         // (3)
}

  • (1) 遍历数组中所有的数；
  • (2) 如果 当前枚举到的数 比记录的变量min小，则将它赋值给min；否则，不做任何处理；
  • (3) 最后，min中存储的就是整个数组的最小值。

2、前缀和差分

1）问题描述

2）动图演示

3）样例分析

  如上图所示，只需要记录一个前缀和，然后就可以通过一次减法将区间的值计算出来。时间复杂度 O(1)。这种就是差分的思想。

原理：

sum[r] = a[1] + a[2] + a[3] + a[l-1] + a[l] + a[l + 1] ...... a[r];

sum[l - 1] = a[1] + a[2] + a[3] + a[l - 1];

sum[r] - sum[l - 1] = a[l] + a[l + 1] + ......+ a[r];

4）算法描述

  第一个枚举，利用一个数组sum，存储前 i 个元素的和。
  第二个枚举，读入 m 组数据 l,r，对每组数据，通过 O(1) 获取答案，即sum[r] - sum[l - 1]​。

5）源码详解

int sum[maxn];
int* prefixSum(int* nums, int numsSize, int m, int *l, int *r){
    int i;
    int *ret;
    for(i = 0; i < numsSize; ++i) {
        sum[i] = nums[i];
        if(i) 
            sum[i] += sum[i-1];                 // (1) 
    }
    ret = (int *) malloc( m * sizeof(int) );    // (2) 
    for(i = 0; i < m; ++i) {
    	int leftsum = l[i] == 0 ? 0 : sum[l[i]-1]; // (3) 
    	int rightsum = sum[r[i]];
    	ret[i] = rightsum - leftsum;            // (4) 
    }
    return ret;
}

  • (1) 计算前缀和；
  • (2) 需要返回的数组；
  • (3) 这里是为了防止数组下标越界；
  • (4) 核心 O(1) 的差分计算；

3、双指针

1）问题描述

2）动图演示

3）样例说明

  维护两个指针 i 和 j，区间 [i,j] 内的子串，应该时刻保持其中所有字符不重复，一旦发现重复字符，就需要自增 i（即执行 i = i + 1）；否则，执行 j = j + 1，直到 j 不能再增加为止。
  过程中，记录合法情况下 j − i + 1 的最大值。

4）算法描述

  如上文所述，这种利用问题特性，通过两个指针，不断调整区间，从而求出问题最优解的算法就叫 “尺取法”，由于利用的是两个指针，所以又叫 “双指针” 算法。
  这里 “尺” 的含义，主要还是因为这类问题，最终要求解的都是连续的序列（子串），就好比一把尺子一样，故而得名。

算法描述如下：
  1）初始化 i = 0, j = i − 1，代表一开始 “尺子” 的长度为 0；
  2）增加 “尺子” 的长度，即 j = j + 1；
  3）判断当前这把 “尺子” [i,j] 是否满足题目给出的条件：
    3.a）如果不满足，则减小 “尺子” 长度，即 i = i + 1，回到 3）；
    3.b）如果满足，记录最优解，回到 2）；

  • 上面这段文字描述的比较官方，其实这个算法的核心，只有一句话：

    满足条件时，j++；不满足条件时，i++；

  • 如图所示，当区间 [i,j] 满足条件时，用蓝色表示，此时 j 自增；反之闪红，此时 i 自增。
    在这里插入图片描述

5）源码详解

int getmaxlen(int n, char *str, int& l, int& r) {
    int ans = 0, i = 0, j = -1, len;   // 1)
    memset(h, 0, sizeof(h));           // 2)
    while (j++ < n - 1) {              // 3)
        ++h[ str[j] ];                 // 4)
        while (h[ str[j] ] > 1) {      // 5)
            --h[ str[i] ];
            ++i;
        }
        len = j - i + 1;              
        if(len > ans)                  // 6)
            ans = len, l = i, r = j;
    }
    return ans;
}

  • 1）初始化 i = 0, j = -1，代表 s[i:j] 为一个空串，从空串开始枚举；
  • 2）需要维护一个哈希表，哈希表记录的是当前枚举的区间 s[i:j] 中每个字符的个数；
  • 3）只推进子串的右端点；
  • 4）在哈希表中记录字符的个数；
  • 5）当 h[ str[j] ] > 1满足时，代表出现了重复字符str[j]，这时候左端点 i 推进，直到没有重复字符为止；
  • 6）记录当前最优解的长度 j - i + 1，更新；
  • 这个算法执行完毕，我们就可以得到最长不重复子串的长度为 ans，并且 i 和 j 这两个指针分别只自增 n 次，两者自增相互独立，是一个相加而非相乘的关系，所以这个算法的时间复杂度为 O(n) 。

4、二分枚举

1）问题描述

2）动图演示

3）样例说明

  需要找值为 5 的这个元素。
  黄色箭头代表都是左区间端点 l，红色箭头代表右区间端点 r。蓝色的数据为数组数据，绿色的数字代表的是数组下标，初始化 l = 0，r = 7，由于数组有序，则可以直接折半，令 mid =(l+r)/2=3，则 55 一定落入区间 [0,3]，这时候令 r = 3，继续执行，直到 l > r 结束迭代。
  最后，当 mid = 2 时，找到数据 5。

4）算法描述

  a）令初始情况下，数组下标从 0 开始，且数组长度为 n，则定义一个区间，它的左端点是      l = 0，右端点是 r = n−1；
  b）生成一个区间中点 mid = (l+r)/2，并且判断 mid 对应的数组元素和给定的目标值的大小关系，主要有三种：
    b.1）目标值 等于 数组元素，直接返回 mid；
    b.2）目标值 大于 数组元素，则代表目标值应该出现在区间 [mid+1,r]，迭代左区间端点：l=mid+1；
    b.3）目标值 小于 数组元素，则代表目标值应该出现在区间 [l,mid−1]，迭代右区间端点：r=mid−1；
  c）如果这时候 l>r，则说明没有找到目标值，返回 −1；否则，回到 b）继续迭代。

5）源码详解

int search(int *nums, int numsSize, int target) {
    int l = 0, r = numsSize - 1;         // (1)
    while(l <= r) {                      // (2)
        int mid = (l + r) >> 1;          // (3)
        if(nums[mid] == target) {   
            return mid;                  // (4)
        }else if(target > nums[mid]) {
            l = mid + 1;                 // (5)
        }else if(target < nums[mid]) {
            r = mid - 1;                 // (6)
        }
    }
    return -1;                           // (7)
}

  • (1) 初始化区间左右端点；
  • (2) 一直迭代左右区间的端点，直到 左端点 大于 右端点 结束；
  • (3) >> 1等价于除 2，也就是这里mid代表的是l和r的中点；
  • (4) nums[mid] == target表示正好找到了这个数，则直接返回下标mid；
  • (5) target > nums[mid]表示target这个数在区间 [���+1,�][mid+1,r] 中，所以才有左区间赋值如下：l = mid + 1;
  • (6) target < nums[mid]表示target这个数在区间 [�,���−1][l,mid−1] 中，所以才有右区间赋值如下：r = mid - 1;
  • (7) 这一步呼应了 (2)，表示这不到给定的数，直接返回 -1；

5、三分枚举

  三分枚举 类似 二分枚举 的思想，也是将区间一下子砍掉一块基本完全不可能的块，从而减小算法的时间复杂度。只不过 二分枚举 解决的是 单调性 问题。而 三分枚举 解决的是 极值问题。

6、插入排序

1）问题描述

  给定一个 n 个元素的数组，数组下标从 0 开始，采用「 插入排序 」将数组按照 「升序」排列。

2）动图演示

3）样例说明

图示含义
蓝色柱形代表尚未排好序的数
绿色柱形代表正在执行 比较 和 移动 的数
橙色柱形代表已经排好序的数
红色柱形代表待执行插入的数

  我们看到，首先需要将 「第二个元素」 和 「第一个元素」 进行 「比较」，如果 前者 小于等于 后者，则将 后者 进行向后 「移动」，前者 则执行插入；
  然后，进行第二轮「比较」，即 「第三个元素」 和 「第二个元素」、「第一个元素」 进行 「比较」， 直到 「前三个元素」 保持有序 。
  最后，经过一定轮次的「比较」 和 「移动」之后，一定可以保证所有元素都是 「升序」 排列的。

4）算法描述

整个算法的执行过程分以下几步：
  1） 循环迭代变量 i=1→n−1；
  2） 每次迭代，令 x=a[i]，j=i−1，循环执行比较 x 和 a[j]，如果产生 x≤a[j] 则执 行 a[j+1]=a[j]。然后执行j=j+1，继续执行 2）；否则，跳出循环，回到 1）。

5）源码详解

#include <stdio.h>

int a[1010];

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

void Output(int n, int *a) {
    for(int i = 0; i < n; ++i) {
        if(i)
            printf(" ");
        printf("%d", a[i]);
    }
    puts("");
}

void InsertSort(int n, int *a) {       // (1)
    int i, j; 
    for(i = 1; i < n; ++i) {
        int x = a[i];                  // (2)
        for(j = i-1; j >= 0; --j) {    // (3)
            if(x <= a[j]) {            // (4)
                a[j+1] = a[j];         // (5)
            }else
                break;                 // (6)
        }
        a[j+1] = x;                    // (7)
    }
} 

int main() {
    int n;
    while(scanf("%d", &n) != EOF) {
        Input(n, a);
        InsertSort(n, a);
        Output(n, a);
    }
    return 0;
}

  • (1) void InsertSort(int n, int *a)为 插入排序 的实现，代表对a[]数组进行升序排序。
  • (2) 此时a[i]前面的 i-1个数都认为是排好序的，令x = a[i]；
  • (3) 逆序的枚举所有的已经排好序的数；
  • (4) 如果枚举到的数a[j]比需要插入的数x大，则当前数往后挪一个位置；
  • (5) 执行挪位置的 �(1)O(1) 操作；
  • (6) 否则，跳出循环；
  • (7) 将x插入到合适位置；

7、选择排序

1）问题描述

  给定一个 �n 个元素的数组，数组下标从 00 开始，采用「 选择排序 」将数组按照 「升序」排列。

2）动图演示

3）样例说明

图示含义
蓝色柱形代表尚未排好序的数
绿色柱形代表正在执行 比较 的数
橙色柱形代表已经排好序的数
红色柱形有两种：1、记录最小元素 2、执行交换的元素

  我们发现，首先从 「第一个元素」 到 「最后一个元素」 中选择出一个 「最小的元素」，和 「第一个元素」 进行 「交换」；
  然后，从 「第二个元素」 到 「最后一个元素」 中选择出一个 「最小的元素」，和 「第二个元素」 进行 「交换」。
  最后，一定可以保证所有元素都是 「升序」 排列的。

4）算法描述

整个算法的执行过程分以下几步：
  1） 循环迭代变量 i=0→n−1；
  2） 每次迭代，令 min=i，j=i+1；
  3） 循环执行比较 a[j] 和 a[min]，如果产生 a[j]<a[min] 则执行 min=j。执行 j=j+1，继续执行这一步，直到 j==n；
  4） 交换 a[i] 和 a[min]，回到 1）。

5）源码详解

#include <stdio.h>

int a[1010];

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

void Output(int n, int *a) {
    for(int i = 0; i < n; ++i) {
        if(i)
            printf(" ");
        printf("%d", a[i]);
    }
    puts("");
}

void Swap(int *a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

void SelectionSort(int n, int *a) {  // (1)
    int i, j;
    for(i = 0; i < n - 1; ++i) {     // (2)
        int min = i;                 // (3)
        for(j = i+1; j < n; ++j) {   // (4)
            if(a[j] < a[min]) {
                min = j;             // (5)
            }
        }
        Swap(&a[i], &a[min]);        // (6) 
    }
}

int main() {
    int n;
    while(scanf("%d", &n) != EOF) {
        Input(n, a);
        SelectionSort(n, a);
        Output(n, a);
    }
    return 0;
}

  • (1) void SelectionSort(int n, int *a)为选择排序的实现，代表对a[]数组进行升序排序。
  • (2) 从首元素个元素开始进行 n−1 次跌迭代。
  • (3) 首先，记录min代表当前第 i 轮迭代的最小元素的下标为 i。
  • (4) 然后，迭代枚举第 i+1 个元素到 最后的元素。
  • (5) 选择一个最小的元素，并且存储下标到 min中。
  • (6) 将 第 i 个元素 和 最小的元素 进行交换。

8、冒泡排序

1）问题描述

  给定一个 n 个元素的数组，数组下标从 0 开始，采用「 冒泡排序 」将数组按照 「升序」排列。

2）动图演示

3）样例说明

图示含义
蓝色柱形代表尚未排好序的数
绿色柱形代表正在执行比较的两个数
黄色柱形代表已经排好序的数

  我们看到，首先需要将 「第一个元素」 和 「第二个元素」 进行 「比较」，如果 前者 大于 后者，则进行 「交换」，然后再比较 「第二个元素」 和 「第三个元素」 ，以此类推，直到 「最大的那个元素」 被移动到 「最后的位置」 。
  然后，进行第二轮「比较」，直到 「次大的那个元素」 被移动到 「倒数第二的位置」 。
  最后，经过一定轮次的「比较」 和 「交换」之后，一定可以保证所有元素都是 「升序」 排列的。

4）算法描述

整个算法的执行过程分以下几步：
  1） 循环迭代变量 i=0→n−1；
  2） 每次迭代，令 j=i，循环执行比较 a[j] 和 a[j+1]，如果产生 a[j]>a[j+1] 则交换两者的值。然后执行 j=j+1，这时候对 j 进行判断，如果 j≥n−1，则回到 1），否则继续执行 2）。

5）源码详解

#include <stdio.h>

int a[1010];

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

void Output(int n, int *a) {
    for(int i = 0; i < n; ++i) {
        if(i)
            printf(" ");
        printf("%d", a[i]);
    }
    puts("");
}

void Swap(int *a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

void BubbleSort(int n, int *a) {             // (1)
    bool swapped;
    int last = n;
    do {
        swapped = false;                     // (2)
        for(int i = 0; i < last - 1; ++i) {  // (3)
            if(a[i] > a[i+1]) {              // (4)
                Swap(&a[i], &a[i+1]);        // (5)
                swapped = true;              // (6)
            }
        }
        --last;
    }while (swapped);
} 

int main() {
    int n;
    while(scanf("%d", &n) != EOF) {
        Input(n, a);
        BubbleSort(n, a);
        Output(n, a);
    }
    return 0;
}

  • (1) void BubbleSort(int n, int *a)为冒泡排序的实现，代表对a[]数组进行升序排序。
  • (2) swapped标记本轮迭代下来，是否有元素产生了交换。
  • (3) 每次冒泡的结果，会执行last的自减，所以待排序的元素会越来越少。
  • (4) 如果发现两个相邻元素产生逆序，则将它们进行交换。保证右边的元素一定不比左边的小。
  • (5) swap实现了元素的交换，这里需要用&转换成地址作为传参。
  • (6) 标记更新。一旦标记更新，则代表进行了交换，所以下次迭代必须继续。

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

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

相关文章

抖音、小红书、视频号是如何判定是否限流的？

抖音、小红书、视频号是如何判定是否限流的？

在这个新媒体营销的时代&#xff0c;抖音、小红书和视频号作为中国最受欢迎的社交媒体平台&#xff0c;为品牌和内容创作者提供了极具潜力的展示空间。然而&#xff0c;无论在哪个平台&#xff0c;限流成为很多人的苦恼。 抖音的推荐算法基于人群画像和初始流量池&#xff0c;同…
阅读更多...
单挑力扣（LeetCode）SQL题：1951. 查询具有最多共同关注者的所有两两结对组（难度：中等）

单挑力扣（LeetCode）SQL题：1951. 查询具有最多共同关注者的所有两两结对组（难度：中等）

题目&#xff1a;1951. 查询具有最多共同关注者的所有两两结对组 &#xff08;通过次数2,464 | 提交次数3,656&#xff0c;通过率67.40%&#xff09; 表: Relations ------------------- | Column Name | Type | ------------------- | user_id | int | | follower_id |…
阅读更多...
ctfshow——文件上传

ctfshow——文件上传

文章目录 文件上传思路web 151web 152web 153知识点解题 web 154web 155web 156web 157web 158web 159 文件上传思路 web 151 打开页面显示&#xff1a;前台校验不可靠。说明这题是前端验证。 右键查看源代码&#xff0c;找到与上传点有关的前端代码&#xff1a;   这里使…
阅读更多...
磁盘相关知识

磁盘相关知识

一、硬盘数据结构 1.扇区&#xff1a; 盘片被分为多个扇形区域&#xff0c;每个扇区存放512字节的数据&#xff08;扇区越多容量越大&#xff09; 存放数据的最小单位 512字节 &#xff08;硬盘最小的存储单位是扇区&#xff0c;512 个字节&#xff0c;八个扇区组成一块&…
阅读更多...
VirtualBox 网络连接配置

VirtualBox 网络连接配置

这几天为了确认笔记本电脑的ssd磁盘型号&#xff0c;拆开电脑查看了一下&#xff0c;并且拔出来又装回去了&#xff0c;就是这个插拔的动作&#xff0c;导致原本能好好运行的虚拟机&#xff0c;突然启动报错启动不起来了。看了启动日志&#xff0c;显示启动的时候磁盘数据校验出…
阅读更多...
leaflet学习笔记-地图缩略图（鹰眼）的添加（三）

leaflet学习笔记-地图缩略图（鹰眼）的添加（三）

介绍 地图缩略图控件有助于用户了解主窗口显示的地图区域在全球、全国、全省、全市等范围内的相对位置&#xff0c;也称为鹰眼图。Leaflet提供了好几种地图缩略图控件&#xff0c;本文介绍其中一个最常用控件&#xff0c;即插件Leaflet.MiniMap。 依赖添加 这些地图控件都可以…
阅读更多...
Zblog主题模板：ZblogitseanPage博客主题模板

Zblog主题模板：ZblogitseanPage博客主题模板

zblog主题模板&#xff1a;ZblogitseanPage博客主题模板 ZblogitseanPage博客主题模板主要是以文字内容为主导&#xff0c;将页面的设计杂乱的图片和元素进行最小化或者去除&#xff0c;从而使整个页面更加简洁、清晰&#xff0c;突出信息的呈现。 下面介绍一下zblog主题模板:Z…
阅读更多...
数据库系统原理例题之——SQL 与关系数据库基本操作

数据库系统原理例题之——SQL 与关系数据库基本操作

SQL 与关系数据库基本操作 第四章 SQL 与关系数据库基本操作【例题】一 、单选题二 、填空题三 、简答题四 、设计题 【答案&解析】一、单选题二、填空题三、简答题四、设计题 【延伸知识点】【延伸知识点答案&解析】 第四章 SQL 与关系数据库基本操作 【例题】 一 、…
阅读更多...
Redis哨兵sentinel

Redis哨兵sentinel

是什么&#xff1f; 哨兵巡查监控后台master主机是否故障&#xff0c;如果故障根据投票数自动将某一个slave库变为master&#xff0c;就行对外服务&#xff0c;称为无人值守运维 能干嘛&#xff1f; 主从监控&#xff1a;监控主从redis库是否正常工作 消息通知&#xff1a;…
阅读更多...
作业--day38

作业--day38

1.定义一个Person类&#xff0c;包含私有成员&#xff0c;int *age&#xff0c;string &name&#xff0c;一个Stu类&#xff0c;包含私有成员double *score&#xff0c;Person p1&#xff0c;写出Person类和Stu类的特殊成员函数&#xff0c;并写一个Stu的show函数&#xff…
阅读更多...
取证工具volatility插件版学习记录

取证工具volatility插件版学习记录

更新时间&#xff1a;2023年12月18日11:48:29 1. 背景描述 在以前学习过volatility的基础功能&#xff0c;主要是使用volatility独立版进行学习的&#xff0c;前几天遇到一个ctf赛事&#xff0c;需要用到的是volatility的mimikatz模块&#xff0c;因为以前没使用过那个模块&…
阅读更多...
Type-C接口显示器PD协议芯片方案-LDR6020

Type-C接口显示器PD协议芯片方案-LDR6020

大家都知道显示器种类有很多种&#xff0c;有桌面显示器&#xff0c;便携显示器&#xff0c;智能显示器&#xff0c;甚至AR眼镜也可以算是一个微型显示器&#xff0c;传输信号的方式也很多种&#xff0c;如HDMI、VGA、DisplayPort、USB-C等等。现在较为统一更新的那就是欧盟规定…
阅读更多...
vue实现滑动切换：切换选项时滑块有滑动过渡的效果

vue实现滑动切换：切换选项时滑块有滑动过渡的效果

效果图 思路&#xff1a; 1. 高亮的色块是独立的一个盒子&#xff0c;需要插入当前激活的内容用来撑开色块盒子的宽度&#xff0c;这样色块的宽度就会和当前激活的内容宽度一致&#xff0c;色块的字体颜色设置透明即可 2. 色块滑动的距离是读当前激活元素的offsetLeft&#x…
阅读更多...
中国蚁剑-antSword

中国蚁剑-antSword

1.简介 蚁剑是一款开源的跨平台Webshell管理工具&#xff0c;它是一个开源的远程管理工具&#xff0c;主要面向于合法授权的渗透测试安全人员以及进行常规操作的网站管理员。蚁剑提供了一个图形化界面&#xff0c;可以通过简单的操作连接和控制目标设备或系统。 蚁剑具有以下…
阅读更多...
POLL机制

POLL机制

文章目录 一、POLL机制1、应用场景2、执行流程 二、程序1、驱动程序2、测试应用程序 三、总结 一、POLL机制 1、应用场景 使用休眠-唤醒的方式等待某个事件发生时&#xff0c;有一个缺点&#xff1a;等待的时间可能很久。我们可以加上一个超时时间&#xff0c;这时就可以使用…
阅读更多...
在linux服务器安装anaconda3

在linux服务器安装anaconda3

下载anaconda3 wget https://repo.anaconda.com/archive/Anaconda3-2023.09-0-Linux-x86_64.sh授权 chmod x Anaconda3-2023.09-0-Linux-x86_64.sh运行安装 ./Anaconda3-2023.09-0-Linux-x86_64.shenter yes 自定义路径&#xff0c;注意路径下的anaconda3文件夹不能已经存…
阅读更多...
基于鸿蒙OS开发一个前端应用

基于鸿蒙OS开发一个前端应用

创建JS工程&#xff1a;做鸿蒙应用开发到底学习些啥&#xff1f; 若首次打开DevEco Studio&#xff0c;请点击Create Project创建工程。如果已经打开了一个工程&#xff0c;请在菜单栏选择File > New > Create Project来创建一个新工程。选择HarmonyOS模板库&#xff0c…
阅读更多...
视频美颜SDK趋势畅想：未来发展方向与应用场景

视频美颜SDK趋势畅想：未来发展方向与应用场景

当下&#xff0c;视频美颜SDK正不断演进&#xff0c;本文将深入探讨视频美颜SDK的发展趋势&#xff0c;探讨未来可能的方向和广泛的应用场景。 1.深度学习与视频美颜的融合 未来&#xff0c;我们可以期待看到更多基于深度学习算法的视频美颜SDK&#xff0c;为用户提供更高质量…
阅读更多...
FinalShell连接虚拟机遇到的问题

FinalShell连接虚拟机遇到的问题

在下载好VM后也安装好了虚拟机&#xff08;我这里使用Centos7.5&#xff09;&#xff0c;但是当使用FinalShell连接虚拟机的时候&#xff0c;一直提示连接超时。。。。 后来找了半天&#xff0c;发现是有次校园网和VM虚拟机冲突&#xff0c;就把虚拟机的网络连接给关了&#x…
阅读更多...
Redis 核心知识总结

Redis 核心知识总结

Redis 核心知识总结 认识 Redis 什么是 Redis&#xff1f; Redis 是一个由 C 语言开发并且基于内存的键值型数据库&#xff0c;对数据的读写操作都是在内存中完成&#xff0c;因此读写速度非常快&#xff0c;常用于缓存&#xff0c;消息队列、分布式锁等场景。 有以下几个特…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023