【数据结构】八大排序之快速排序算法

🦄个人主页:修修修也

🎏所属专栏:数据结构

⚙️操作环境:Visual Studio 2022

目录

一.快速排序简介及思路

二.快速排序代码实现的三种方式

📌左右交换法

📌挖坑填坑法

📌前后指针法

三.快速排序的时间复杂度分析

四.快速排序的优化

🎏优化选key方式

📌随机选key法

📌三数取中法

🎏小区间优化

📌小区间优化的原理

📌小区间优化的代码实现

五.借助栈实现非递归快速排序

📌为什么要将递归的快速排序算法改为非递归?

📌递归函数改非递归的思路

📌快速排序改非递归的思路

📌快速排序改非递归的代码实现

六.快速排序的三路划分

结语

一.快速排序简介及思想

快速排序(Quick Sort)是一种效率较高的交换排序算法.

它的基本思想是:

  • 通过一趟排序将待排数据分割成独立的两部分
  • 其中一部分数据的关键字均比另一部分数据的关键字小
  • 可分别对这两部分数据继续进行排序,以达到整个序列有序的目的.

算法动图演示:

二.快速排序代码实现的三种方式

我们了解了快速排序的基本思想是通过一趟排序将待排数据分割成独立的两部分之后,在代码的实现上,其实就有很多可以自由发挥的空间,如下较为主流的快速排序有三种实现思路,接下来我将一一带大家理解这三个思路并使用它们实现快排算法:

注:本文的快排实现思路均以升序为例!

📌左右交换法

左右交换法的思路是:

  1. 先选定当前待排序列的首元素位置的值为基准值(key).
  2. 然后设置一个右指针,使其从后向前遍历,找到比基准值(key)小的元素就停下来.
  3. 再设置一个左指针,使其从前向后遍历,找到比基准值(key)大的元素就停下来.
  4. 当左右指针都找到相应元素时,交换它们找到的元素.
  5. 重复步骤2~4,直到左右指针相遇
  6. 左右指针相遇后,将基准值(key)与相遇位置做交换,此时数组已经被重新一分为二成两个新的待排子序列.
  7. 分别继续对新的待排子序列继续执行步骤1~6排序,直到所有元素都排列在相应位置上为止.

左右交换法算法演示:

 清楚了左右交换法实现快排的思路后,我们编写实现代码就比较容易了,代码如下:

//交换函数
void Swap(int* a, int* b)
{int tmp = *a;*a = *b;*b = tmp;
}//快速排序(左右交换法
void QuickSort_swap(int* a, int left, int right)
{if (left >= right)return;int begin = left, end = right;int keyi = left;//选定序列首元素为基准值while (left < right){//右边找小while (left < right && a[right] >= a[keyi])right--;//左边找大while (left < right && a[left] <= a[keyi])left++;//交换Swap(&a[left], &a[right]);}//相遇时交换key和相遇位置的值Swap(&a[keyi], &a[left]);keyi = left;//用keyi记录下本轮确定的基准值位置QuickSort_swap(a, begin, keyi - 1);//递归排序左区间[begin , keyi-1]QuickSort_swap(a, keyi + 1, end);//递归排序右区间[keyi+1 , end]
}

📌挖坑填坑法

挖坑填坑法是基于快排的基础思想提出的一种创新实现的思路,它的思路是这样的:

  1. 先记录下当前待排序列的首元素为基准值(key).
  2. 此时认为首元素的位置是空缺的,即该位置成为了一个坑.
  3. 设置一个右指针,使其从后向前遍历,找到比基准值(key)小的元素停下来将其填入刚才的坑位中,此时认为右指针找到的这个元素位置又形成了一个坑.
  4. 设置一个左指针,使其从前向后遍历,找到比基准值(key)大的元素停下来将其填入刚才的坑位中,此时认为左指针找到的这个元素位置又形成了一个坑.
  5. 左右指针不断向中间挪动不断填坑又形成新坑,直到两指针相遇
  6. 最后将基准值(key)填入左右指针相遇位置的坑中,此时数组已经被重新一分为二成两个新的待排子序列.
  7. 分别继续对新的待排子序列继续执行步骤1~6排序,直到所有元素都排列在相应位置上为止.

