数据结构与算法-常用排序算法

一、常用排序说明

        当涉及排序算法时，理解每个算法的工作原理、时间复杂度和空间复杂度是至关重要的。下面对常用排序算法进行详细说明：     

        1、冒泡排序（Bubble Sort）：

        工作原理：比较相邻的元素并交换，每一轮将最大（或最小）的元素移动到数组末尾（或开头）。

        时间复杂度：平均情况和最坏情况均为 O(n^2)。

        空间复杂度：O(1)，原地排序，不需要额外空间。

        适用场景：适用于小规模数据集，对稳定性要求高的场景，或者作为教学和理解排序算法的基础。

        2、选择排序（Selection Sort）：

        工作原理：每一轮选择最小（或最大）的元素放在已排序序列的末尾（或开头）。

        时间复杂度：平均情况和最坏情况均为 O(n^2)。

        空间复杂度：O(1)，原地排序，不需要额外空间。

        适用场景：适用于小规模数据集，简单易实现，但性能较差。对稳定性要求不高的场景。

        3、插入排序（Insertion Sort）：

        工作原理：将未排序序列中的元素逐个插入到已排序序列中的适当位置。

        时间复杂度：平均情况和最坏情况均为 O(n^2)。

        空间复杂度：O(1)，原地排序，不需要额外空间。

        适用场景：适用于小规模或基本有序的数据集，对稳定性要求高的场景，用于改进其他排序算法的一部分。

        4、希尔排序（Shell Sort）：

        工作原理：是插入排序的改进版，通过比较距离较远的元素进行交换，最终使数据基本有序，然后再使用插入排序。

        时间复杂度：取决于增量序列的选择，在实践中介于 O(n log^2 n) 和 O(n^2) 之间。

        空间复杂度：O(1)，原地排序，不需要额外空间。

        适用场景：适用于小规模或基本有序的数据集，对稳定性要求高的场景，用于改进其他排序算法的一部分。

        5、归并排序（Merge Sort）：

        工作原理：采用分治法，将数组分成两半，分别排序，然后合并两个有序数组。

        时间复杂度：平均情况和最坏情况均为 O(n log n)。

        空间复杂度：O(n)，需要额外的内存来存储临时数组。

        适用场景：适用于小规模或基本有序的数据集，对稳定性要求高的场景，用于改进其他排序算法的一部分。

        6、快速排序（Quick Sort）：

        工作原理：采用分治法，选取一个基准值，将小于基准值的放在左边，大于基准值的放在右边，然后递归地对左右两部分进行排序。

        时间复杂度：平均情况为 O(n log n)，最坏情况为 O(n^2)。

        空间复杂度：取决于实现方式，通常为 O(log n)。

        适用场景：适用于大规模数据集，性能优秀且易于实现。常用于实际生产环境中的排序需求。

        7、堆排序（Heap Sort）：

        工作原理：利用堆的性质（最大堆或最小堆），将待排序数组构建成堆，然后每次取出堆顶元素，重新调整堆，直至完成排序。

        时间复杂度：平均情况和最坏情况均为 O(n log n)。

        空间复杂度：O(1)，原地排序，不需要额外空间。

        适用场景：适用于大规模数据集，性能稳定且不受输入数据分布情况影响。适合内存受限的情况下进行排序。

        8、计数排序（Counting Sort）：

        工作原理：统计待排序数组中每个元素出现的次数，然后根据元素的值将其放到正确的位置。

        时间复杂度：平均情况和最坏情况均为 O(n + k)，其中 k 是非负整数的最大值。

        空间复杂度：O(n + k)，需要额外空间来存储计数数组和输出数组。

        适用场景：适用于输入数据的范围相对较小，但数量较大的情况下，可以快速排序。对数字的频率进行统计。

        9、桶排序（Bucket Sort）：

        工作原理：将待排序数据分到有限数量的桶里，每个桶再分别进行排序，最后合并所有桶的结果。

        时间复杂度：平均情况为 O(n + k)，最坏情况为 O(n^2)。

        空间复杂度：O(n + k)，需要额外空间来存储计数数组和输出数组。

        适用场景：适用于数据均匀分布在一个范围内的情况下，将数据分到多个桶中，然后对每个桶单独进行排序。

        10、基数排序（Radix Sort）：

        工作原理：根据数字位进行排序，先按个位排序，再按十位排序，依次类推，直到最高位排序完成。

        时间复杂度：平均情况和最坏情况均为 O(d * (n + k))，其中 d 是数字位数，k 是基数（如 10 进制中的 10）。

        空间复杂度：O(n + k)，需要额外空间来存储计数数组和输出数组。

        适用场景：适用于对数字进行排序的场景通过按位进行排序，每次排序根据数字位数来确定，效率高且稳定。

