数据结构，第8章：排序(复习）

目录

直接插入排序：

1. (程序题)

折半插入排序：

希尔排序：

3. (程序题)

冒泡排序 ：

2. (程序题)

快速排序 ：

5. (程序题)

 简单选择排序：

4. (程序题)

堆排序：

6. (程序题)

前置知识： 

稳定排序：如果有两个相等的元素在排序前后的相对顺序保持不变，那么排序算法是稳定的。

直接插入排序：

直接插入排序（Insertion Sort）是一种简单直观的排序算法，其基本思想是将待排序的序列分成两部分，已排序部分和未排序部分。初始时，已排序部分只包含第一个元素，然后从未排序部分取出元素，插入到已排序部分的适当位置，使得已排序部分仍然有序。重复这个过程，直到未排序部分为空。

基本思想：排序方法中,从未排序序列中依次取出元素与已排序序列中的元素进行比较,将其放入已排序序列的正确位置上。

1. (程序题)

试设计算法实现直接插入排序,输出在第m趟排序后的结果

输入数据两行：

第1行：多个需要排序的整数，以0结束

第2行：数m，表示第几趟的插入算法

输入：

2 5 3 4 8 7 9 6 1 0

5
输出：
2 3 4 5 7 8 9 6 1 

#include <iostream>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <utility>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <math.h>
#include <map>
#include <sstream>
#include <deque>
#include <unordered_map>using namespace std;
typedef long long LL;
const int N = 1e4;int ar[N];
int n;// 插入排序函数
void sort(int m) {for (int i = 2; i <= n && m; i++) {m--;if (ar[i - 1] > ar[i]) {ar[0] = ar[i];int j;for (j = i - 1; j > 0 && ar[0] < ar[j]; j--)ar[j + 1] = ar[j];ar[j + 1] = ar[0];}}
}int main() {do {cin >> ar[++n];} while (ar[n]);n--; int m;cin >> m;//m = n - 1;sort(m);for (int i = 1; i <= n; i++) {cout << ar[i] << " ";}return 0;
}

用例1：

输入

2 5 3 4 8 7 9 6 1 0 5

输出

2 3 4 5 7 8 9 6 1

用例2：

输入

2 5 3 1 6 10 19 4 18 22 0 6

输出

1 2 3 5 6 10 19 4 18 22

折半插入排序：

折半插入排序是在直接插入排序的基础上的改进，使用二分查找确定插入的位置，虽然移动的次数不变，但是查找的效率得到了明显的提升。

#include <iostream>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <utility>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <math.h>
#include <map>
#include <sstream>
#include <deque>
#include <unordered_map>using namespace std;
typedef long long LL;
const int N = 1e4;int ar[N];
int n;// 插入排序函数
void sort() {for (int i = 2; i <= n ; i++) {if (ar[i - 1] > ar[i]) {ar[0] = ar[i];int j;int l = 1, r = i-1, mid, ret = 1;while (l <= r) {mid = l + (r - l) / 2;if (ar[mid]<=ar[0]) {l = mid + 1;}else {r = mid - 1;ret = mid;}}for (j = i - 1; j >= ret ; j--)ar[j + 1] = ar[j];ar[ret] = ar[0];}}
}int main() {do {cin >> ar[++n];} while (ar[n]);n--;sort();for (int i = 1; i <= n; i++) {cout << ar[i] << " ";}return 0;
}

希尔排序：

希尔排序也是出入排序的一种改进版，通过固定的距离的跳跃取数将序列分为多组，每组内进行插入排序，最终实现序列的排序。 不难看出，简单插入排序就是间距为1的希尔排序。

希尔排序的时间复杂度是一个很难求解的问题，但大量的实验和研究表明，当增量序列为 dt[k]=2^(t-k+1)-1 时，时间复杂度为 O(n^(3/2)),其中 t 为排序趟数，1<=k<=t<=log2(n+1），当 n 趋向与无穷时 复杂度可以为 O（n(log2(n))^2)。

3. (程序题)

试编写算法，实现希尔排序。

输出在第m趟排序后的结果

输入数据两行：

第1行：多个需要排序的整数，以0结束

第2行：数m，表示第几趟的希尔排序算法

增量序列统一取【5，3，1】

输入：

1 8 4 6 7 9 5 3 2 11 0

1

输出：
1 5 3 2 7 9 8 4 6 11

#include <iostream>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <utility>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <math.h>
#include <map>
#include <sstream>
#include <deque>
#include <unordered_map>using namespace std;typedef long long LL;
const int N = 1e4;int n;
int ar[N], d[3] = {5, 3, 1};void F(int u) {for (int i = 1 + u; i <= n; i++) {if (ar[i] < ar[i - u]) {ar[0] = ar[i];int j;for (j = i - u; j > 0 && ar[0] < ar[j]; j -= u)ar[j + u] = ar[j];ar[j + u] = ar[0];}}
}void sort(int m) {for (int i = 0; i < 3 && i < m; i++) {F(d[i]);}
}int main() {do {cin >> ar[++n];} while (ar[n]);n--;int m;cin >> m;sort(m);for (int i = 1; i <= n; i++) {cout << ar[i] << " ";}return 0;
}

输入

3 15 9 15 10 4 8 12 20 13 0 2

输出

3 8 4 13 10 9 15 12 20 15

输入

1 8 4 6 7 9 5 3 2 11 0 1

输出

1 5 3 2 7 9 8 4 6 11

输入

100 81 4 66 7 9 55 3 2 11 9 0 3

输出

2 3 4 7 9 9 11 55 66 81 100

冒泡排序 ：

冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历待排序数组，一次比较两个元素，如果它们的顺序错误就交换它们。遍历数组的工作是重复地进行直到没有再需要交换，也就是数组已经排序完成。

基本思想：排序时扫描待排序记录序列,顺次比较相邻的两个元素的大小,逆序时就交换位置。

2. (程序题)

试设计算法实现冒泡排序。输出在第m趟排序后的结果

输入数据两行：

第1行：多个需要排序的整数，以0结束

第2行：数m，表示第几趟后的冒泡算法

输入：
2 4 3 9 6 8 7 5 1 0

3
输出：
2 3 4 6 5 1 7 8 9 

#include <iostream>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <utility>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <math.h>
#include <map>
#include <sstream>
#include <deque>
#include <unordered_map>using namespace std;typedef long long LL;
const int N = 1e4;int ar[N];
int n;void sort(int m) {for (int i = 1, flg = 0; i <= m; i++, flg = 0) {for (int j = 1; j <= n - i; j++) {if (ar[j] > ar[j + 1]) {flg = 1;ar[0] = ar[j];ar[j] = ar[j + 1];ar[j + 1] = ar[0];}}if (flg == 0)break;}
}int main() {do {cin >> ar[++n];} while (ar[n]);n--;int m;cin >> m;sort(m);for (int i = 1; i <= n; i++) {cout << ar[i] << " ";}return 0;
}

输入

2 4 3 9 6 8 7 5 1 0 3

输出

2 3 4 6 5 1 7 8 9

输入

3 15 9 15 10 4 8 12 0 4

输出

3 4 8 9 10 12 15 15

快速排序 ：

快速排序是由冒泡排序改进而得。在冒泡排序中，只对相邻的两个记录进行比较，因此每次交换两个相邻记录时只能消除一个逆序。如果能通过两个（不相邻）的记录的一次交换，消除多个逆序，则会大大加快排序的速度。快速排序方法中的一次交换可消除多个逆序。

算法步骤：

选择一个数，通常为第一个，通过交换排序将比这个数大的放到右边，比这个数小的放到左边，然后再使用递归方法，同样的处理两边的数，知道所有的数都有序。

平均时间复杂度O(nlog2(n))

不难发现快速排序的递归过程是一棵二叉树

快速排序（Quick Sort）是一种基于分治思想的排序算法。它选择一个基准元素，将数组分为两个子数组，使得左边的元素都小于基准元素，右边的元素都大于基准元素。然后递归地对左右子数组进行排序。快速排序是一种高效的排序算法，其平均时间复杂度为 O(n log n)。

5. (程序题)

试编写算法实现快速排序算法。

输入：
1 8 4 6 7 9 5 3 2 0
输出：
1 2 3 4 5 6 7 8 9

#include <iostream>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <utility>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <math.h>
#include <map>
#include <sstream>
#include <deque>
#include <unordered_map>
using namespace std;
typedef long long LL;
const int N = 1e4;
int n;
int ar[N];
void sort(int L, int R) {if (L >= R)return;int t = ar[L];int l = L, r = R;while (l < r) {while (ar[r] >= t && l < r) {r--;}if (ar[r] < t)ar[l] = ar[r];while (ar[l] <= t && l < r) {l++;}if (ar[l] > t)ar[r] = ar[l];}ar[l] = t;sort(L, l - 1);sort(l + 1, R);
}int main() {do {cin >> ar[++n];} while (ar[n]);n--;sort(1, n);for (int i = 1; i <= n; i++) {cout << ar[i] << " ";}return 0;
}

输入

1 8 4 6 7 9 5 3 2 0

输出

1 2 3 4 5 6 7 8 9

输入

9 15 3 15 10 4 8 12 0

输出

3 4 8 9 10 12 15 15

 简单选择排序：

算法思路：

依次选出最小、第二小、第三小……最大的数，存入对应的位置。

4. (程序题)

试设计算法实现简单选择排序。

输出在第m趟排序后的结果

输入数据两行：

第1行：多个需要排序的整数，以0结束

第2行：数m，表示第几趟的排序

输入：
1 8 4 6 7 9 5 3 2 0

3
输出：
1 2 3 6 7 9 5 4 8 

#include <iostream>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <utility>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <math.h>
#include <map>
#include <sstream>
#include <deque>
#include <unordered_map>
using namespace std;
typedef long long LL;
const int N = 1e4;
int n;
int ar[N], d[3] = { 5, 3, 1 };
void sort(int m) {for (int i = 1; i < n && m; i++) {m--;int mn = i;for (int j = i; j <= n; j++) {if (ar[j] < ar[mn]) {mn = j;}}ar[0] = ar[i];ar[i] = ar[mn];ar[mn] = ar[0];}
}int main() {do {cin >> ar[++n];} while (ar[n]);n--;int m;cin >> m;sort(m);for (int i = 1; i <= n; i++) {cout << ar[i] << " ";}return 0;
}

输入

1 8 4 6 7 9 5 3 2 0 3

输出

1 2 3 6 7 9 5 4 8

输入

53 82 9 233 43 14 55 9 4 67 0 4

输出

4 9 9 14 43 233 55 82 53 67

输入

44 9 89 14 43 233 55 82 53 67 0 5

输出

9 14 43 44 53 233 55 82 89 67

堆排序：

在计算机科学中，堆（Heap）是一种基于树的数据结构，它具有以下特点：

  1. 完全二叉树结构： 堆通常被实现为一棵完全二叉树，这意味着除了最底层，其他层的节点都被填满，而且最底层的节点都集中在左侧。

  2. 堆序性质： 堆分为最大堆和最小堆。在最大堆中，每个节点的值都大于或等于其子节点的值；而在最小堆中，每个节点的值都小于或等于其子节点的值。

堆通常用于实现优先队列等抽象数据类型，其中最大（或最小）元素可以迅速地被查找和删除。

根据堆的性质，我们可以将堆分为两种主要类型：

  1. 最大堆（Max Heap）（大根堆）： 最大堆的每个节点的值都大于或等于其子节点的值。根节点包含堆中的最大元素。

  2. 最小堆（Min Heap）（小根堆）： 最小堆的每个节点的值都小于或等于其子节点的值。根节点包含堆中的最小元素。

堆排序通常使用数组来存储，但不限于数组，也可以用链表的方式进行存储，这里为方便起见使用数组进行演示。

这里首先要知道怎么用数组模拟完全二叉树：输出 key[1……n] 中 key[s] 的左节点为 key[2*s] ，右节点为 key[2*s+1]。且有 n 个节点的二叉树的深度 不会超过 log2(n)+1，非叶子节点的下标最大的节点下标为 n/2。

知道的这些就可进行推排序了：首先将所有的数据存入数组 key 中，从对的特点不难看出堆与二叉树的许多操作一样，具有递归性质，所以我们在对的排序过程中也会利用这一递归性质：搜先利用 HeapAdjust 函数对堆进行调整，使它成为大根堆或小根堆，这里以大根堆为例；先从非叶子节点的下标最大的节点 n/2 开始，对以 n/2 下标为根的二叉树进行堆排序，再对以 n/2-1，n/2-2……1 为根的二叉树进行堆排序。利用堆排序的递归性质，最大限度的提高算法的效率。

 HeapAdjust 函数：比较当前点与它左右孩子的大小，将它与他们三者中的最大值交换，继续以跟踪最大值，重复上述过程，知道不在变化为止。过程可以理解为大的值不断地往上浮，小的值不断往下沉。

时间复杂度O(nlog2(n)) 

6. (程序题)

试编写算法实现堆排序算法。

输出分两行：

第1行：输出初始堆，以行输出

第2行：输出排好序的数列

输入：
1 8 4 6 7 9 5 3 2 0
输出：

9 8 5 6 7 4 1 3 2 

1 2 3 4 5 6 7 8 9 

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
#include<sstream>
#include<deque>
#include<unordered_map>
using namespace std;
typedef long long LL;
const int N = 1e4;
typedef struct Heap {int key[N];int lenth;
}Heap;
void print(Heap& h) {for (int i = 1; i <= h.lenth; i++) {cout << h.key[i] << " ";}cout << endl;
}void HeapAdjust(Heap&h,int u,int len) {/*cout << "KKKKKKKKKKKKKK   ";print(h);*/for (int j = 2 * u; j <=len; j *= 2) {if (j < len && h.key[j] < h.key[j + 1])j++;if (h.key[u] < h.key[j]) {//cout << "PPPPPPPPPPPPP  " << h.key[u] << " " << h.key[j] << endl;swap(h.key[u], h.key[j]);u = j;//cout << "PPPPPPPPPPPPP  " << h.key[u] << " " << h.key[j] << endl;}else {break;}}//cout << "KKKKKKKKKKKKKK   ";//print(h);
}void HeapFun(Heap& h) {for (int i = h.lenth / 2; i > 0; i--) {//cout << "____________" << i << endl;HeapAdjust(h, i,h.lenth);}print(h);for (int i = h.lenth ; i > 1; i--) {swap(h.key[1], h.key[i]);HeapAdjust(h, 1,i-1);}print(h);
}int main() {Heap h;h.lenth = 0;do {cin>>h.key[++h.lenth];} while (h.key[h.lenth]);h.lenth--;HeapFun(h);return 0;
}

用例1：

输入

1 8 4 6 7 9 5 3 2 0

输出

9 8 5 6 7 4 1 3 2 1 2 3 4 5 6 7 8 9

用例2：

输入

2 87 39 49 34 62 53 6 44 98 0

输出

98 87 62 49 34 39 53 6 44 2 2 6 34 39 44 49 53 62 87 98

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

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

相关文章

【数据结构】图论与并查集

【数据结构】图论与并查集

一、并查集 1.原理 简单的讲并查集&#xff0c;就是查询两个个元素&#xff0c;是否在一个集合当中&#xff0c;这里的集合用树的形式进行表示。并查集的本质就是森林, 即多棵树。 我们再来简单的举个例子: 假设此时的你是大一新生&#xff0c;刚进入大学&#xff0c;肯定是…
阅读更多...
php-fpm运行一段时间，内存不足

php-fpm运行一段时间，内存不足

目录 一&#xff1a;原因分析 二&#xff1a;解决 三:观察系统情况 php-fpm运行一段时间&#xff0c;内存不足&#xff0c;是什么原因呢。 一&#xff1a;原因分析 1:首先php-fpm的配置 &#xff08;1&#xff09;启动的进程数 启动的进程数越多,占用内存越高; 2:其次…
阅读更多...
HarmonyOS自学-Day4(TodoList案例)

HarmonyOS自学-Day4(TodoList案例)

目录 文章声明⭐⭐⭐让我们开始今天的学习吧&#xff01;TodoList小案例 文章声明⭐⭐⭐ 该文章为我&#xff08;有编程语言基础&#xff0c;非编程小白&#xff09;的 HarmonyOS自学笔记&#xff0c;此类文章笔记我会默认大家都学过前端相关的知识知识来源为 HarmonyOS官方文…
阅读更多...
【蓝桥杯】比赛大纲整理

【蓝桥杯】比赛大纲整理

枚举[1-3] 排序 &#xff08;1&#xff09;冒泡排序[2] &#xff08;2&#xff09;选择排序[3] &#xff08;3&#xff09;插入排序[3] 搜索(bfs, dfs)[1-5] 贪心[1-5] 模拟[1-3] 二分[2-5] DP(普通一维问题)[3-5] 高精度[1-5] 数据结构 &#xff08;1&#xff09;栈[2-4]&…
阅读更多...
Linux sed命令教程：如何使用流编辑器进行文本处理（附实例教程和注意事项）

Linux sed命令教程：如何使用流编辑器进行文本处理（附实例教程和注意事项）

Linux sed命令介绍 sed是stream editor的缩写&#xff0c;意为流编辑器。它是一种在命令行下处理文本文件的工具。sed主要用于自动编辑一个或多个文件、简化对文件的反复操作、编写转换程序等。 Linux sed命令适用的Linux版本 sed命令在大多数Linux发行版中都是预装的&#…
阅读更多...
Java插入排序：优雅整理数据的艺术

Java插入排序：优雅整理数据的艺术

Java插入排序&#xff1a;优雅整理数据的艺术 大家好&#xff0c;我是免费搭建查券返利机器人赚佣金就用微赚淘客系统3.0的小编&#xff0c;也是冬天不穿秋裤&#xff0c;天冷也要风度的程序猿&#xff01;今天&#xff0c;让我们一同深入研究Java中的排序算法&#xff0c;探讨…
阅读更多...
1.NumPy 介绍

1.NumPy 介绍

1.NumPy 介绍 1.1 NumPy 演变史 在 NumPy 之前&#xff0c;有两个 Python 数组包&#xff1a; Numeric 包 Numeric 包开发于 20 世纪 90 年代中期&#xff0c;在 Python 中提供了数组对象和数组感知函数。它由 C 语言编写&#xff0c;并与线性代数的标准快速实现相链接。它最…
阅读更多...
nodejs微信小程序＋python＋PHP的林业信息管理系统的设计与实现-计算机毕业设计推荐

nodejs微信小程序＋python＋PHP的林业信息管理系统的设计与实现-计算机毕业设计推荐

目 录 摘 要 I ABSTRACT II 目 录 II 第1章 绪论 1 1.1背景及意义 1 1.2 国内外研究概况 1 1.3 研究的内容 1 第2章 相关技术 3 2.1 nodejs简介 4 2.2 express框架介绍 6 2.4 MySQL数据库 4 第3章 系统分析 5 3.1 需求分析 5 3.2 系统可行性分析 5 3.2.1技术可行性&#xff1a;…
阅读更多...
nodejs+vue+微信小程序＋python＋PHP的冷链物流配送系统-计算机毕业设计推荐

nodejs+vue+微信小程序＋python＋PHP的冷链物流配送系统-计算机毕业设计推荐

对于冷链物流信息调度系统所牵扯的管理及数据保存都是非常多的&#xff0c;例如管理员&#xff1b;首页、用户管理&#xff08;管理员、客户、业务员、配送员&#xff09;客户管理&#xff08;货物信息、客户运输单、车辆信息、调度安排&#xff09;这给管理者的工作带来了巨大…
阅读更多...
Redisson依赖冲突记录

Redisson依赖冲突记录

前言&#xff1a;项目使用的springboot项目为2.7.X 依赖冲突一&#xff1a;springboot 与 redisson版本冲突 项目中依赖了 Lock4j&#xff0c;此为苞米豆开源的分布式锁组件 <dependency><groupId>com.baomidou</groupId><artifactId>lock4j-redisso…
阅读更多...
读算法霸权笔记07_筛选

读算法霸权笔记07_筛选

1. 美国残疾人法案 1.1. 1990年 1.2. 公司在招聘时使用身体检查是非法的 1.3. 有某些心理健康问题的人被“亮了红灯”&#xff0c;他们因此没能找到一份正常的工作&#xff0c;过上正常的生活&#xff0c;这就使其进一步被社会孤立&#xff0c;而这正是《美国残疾人法案》要…
阅读更多...
使用Halcon 采集图像并进行简单处理rgbl_to_gray/threshold/connection/fill_up

使用Halcon 采集图像并进行简单处理rgbl_to_gray/threshold/connection/fill_up

使用Halcon 采集图像并进行简单处理 文章目录 使用Halcon 采集图像并进行简单处理 下面介绍一个简单的采集图像的例子。在Halcon中利用图像采集接口&#xff0c;使用USB3.0相机实时拍摄图像。采集到图像后对图像进行简单的阀值分割处理&#xff0c;将有物体的区域标记出来。 &a…
阅读更多...
3d光学轮廓仪测微光学器件应用及其重要意义

3d光学轮廓仪测微光学器件应用及其重要意义

微光学器件是光学器件的重要分支&#xff0c;为光学通信、光传感、光计算等领域的发展提供重要支撑。微光学器件具有尺寸小、功耗低、低成本等优势&#xff0c;可以于电子器件集成&#xff0c;实现更高效的数据传输和信号处理。未来&#xff0c;随着微纳加工技术的进一步发展&a…
阅读更多...
prerender-spa-plugin使用总结

prerender-spa-plugin使用总结

1. 介绍 prerender-spa-plugin 利用了 Puppeteer 的爬取页面的功能。 Puppeteer 是一个 Chrome官方出品的 headlessChromenode 库。它提供了一系列的 API, 可以在无 UI 的情况下调用 Chrome 的功能, 适用于爬虫、自动化处理等各种场景。它很强大&#xff0c;所以很简单就能将运…
阅读更多...
在 Golang 应用程序中管理多个数据库

在 Golang 应用程序中管理多个数据库

掌握在 Golang 项目中处理多个数据库的艺术 在当前软件开发领域中&#xff0c;处理单个应用程序内的多个数据库的需求越来越普遍。具有强大功能的 Golang 是处理此类任务的绝佳解决方案&#xff0c;无论您是与多个数据源合作还是仅为增强组织和可扩展性而分隔数据。在本文中&a…
阅读更多...
FastAPI使用异步Redis

FastAPI使用异步Redis

1. 安装依赖 pip install fastapi redis uvicorn 2. 主要代码 #!/usr/bin/env python import os import sys from contextlib import AbstractAsyncContextManager, asynccontextmanager from datetime import timedelta from pathlib import Pathfrom fastapi import FastA…
阅读更多...
Java开发框架和中间件面试题(7)

Java开发框架和中间件面试题(7)

目录 63.Spring中都应用了哪些设计模式&#xff1f; 64.请举例说明如何在Spring中注入一个Java Collection&#xff1f; 65.说一下都有哪些基本理念&#xff1f; 67.Spring Bean的生命周期&#xff1f; 68.说说Spring AOP的实现原理&#xff1f; 69.Spring中事务的实现方…
阅读更多...
vue3导入excel并解析excel数据渲染到表格中，纯前端实现。

vue3导入excel并解析excel数据渲染到表格中，纯前端实现。

需求 用户将已有的excel上传到系统&#xff0c;并将excel数据同步到页面的表格中进行二次编辑&#xff0c;由于excel数据不是最终数据&#xff0c;只是批量的一个初始模板&#xff0c;后端不需要存储&#xff0c;所以该功能由前端独立完成。 吐槽 系统中文件上传下载预览三部…
阅读更多...
在pytorch中，读取GPU上张量的数值 (数据从GPU到CPU) 的几种常用方法

在pytorch中，读取GPU上张量的数值 (数据从GPU到CPU) 的几种常用方法

1、.cpu() 方法&#xff1a; 使用 .cpu() 方法可以将张量从 GPU 移动到 CPU。这是一种简便的方法&#xff0c;常用于在进行 CPU 上的操作之前将数据从 GPU 取回 import torch# 在 GPU 上创建一个张量 gpu_tensor torch.tensor([1, 2, 3], devicecuda)# 将 GPU 上的张…
阅读更多...
AI赋能金融创新：技术驱动的未来金融革命

AI赋能金融创新：技术驱动的未来金融革命

人工智能&#xff08;AI&#xff09;作为一种技术手段&#xff0c;正逐渐改变金融行业的方方面面。从风险管理到客户体验&#xff0c;从交易执行到反欺诈&#xff0c;AI带来了许多创新和机遇。本文将探讨AI在金融领域的应用和其赋能的金融创新。 金融领域一直以来都面临着复杂的…
阅读更多...
最新文章

Copyright @ 2022~2023