挖坑填坑法算法演示:

挖坑填坑法实现快排代码如下:

//快速排序(挖坑填坑法
void QuickSort_hole(int* a, int left, int right)
{if (left >= right)return;int begin = left, end = right;int key = a[left];//选定序列首元素为基准值,记录下基准值int hole = left;  //基准值的位置形成坑位while (left < right){//右边找小while (left < right && a[right] >= key)right--;//找到了就填坑,更新坑a[hole] = a[right];hole = right;//左边找大while (left < right && a[left] <= key)left++;//找到了就填坑,更新坑a[hole] = a[left];hole = left;}//相遇时把key的值填进相遇的坑里a[hole] = key;QuickSort_hole(a, begin, hole - 1);//递归遍历左区间[begin , hole-1]QuickSort_hole(a, hole + 1, end);//递归遍历右区间[hole+1 , end]
}

📌前后指针法

前后指针法思路为:

  1. 先选定当前待排序列的首元素位置的值为基准值(key).
  2. 设立前指针prev,使其指向序列开头,即基准值位置
  3. 设立后指针cur,使其指向prev指针的后一个位置
  4. 判断cur指向的数据是否小于key:如果小于,则prev后移一位,然后将cur指向的内容与prev指向的内容交换, 然后cur指针++;如果不小于,则cur++.
  5. 循环步骤4,直到cur移动到超出序列范围时,交换prev位置和基准位置的值,此时数组已经被重新一分为二成两个新的待排子序列.
  6. 分别继续对新的待排子序列继续执行步骤1~5排序,直到所有元素都排列在相应位置上为止.

前后指针法算法演示:

前后指针法实现快排代码如下:

//交换
void Swap(int* a, int* b)
{int tmp = *a;*a = *b;*b = tmp;
}//快速排序(前后指针法
void QuickSort_follow(int* a, int left, int right)
{if (left >= right)return;int begin = left, end = right;int keyi = left;//选定序列首元素为基准值,记录下基准值位置int prev = left;int cur = prev + 1;while (cur <= right) //cur没有越界就继续{if (a[cur] < a[keyi] && ++prev != cur) //如果cur指向的值小于key,并且++prev与cur不重叠{Swap(&a[cur], &a[prev]);  //就交换它们}cur++; }Swap(&a[prev], &a[keyi]);//交换prev和key的值keyi = prev;QuickSort_follow(a, begin, keyi - 1);//递归遍历左区间[begin , keyi-1]QuickSort_follow(a, keyi + 1, end);//递归遍历右区间[keyi+1 , end]
}

三.快速排序的时间复杂度分析

"快速排序的平均时间为 T_{avg}(n)=knlog_2n,其中n为待排序序列中数据的个数,k为某个常数,经验证明,在所有同数量级的此类(先进的)排序算法中,快速排序的常数因子k最小.因此,就平均时间而言,快速排序是目前被认为最好的一种内部排序方法.

通常,快速排序被认为是,在所有同数量级(O(nlogn))的排序算法中,其平均性能最好.但是,若初始数据序列按关键字有序或基本有序时,快速排序将蜕化为冒泡排序,其时间复杂度为O(n^2)."

                                ——《数据结构》严蔚敏

也就是说,快排的时间复杂度我们可以认为是O(nlogn),但当遇到原数组本身有序的情况下,其时间复杂度就会退化至O(n^2),这个其实很好理解,举个例子就明白了:

当最优情况下,即每趟选择key时都恰好选择到数组的中间值时(第n层可以确定2^{n-1}个数字位置),快排的时间复杂度如下图完全(满)二叉树:

该树每层需要遍历一遍数组,时间复杂度为n,而树高为h=log_2n,因此最优状态下快排的时间复杂度仅为O(nlogn).

而最坏情况下,即每趟选择key时都恰好选择到数组最大或最小的值时(即每一层都只能确定一个数字位置),快排的时间复杂度如下单支树:

该树每层遍历一遍数组,时间复杂度为n,而树高也为n,因此最坏状态下快排的时间复杂度为O(n^2).

综上,对快排时间复杂度的分析,我们不光理解了为什么快排排先天有序的数组时反而效率最差,同样也为我们后续对快排算法的优化提供了思路.