二、时间复杂度说明

        O(1)：常数时间复杂度。无论输入规模的大小如何，算法的执行时间都是固定的。例如，访问数组中的一个元素，计算数组的长度等。无论数组中有多少个元素，时间都是恒定的。

        O(log n)：对数时间复杂度。算法的执行时间与输入规模的对数成正比。典型的例子是二分查找算法。在一个有序数组中查找一个元素时，每次都将搜索空间减半，因此时间复杂度为对数级别。

        O(n)：线性时间复杂度。算法的执行时间与输入规模成正比，呈线性增长。例如，遍历数组或链表中的所有元素。如果一个数组有 n 个元素，那么对每个元素的访问将花费 O(n) 的时间。

        O(n log n)：线性对数时间复杂度。典型的例子是快速排序和归并排序等基于比较的排序算法。这些算法的执行时间与输入规模的对数乘以线性成正比。

        O(n^2)：平方时间复杂度。算法的执行时间与输入规模的平方成正比。例如，嵌套循环的排序算法（如冒泡排序、选择排序），每个元素都需要与其他元素比较。

        O(2^n)：指数时间复杂度。通常出现在递归算法中，每次递归都会产生指数级别的子问题。例如，求解所有可能的子集或排列问题。

        O(n!)：阶乘时间复杂度。通常出现在全排列等组合问题中，需要计算所有可能的排列。例如，求解 n 个元素的所有排列可能性的问题。

三、空间复杂度说明

        O(1)：常数空间复杂度。算法的额外空间使用是一个固定的常数，与输入规模无关。例如，原地排序算法，如冒泡排序、选择排序，不需要额外的空间。

        O(log n)：对数空间复杂度。算法的额外空间使用与输入规模的对数成正比。例如，递归算法每次调用都会消耗对数级别的栈空间。二分搜索的递归版本就是一个典型的例子。

        O(n)：线性空间复杂度。算法的额外空间使用与输入规模成正比，呈线性增长。例如，需要一个与输入规模相同大小的数组来存储数据，或者使用一个辅助数组来进行排序。

        O(n^2)：平方空间复杂度。算法的额外空间使用与输入规模的平方成正比。例如，使用一个二维数组来存储所有可能的组合情况。

        O(2^n)：指数空间复杂度。算法的额外空间使用与输入规模的指数成正比。通常出现在递归的指数增长情况下，例如，子集生成问题。

        O(n!)：阶乘空间复杂度。算法的额外空间使用与输入规模的阶乘成正比。通常出现在全排列等组合问题中，需要存储所有可能的排列。

四、代码样例

(一) 冒泡排序（Bubble Sort）

#include <iostream>
using namespace std;void bubbleSort(int arr[], int n) {for (int i = 0; i < n-1; i++) {for (int j = 0; j < n-i-1; j++) {if (arr[j] > arr[j+1]) {swap(arr[j], arr[j+1]);}}}
}int main() {int arr[] = {64, 34, 25, 12, 22, 11, 90};int n = sizeof(arr) / sizeof(arr[0]);bubbleSort(arr, n);cout << "Sorted array: ";for (int i = 0; i < n; i++) {cout << arr[i] << " ";}cout << endl;return 0;
}

(二) 选择排序（Selection Sort）

#include <iostream>
using namespace std;void selectionSort(int arr[], int n) {for (int i = 0; i < n-1; i++) {int min_idx = i;for (int j = i+1; j < n; j++) {if (arr[j] < arr[min_idx]) {min_idx = j;}}swap(arr[i], arr[min_idx]);}
}int main() {int arr[] = {64, 34, 25, 12, 22, 11, 90};int n = sizeof(arr) / sizeof(arr[0]);selectionSort(arr, n);cout << "Sorted array: ";for (int i = 0; i < n; i++) {cout << arr[i] << " ";}cout << endl;return 0;
}

(三) 插入排序（Insertion Sort）

#include <iostream>
using namespace std;void insertionSort(int arr[], int n) {for (int i = 1; i < n; i++) {int key = arr[i];int j = i - 1;while (j >= 0 && arr[j] > key) {arr[j+1] = arr[j];j--;}arr[j+1] = key;}
}int main() {int arr[] = {64, 34, 25, 12, 22, 11, 90};int n = sizeof(arr) / sizeof(arr[0]);insertionSort(arr, n);cout << "Sorted array: ";for (int i = 0; i < n; i++) {cout << arr[i] << " ";}cout << endl;return 0;
}

(四) 希尔排序（Shell Sort）

#include <iostream>
using namespace std;void shellSort(int arr[], int n) {for (int gap = n/2; gap > 0; gap /= 2) {for (int i = gap; i < n; i++) {int temp = arr[i];int j;for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {arr[j] = arr[j - gap];}arr[j] = temp;}}
}int main() {int arr[] = {64, 34, 25, 12, 22, 11, 90};int n = sizeof(arr) / sizeof(arr[0]);shellSort(arr, n);cout << "Sorted array: ";for (int i = 0; i < n; i++) {cout << arr[i] << " ";}cout << endl;return 0;
}

(五) 归并排序（Merge Sort）

#include <iostream>
#include <vector>
using namespace std;void merge(vector<int>& arr, int l, int m, int r) {int n1 = m - l + 1;int n2 = r - m;vector<int> L(n1), R(n2);for (int i = 0; i < n1; i++)L[i] = arr[l + i];for (int j = 0; j < n2; j++)R[j] = arr[m + 1 + j];int i = 0, j = 0, k = l;while (i < n1 && j < n2) {if (L[i] <= R[j]) {arr[k] = L[i];i++;} else {arr[k] = R[j];j++;}k++;}while (i < n1) {arr[k] = L[i];i++;k++;}while (j < n2) {arr[k] = R[j];j++;k++;}
}void mergeSort(vector<int>& arr, int l, int r) {if (l < r) {int m = l + (r - l) / 2;mergeSort(arr, l, m);mergeSort(arr, m + 1, r);merge(arr, l, m, r);}
}int main() {vector<int> arr = {64, 34, 25, 12, 22, 11, 90};int n = arr.size();mergeSort(arr, 0, n - 1);cout << "Sorted array: ";for (int i = 0; i < n; i++)cout << arr[i] << " ";cout << endl;return 0;
}

(六) 快速排序（Quick Sort）

#include <iostream>
#include <vector>
using namespace std;int partition(vector<int>& arr, int low, int high) {int pivot = arr[high];int i = low - 1;for (int j = low; j < high; j++) {if (arr[j] < pivot) {i++;swap(arr[i], arr[j]);}}swap(arr[i + 1], arr[high]);return i + 1;
}void quickSort(vector<int>& arr, int low, int high) {if (low < high) {int pi = partition(arr, low, high);quickSort(arr, low, pi - 1);quickSort(arr, pi + 1, high);}
}int main() {vector<int> arr = {64, 34, 25, 12, 22, 11, 90};int n = arr.size();quickSort(arr, 0, n - 1);cout << "Sorted array: ";for (int i = 0; i < n; i++)cout << arr[i] << " ";cout << endl;return 0;
}

(七) 堆排序（Heap Sort）

#include <iostream>
#include <vector>
using namespace std;void heapify(vector<int>& arr, int n, int i) {int largest = i;int l = 2 * i + 1;int r = 2 * i + 2;if (l < n && arr[l] > arr[largest])largest = l;if (r < n && arr[r] > arr[largest])largest = r;if (largest != i) {swap(arr[i], arr[largest]);heapify(arr, n, largest);}
}void heapSort(vector<int>& arr) {int n = arr.size();for (int i = n / 2 - 1; i >= 0; i--)heapify(arr, n, i);for (int i = n - 1; i > 0; i--) {swap(arr[0], arr[i]);heapify(arr, i, 0);}
}int main() {vector<int> arr = {64, 34, 25, 12, 22, 11, 90};int n = arr.size();heapSort(arr);cout << "Sorted array: ";for (int i = 0; i < n; i++)cout << arr[i] << " ";cout << endl;return 0;
}