四.快速排序的优化

🎏优化选key方式

既然在快排在面对原本就接近有序的数组时排序会因为key值的选取导致效率降低,那么我们不妨优化一下我们快排时选key的方式,下面为大家介绍两种常用的优化选key的方式:

📌随机选key法

随机选key的思路为:

  1. 先使用rand()函数随机选出一个在[left,right]范围内的下标值randi
  2. 将randi下标的数据和keyi下标的数据互换

随机选key函数的实现:

//随机选key法
void SwapRand_key(int* a,int left, int right)
{int randi = left + (rand() % (right - left));Swap(&a[left], &a[randi]);
}

结合随机选key法实现快排

我们写好随机选key函数后只需要在正常快排函数中选定keyi后(如下函数的第15行后)调用一下随机选keyi函数就可以将随机选出的key值和原本的key值做交换了.

实现代码如下:

//随机选key法
void SwapRand_key(int* a,int left, int right)
{int randi = left + (rand() % (right - left));Swap(&a[left], &a[randi]);
}//快速排序(前后指针法
void QuickSort_follow(int* a, int left, int right)
{if (left >= right)return;int begin = left, end = right;int keyi = left;    //选定序列首元素为基准值,记录下基准值SwapRand_key(a,left, right);  //随机选出一个数据交换基准值keyint prev = left;int cur = prev + 1;while (cur <= right){if (a[cur] < a[keyi] && ++prev != cur){Swap(&a[cur], &a[prev]);}cur++;}Swap(&a[prev], &a[keyi]);keyi = prev;QuickSort_follow(a, begin, keyi - 1);//递归遍历左区间[begin , keyi-1]QuickSort_follow(a, keyi + 1, end);//递归遍历右区间[keyi+1 , end]
}

📌三数取中法

三数取中法的思路是:

  1. 比较序列首元素,尾元素,中间元素,取三者中的中间值作为midi
  2. 将midi下标的数据和keyi下标的数据互换

三数取中函数的实现:

//三数取中法
void SwapMid_key(int* a, int left, int right)
{int midi = (left + right) / 2;if (a[left] < a[midi]){if (a[midi] < a[right]){midi = midi;}else if (a[left] > a[right]){midi = left;}else {midi = right;}}else // a[left] > a[mid]{if (a[midi] > a[right]){midi = midi;}else if (a[left] < a[right]){midi = left;}else{midi = right;}}if (midi != left)Swap(&a[midi], &a[left]);
}

结合三数取中法实现快排

我们写好三数取中函数后只需要在正常快排函数中选定keyi后(如下函数的第45行后)调用一下三数取中函数就可以将三数取中选出的key值和原本的key值做交换了.

实现代码如下:

//三数取中函数
void SwapMid_key(int* a, int left, int right)
{int midi = (left + right) / 2;if (a[left] < a[midi]){if (a[midi] < a[right]){midi = midi;}else if (a[left] > a[right]){midi = left;}else {midi = right;}}else // a[left] > a[mid]{if (a[midi] > a[right]){midi = midi;}else if (a[left] < a[right]){midi = left;}else{midi = right;}}if (midi != left)Swap(&a[midi], &a[left]);
}//快速排序(前后指针法
void QuickSort_follow(int* a, int left, int right)
{if (left >= right)return;int begin = left, end = right;int keyi = left;    //选定序列首元素为基准值,记录下基准值SwapMid_key(a, left, right);   //三数取中法选出基准值后交换基准值int prev = left;int cur = prev + 1;while (cur <= right){if (a[cur] < a[keyi] && ++prev != cur){Swap(&a[cur], &a[prev]);}cur++;}Swap(&a[prev], &a[keyi]);keyi = prev;QuickSort_follow(a, begin, keyi - 1);//递归遍历左区间[begin , keyi-1]QuickSort_follow(a, keyi + 1, end);//递归遍历右区间[keyi+1 , end]
}

🎏小区间优化

📌小区间优化的原理

快排的递归展开思路类似于二叉树,因此它们拥有同样的弊病,就是越靠近树的底部,空递归的情况就越多,并且空递归的规模量非常大,拿下面这颗树来举例:

我们递归遍历该树,发现空递归(紫色)访问次数竟然和总有效访问次数(绿色)是相同的.而对于快排来说,这样的空递归不仅浪费时间,而且是没有任何实际意义的.

因此我们可以考虑采用一种办法,将快排的递归范围加以限制,比如当我们不断分割快排子区间,当子区间数组元素小于10个数时,我们就不再进行快排递归排序,而使用直接插入排序来对该小区间进行排序,这样就可以有效的消灭超过一半的递归,从而提升快排的效率.

📌小区间优化的代码实现

清楚了上面的原理之后,我们实现小区间优化的思路为:

  1. 判断小区间数组是否小于10个数.
  2. 如果区间不小于10,则执行快排逻辑.
  3. 如果区间小于等于10,则执行直接插入排序逻辑.

综上所述,小区间代码实现如下:

//交换函数
void Swap(int* a, int* b)
{int tmp = *a;*a = *b;*b = tmp;
}//三数取中法取key函数
void SwapMid_key(int* a, int left, int right)
{int midi = (left + right) / 2;if (a[left] < a[midi]){if (a[midi] < a[right]){midi = midi;}else if (a[left] > a[right]){midi = left;}else {midi = right;}}else // a[left] > a[mid]{if (a[midi] > a[right]){midi = midi;}else if (a[left] < a[right]){midi = left;}else{midi = right;}}if (midi != left)Swap(&a[midi], &a[left]);
}//直接插入排序函数
void InsertSort(int* a, int n)
{for (int i = 1; i < n; i++){int end = i - 1;int tmp = a[i];//将tmp插入到[0,end]这个区间里while (end >= 0){if (tmp < a[end]){a[end + 1] = a[end];end--;}else{break;}}a[end + 1] = tmp;}
}//小区间优化版快排
void QuickSort(int* a, int left, int right)
{if (left >= right)return;if ((right - left + 1 ) > 10){int keyi = left;SwapMid_key(a, left, right);//双指针前后移动法快排int prev = left;int cur = left + 1;while (cur <= right){if (a[cur] < a[keyi] && ++prev != cur)Swap(&a[cur], &a[prev]);++cur;}Swap(&a[prev], &a[keyi]);keyi = prev;QuickSort(a, left, keyi - 1);QuickSort(a, keyi + 1, right);}else{InsertSort( a + left , right - left + 1 );}
}

五.借助栈实现非递归快速排序

📌为什么要将递归的快速排序算法改为非递归?

递归函数有以下几个缺点:

  • 内存消耗大：递归调用会占用大量的内存空间，因为每次调用都需要在内存中保存当前的状态和参数。

  • 性能低下：递归调用会增加函数调用的开销，因此在一些情况下会导致程序的性能下降。

  • 可读性差：递归函数通常比较复杂，难以理解和调试，降低了代码的可读性。

  • 可能导致栈溢出：如果递归调用层次过深，会导致栈溢出的问题，使程序崩溃。

  • 难以优化：一些编译器和优化工具难以对递归函数进行有效的优化，导致性能不佳。

📌递归函数改非递归的思路

  1. 直接改为循环.(如:斐波那契数列)
  2. 利用栈辅助改为循环.(如:二叉树的前序遍历)

📌快速排序改非递归的思路

  1. 将初始数组区间压入栈
  2. 在栈里取一段区间,单趟排序
  3. 单趟分割子区间入栈
  4. 子区间只有一个值或着不存在就不入栈
  5. 重复步骤2-4,直到栈为空,则排序完成.

📌快速排序改非递归的代码实现

因为快排改非递归时要借助栈结构,因此我先将栈相关定义的头文件贴在这里,具体栈的C语言完整实现可以移步我的另一篇博客,在文末有数据结构栈实现的完整代码,大家可以直接粘贴过来使用:

【数据结构】C语言实现顺序栈(附完整运行代码)icon-default.png?t=N7T8http://t.csdnimg.cn/FL0V3(注:如果本身没有自己实现数据结构栈的工程文件的,一定要将该博客末尾的Stack.h文件和Stack.c文件粘贴在排序项目文件里才可以正常使用栈的相关功能,否则C语言是不支持直接使用的!)

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>typedef int STDataType;typedef struct Stack
{STDataType*arr;int top;int capacity;
}ST;void STInit(ST* ps);
void STDestroy(ST* ps);
void STPush(ST* ps, STDataType x);
void STPop(ST* ps);
int STSize(ST* ps);
bool STEmpty(ST* ps);
STDataType STTop(ST* ps);
void STMenu();

综上,快排的非递归代码实现如下:

//交换函数
void Swap(int* a, int* b)
{int tmp = *a;*a = *b;*b = tmp;
}//三数取中法取key函数
void SwapMid_key(int* a, int left, int right)
{int midi = (left + right) / 2;if (a[left] < a[midi]){if (a[midi] < a[right]){midi = midi;}else if (a[left] > a[right]){midi = left;}else {midi = right;}}else // a[left] > a[mid]{if (a[midi] > a[right]){midi = midi;}else if (a[left] < a[right]){midi = left;}else{midi = right;}}if (midi != left)Swap(&a[midi], &a[left]);
}//快速排序主函数(非递归版
void QuickSortNonR(int* a, int left, int right)
{ST st;STInit(&st);STPush(&st, right);//先入后出STPush(&st, left);while (!STEmpty(&st)){int begin = STTop(&st);STPop(&st);int end = STTop(&st);STPop(&st);int keyi = begin;SwapMid_key(a, begin, end);//双指针前后移动法快排int prev = begin;int cur = begin + 1;while (cur <= end){if (a[cur] < a[keyi] && ++prev != cur)Swap(&a[cur], &a[prev]);++cur;}Swap(&a[prev], &a[keyi]);keyi = prev;if (keyi + 1 < end){STPush(&st, end);STPush(&st, keyi + 1);}if (begin < keyi - 1){STPush(&st, keyi - 1);STPush(&st, begin);}}STDestroy(&st);
}

六.快速排序的三路划分

//主要解决快速排序面对大量重复数据时效率低下的问题

//该部分内容待补

结语

希望这篇快速排序算法详解能对大家有所帮助,欢迎大佬们留言或私信与我交流.

有关更多排序相关知识可以移步:

【数据结构】八大排序算法​​icon-default.png?t=N7T8https://blog.csdn.net/weixin_72357342/article/details/135038495?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22135038495%22%2C%22source%22%3A%22weixin_72357342%22%7D&fromshare=blogdetail

学海漫浩浩,我亦苦作舟!关注我,大家一起学习,一起进步!

相关文章推荐

【数据结构】八大排序之冒泡排序算法

【数据结构】八大排序之希尔排序算法

【数据结构】八大排序之直接插入排序算法

【数据结构】八大排序之简单选择排序

【数据结构】八大排序之堆排序算法

 数据结构排序篇思维导图:

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

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

相关文章

读算法霸权笔记12_数据科学

读算法霸权笔记12_数据科学

1. 公平与公正 1.1. 公平大多数时候只是副产品 1.2. 由贪婪或偏见导致的不公正一直发生在我们身边 1.2.1. 如果承认法律面前人人平等&#xff0c;或者作为选民的大众应该被平等对待&#xff0c;我们就不能允许模型把我们分为不同的群体进行区别对待 1.3. 对于数学模型来说&…
阅读更多...
学习Redis缓存

学习Redis缓存

学习Redis缓存 NoSQL和SQL的区别缓存缓存作用缓存成本添加Redis缓存 Redis特征Redis中数据结构Redis通用命令String类型Key的层级格式Hash类型Redis的Java客户端 NoSQL和SQL的区别 缓存 缓存就是数据交换的缓冲区&#xff0c;是存储数据的临时地方&#xff0c;一般读写性比较高…
阅读更多...
香橙派5b 移植 imx415

香橙派5b 移植 imx415

香橙派5b 移植 imx415 镜头配置 Sensor选用如下型号&#xff1a;香橙派OrangePi_5 RK3588S IMX415 我使用的时候更换了镜头&#xff0c;将该sensor装在了我的变焦780模组上&#xff0c;经过后续测试因为CAM1相对稳定&#xff0c;所以安装在CAM1。安装位置如下&#xff1a; 配…
阅读更多...
三英战吕布web3游戏项目启动全流程

三英战吕布web3游戏项目启动全流程

项目是一个学习相关的很好的例子并且开源&#xff0c;原本的项目是连接goerli网络&#xff0c;但我把它修改为可连接ganache网络的项目了&#xff0c;更方便启动。 智能合约部分 进入文件 hardhat.config.js &#xff0c;增加一个钱包私钥 2.执行npm install 3.测试合约 npx ha…
阅读更多...
分解质因数算法总结

分解质因数算法总结

知识概览 n中最多只包含一个大于的质因子。 例题展示 题目链接 活动 - AcWing 系统讲解常用算法与数据结构&#xff0c;给出相应代码模板&#xff0c;并会布置、讲解相应的基础算法题目。https://www.acwing.com/problem/content/869/ 题解 分解质因数可以用试除法解决&…
阅读更多...
高压放大器输出接法及其注意事项

高压放大器输出接法及其注意事项

高压放大器应用场景非常广泛&#xff0c;非常适用于半导体高压驱动、TFT产业高压驱动、各种高压工程等应用&#xff1b;也很适用当作音频信号产生器或函数波形产生器的波形放大使用。使用场景广泛&#xff0c;放大器的输出接法也多种&#xff0c;对于不同的放大器也有对应的输出…
阅读更多...
计算机网络（7）：网络安全

计算机网络（7）：网络安全

网络安全问题 计算机网络上的通信面临以下的四种威胁: (1)截获(interception)攻击者从网络上窃听他人的通信内容。 (2)中断(interruption)攻击者有意中断他人在网络上的通信。 (3)篡改(modification)攻击者故意篡改网络上传送的报文。 (4)伪造(fabrication)攻击者伪造信息在网…
阅读更多...
【Pytorch】学习记录分享10——TextCNN用于文本分类处理

【Pytorch】学习记录分享10——TextCNN用于文本分类处理

【Pytorch】学习记录分享10——PyTorchTextCNN用于文本分类处理 1. TextCNN用于文本分类2. 代码实现 1. TextCNN用于文本分类 具体流程&#xff1a; 2. 代码实现 # coding: UTF-8 import torch import torch.nn as nn import torch.nn.functional as F import numpy as np…
阅读更多...
Python接口自动化-参数关联（超详细的）

Python接口自动化-参数关联（超详细的）

前言 我们用自动化发帖之后&#xff0c;要想接着对这篇帖子操作&#xff0c;那就需要用参数关联了&#xff0c;发帖之后会有一个帖子的id&#xff0c;获取到这个id&#xff0c;继续操作传这个帖子id就可以了 &#xff08;博客园的登录机制已经变了&#xff0c;不能用账号和密…
阅读更多...
java.lang.NoSuchFieldError: No static field xxx of type I in class

java.lang.NoSuchFieldError: No static field xxx of type I in class

问题描述 将Library编译成 aar导入到另一个项目中依赖成功&#xff0c;编译成功&#xff0c;运行打开发生了崩溃异常如下图: 原因分析&#xff1a; 异常错误提示找不到id为recycler_1的控件了&#xff0c;我的Library中recycler_1控件是在MainActivity的xml中使用的&#xff0c…
阅读更多...
Redis高级特性和应用(慢查询、Pipeline、事务、Lua)

Redis高级特性和应用(慢查询、Pipeline、事务、Lua)

Redis的慢查询 许多存储系统（例如 MySQL)提供慢查询日志帮助开发和运维人员定位系统存在的慢操作。所谓慢查询日志就是系统在命令执行前后计算每条命令的执行时间，当超过预设阀值,就将这条命令的相关信息（例如:发生时间，耗时，命令的详细信息）记录下来，Redis也提供了类似…
阅读更多...
Android开发编程从入门到精通，安卓技术从初级到高级全套教学

Android开发编程从入门到精通，安卓技术从初级到高级全套教学

一、教程描述 本套教程基于JDK1.8版本&#xff0c;教学内容主要有&#xff0c;1、环境搭建&#xff0c;UI布局&#xff0c;基础UI组件&#xff0c;高级UI组件&#xff0c;通知&#xff0c;自定义组件&#xff0c;样式主题&#xff1b;2、四大组件&#xff0c;Intent&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023