(八) 计数排序（Counting Sort）

#include <iostream>
#include <vector>
using namespace std;void countingSort(vector<int>& arr) {int n = arr.size();int maxVal = *max_element(arr.begin(), arr.end());int minVal = *min_element(arr.begin(), arr.end());int range = maxVal - minVal + 1;vector<int> count(range), output(n);for (int i = 0; i < n; i++)count[arr[i] - minVal]++;for (int i = 1; i < range; i++)count[i] += count[i - 1];for (int i = n - 1; i >= 0; i--) {output[count[arr[i] - minVal] - 1] = arr[i];count[arr[i] - minVal]--;}for (int i = 0; i < n; i++)arr[i] = output[i];
}int main() {vector<int> arr = {64, 34, 25, 12, 22, 11, 90};countingSort(arr);cout << "Sorted array: ";for (int i = 0; i < arr.size(); i++)cout << arr[i] << " ";cout << endl;return 0;
}

(九) 桶排序（Bucket Sort）

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;void bucketSort(vector<float>& arr) {int n = arr.size();vector<vector<float>> buckets(n);for (int i = 0; i < n; i++) {int bucketIndex = n * arr[i];buckets[bucketIndex].push_back(arr[i]);}for (int i = 0; i < n; i++)sort(buckets[i].begin(), buckets[i].end());int index = 0;for (int i = 0; i < n; i++) {for (float num : buckets[i]) {arr[index++] = num;}}
}int main() {vector<float> arr = {0.64, 0.34, 0.25, 0.12, 0.22, 0.11, 0.90};bucketSort(arr);cout << "Sorted array: ";for (int i = 0; i < arr.size(); i++)cout << arr[i] << " ";cout << endl;return 0;
}

(十) 基数排序（Radix Sort）

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;int getMax(vector<int>& arr) {int maxVal = arr[0];for (int i = 1; i < arr.size(); i++) {if (arr[i] > maxVal)maxVal = arr[i];}return maxVal;
}void countingSort(vector<int>& arr, int exp) {int n = arr.size();vector<int> output(n), count(10);for (int i = 0; i < n; i++)count[(arr[i] / exp) % 10]++;for (int i = 1; i < 10; i++)count[i] += count[i - 1];for (int i = n - 1; i >= 0; i--) {output[count[(arr[i] / exp) % 10] - 1] = arr[i];count[(arr[i] / exp) % 10]--;}for (int i = 0; i < n; i++)arr[i] = output[i];
}void radixSort(vector<int>& arr) {int maxVal = getMax(arr);for (int exp = 1; maxVal / exp > 0; exp *= 10)countingSort(arr, exp);
}int main() {vector<int> arr = {64, 34, 25, 12, 22, 11, 90};radixSort(arr);cout << "Sorted array: ";for (int i = 0; i < arr.size(); i++)cout << arr[i] << " ";cout << endl;return 0;
}

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

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

相关文章

python bug与debug

python bug与debug

一、什么是bug&#xff08;软件缺陷&#xff09;&#xff1f; 产品说明书中规定要做的事情&#xff0c;而软件没有实现。 产品说明书中规定不要做的事情&#xff0c;而软件确实现了。 产品说明书中没有提到过的事情&#xff0c;而软件确实现了。 产品说明书中没有提到但是必…
阅读更多...
跨语言的序列化与反序列化

跨语言的序列化与反序列化

在Java中实现跨语言的序列化与反序列化通常可以采用以下几种方式 使用标准的跨语言序列化格式 可以选择使用一些标准的跨语言序列化格式，例如JSON、XML、Protocol Buffers（ProtoBuf）等。这些格式都是跨语言的，可以方便地在不同的编程语言之间进行数据交换。在Java中，可以…
阅读更多...
紫光同创初使用

紫光同创初使用

芯片PGC2KG-6LPG144 1、安装好软件接&#xff0c;加载license,有两个&#xff0c;与电脑MAC地址绑定的 2、正常使用后&#xff0c;新建个工程&#xff0c;配置管脚Tools→UCE 3、程序中有些信号被软件认为是时钟信号&#xff0c;会报错&#xff08;时钟输入I0约束在非专用时钟…
阅读更多...
LeetCode--代码详解 78.子集

LeetCode--代码详解 78.子集

78.子集 题目 给你一个整数数组 nums &#xff0c;数组中的元素 互不相同 。返回该数组所有可能的子集&#xff08;幂集&#xff09;。 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。 示例 1&#xff1a; 输入&#xff1a;nums [1,2,3] 输出&#xff1a;[[],[1…
阅读更多...
Python爬虫-使用代理伪装IP

Python爬虫-使用代理伪装IP

爬虫系列&#xff1a;http://t.csdnimg.cn/WfCSx 前言 我们在做爬虫的过程中经常会遇到这样的情况&#xff0c;最初爬虫正常运行&#xff0c;正常抓取数据&#xff0c;一切看起来都是那么的美好&#xff0c;然而一杯茶的功夫可能就会出现错误&#xff0c;比如 403 Forbidden&…
阅读更多...
【LeetCode刷题笔记】242.有效的字母异位词

【LeetCode刷题笔记】242.有效的字母异位词

创作不易&#xff0c;本篇文章如果帮助到了你&#xff0c;还请点赞 关注支持一下♡>&#x16966;<)!! 主页专栏有更多知识&#xff0c;如有疑问欢迎大家指正讨论&#xff0c;共同进步&#xff01; 更多算法知识专栏&#xff1a;算法分析&#x1f525; 给大家跳段街舞感谢…
阅读更多...
Spring基础之AOP和代理模式

Spring基础之AOP和代理模式

文章目录 理解AOPAOP的实现原理 AOP代理模式静态代理动态代理1-JDK动态代理2-CGLIB动态代理 总结 理解AOP OOP - - Object Oriented Programming 面向对象编程 AOP - - Aspect Oriented Programming 面向切面编程 AOP是Spring提供的关键特性之一。AOP即面向切面编程&#xff0…
阅读更多...
Jenkins邮件通知配置（7）

Jenkins邮件通知配置（7）

1、安装插件&#xff1a; Email Extension&#xff0c;Email Extension Template&#xff0c;这两个插件可以帮助我们进行邮件的编写发送以及格式化 2、配置jenkins中链接腾讯企业邮箱 先配置发送服务&#xff0c;然后在具体工程中设置接收者 基础信息&#xff1a; POP3/S…
阅读更多...
SWIFT：自我认知微调

SWIFT：自我认知微调

文档：https://github.com/modelscope/swift/blob/main/docs/source/LLM/%E8%87%AA%E6%88%91%E8%AE%A4%E7%9F%A5%E5%BE%AE%E8%B0%83%E6%9C%80%E4%BD%B3%E5%AE%9E%E8%B7%B5.md ​​​​​​代码： Swift是如何把自我认知数据集融合到训练集中呢？ 1：相关的3个参数
阅读更多...
设计模式学习笔记 - 面向对象 - 6.为什么要基于接口而非实现编程？有必要为每个类都定义接口吗？

设计模式学习笔记 - 面向对象 - 6.为什么要基于接口而非实现编程？有必要为每个类都定义接口吗？

前言 “基于接口而非实现编程”这个原则非常重要&#xff0c;是一种非常有效的提高代码质量的手段&#xff0c;在平时的开发中经常被用到。 如何解读原则中的“接口”二字 要理解“基于接口而非实现编程”的关键就是要理解其中的“接口”二字&#xff0c;我们可以理解为编程语…
阅读更多...
学习数据节构和算法的第14天

学习数据节构和算法的第14天

题目讲解 链表的移除 #include <stdio.h> #include <stdlib.h> // 定义链表节点结构体 typedef struct Node {int data; // 节点数据struct Node* next; // 指向下一个节点的指针 } Node; // 初始化链表节点 Node* initNode(int data) {Node* n…
阅读更多...
mfc 疑难杂症之一

mfc 疑难杂症之一

病情&#xff1a; 1.xxxx处的第一机会异常: 0xC0000005: 读取位置 0x00000004 时发生访问冲突。 2.不定时程序闪退 访问违例 程序定位到 main处 0x76DCB5B2 处(位于 Tetris.exe 中)引发的异常: Microsoft C 异常: CResourceException&#xff0c;位于内存位置 0x008FF0D4 处…
阅读更多...
vue计算属性和监听器详解

vue计算属性和监听器详解

1.watch 和 computed 的作用和区别 watch&#xff08;侦听器&#xff09; 作用&#xff1a; 监听器允许开发者自定义一个函数来观察 Vue 实例上的特定数据属性的变化&#xff0c;当这些属性发生变化时&#xff0c;会触发相应的回调函数。 特点&#xff1a; 非缓存&#xff1a…
阅读更多...
用支持向量机进行光学符号识别

用支持向量机进行光学符号识别

&#x1f349;CSDN小墨&晓末:https://blog.csdn.net/jd1813346972 个人介绍: 研一&#xff5c;统计学&#xff5c;干货分享          擅长Python、Matlab、R等主流编程软件          累计十余项国家级比赛奖项&#xff0c;参与研究经费10w、40w级横向 文…
阅读更多...
企业级大数据安全架构（十一）Kerberos接入dophinscheduler

企业级大数据安全架构（十一）Kerberos接入dophinscheduler

作者&#xff1a;楼高 建议将dophinscheduler集成到Ambari安装部署&#xff0c;在Ambari上面开启kerberos 1.安装准备 编译 从GitHub获取dolphinscheduler-1.3.9源码 git clone https://github.com/apache/dolphinscheduler.git -b 1.3.9-releasehttps://github.com/apache/…
阅读更多...
多输入回归预测|GWO-CNN-LSTM|灰狼算法优化的卷积-长短期神经网络回归预测(Matlab)

多输入回归预测|GWO-CNN-LSTM|灰狼算法优化的卷积-长短期神经网络回归预测(Matlab)

目录 一、程序及算法内容介绍&#xff1a; 基本内容&#xff1a; 亮点与优势&#xff1a; 二、实际运行效果&#xff1a; 三、算法介绍&#xff1a; 灰狼优化算法&#xff1a; 卷积神经网络-长短期记忆网络&#xff1a; 四、完整程序下载&#xff1a; 一、程序及算法内容…
阅读更多...
java日志框架总结（七、使用过滤器自动打印接口入参、出参）

java日志框架总结（七、使用过滤器自动打印接口入参、出参）

使用过滤器自动打印接口入参、出参首先要了解一个过滤器OncePerRequestFilter&#xff0c;一般使用这个过滤器进行日志打印。 一、OncePerRequestFilter 1)、什么是OncePerRequestFilter 回顾一下 Filter 的工作原理。Filter 可以在 Servlet 执行之前或之后调用。当请求被调度…
阅读更多...
ChatGPT/GPT4科研应用与AI绘图及论文写作

ChatGPT/GPT4科研应用与AI绘图及论文写作

2023年随着OpenAI开发者大会的召开&#xff0c;最重磅更新当属GPTs&#xff0c;多模态API&#xff0c;未来自定义专属的GPT。微软创始人比尔盖茨称ChatGPT的出现有着重大历史意义&#xff0c;不亚于互联网和个人电脑的问世。360创始人周鸿祎认为未来各行各业如果不能搭上这班车…
阅读更多...
重看LeakCanary

重看LeakCanary

LeakCanary是我很久之前看的东西了&#xff0c;我当时侯对它的印象就是它可以用来检测内存泄漏&#xff0c;具体原理就是将弱引用对象延迟个5s然后看是否被回收,如果没有被回收,那么就说明发生了内存泄漏,其他的也没有仔细地看 现在就详细地梳理一遍这个流程&#xff1a; 1.L…
阅读更多...
微服务篇之分布式事务

微服务篇之分布式事务

一、Seata架构 Seata事务管理中有三个重要的角色&#xff1a; TC (Transaction Coordinator) - 事务协调者&#xff1a;维护全局和分支事务的状态&#xff0c;协调全局事务提交或回滚。 TM (Transaction Manager) - 事务管理器&#xff1a;定义全局事务的范围、开始全局事务、…
阅读更多...
最新文章

Copyright @ 2022~2023