【算法篇C++实现】常见排序算法

news2024/11/24 1:19:20

文章目录

  • 🚀一、选择排序
  • 🚀二、冒泡排序
  • 🚀三、插入排序
  • 🚀四、希尔排序
  • 🚀五、堆排序
  • 🚀六、归并排序
  • 🚀七、快速排序
  • ⛳总结：

🚀一、选择排序

算法精炼每趟从待排序的记录中选出关键字最小的记录，顺序放在已排序的记录序列末尾，直到全部排序结束为止。

简单排序处理流程

  1. 从待排序序列中，找到关键字最小的元素；
  2. 如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换；
  3. 从余下的 N - 1 个元素中，找出关键字最小的元素，重复1、2步，直到排序结束。

或者：

  1. 从待排序序列中，找到关键字最大的元素；
  2. 如果最大元素不是待排序序列的最后一个元素，将其和最后一个元素互换；
  3. 从余下的 N - 1 个元素中，找出关键字最大的元素，重复1、2步，直到排序结束。

img

时间复杂度：

  • 简单选择排序的比较次数与序列的初始排序无关。 假设待排序的序列有 N 个元素，第一个元素和后面每个元素比较（n-1次），将最小的排在前面，再将第二个元素和后面每个元素比较（n-2次），则可以近似地表示为 (n-1) + (n-2) + … + 1。这是一个等差数列的求和，可以使用等差数列求和公式进行计算。比较次数总是N (N - 1) / 2。
  • 所以，综合以上，简单排序的时间复杂度为 O(N^2)。

C语言代码实现：

 #include <stdio.h>
//最小值往前放
void SelectSort(int arr[], int len)
{
	if (len < 1 || arr == nullptr) return;
 
	for (int i = 0; i < len; i++)
	{
		int minindex = i;//用来保存最小值的索引
		for (int j = i + 1; j < len; j++)
		{
			if (arr[j] < arr[index])
			{
				index = j;
			}
		}
		int temp = arr[i];
		arr[i] = arr[index];
		arr[index] = temp;
	}
}
//最大值往后放
void SelectSort1(int arr[], int len)
{
	if (len < 1 || arr == nullptr) return;
 
	for (int i = len-1; i > 0; --i)
	{
		int index = i;//用来保存最大值的索引
		for (int j = 0; j < i; j++)
		{
			if (arr[j] > arr[index])
			{
				index = j;
			}
		}
		int temp = arr[index];
         arr[index] = arr[i];
         arr[i] = temp;
        }
	}
}

void PrintAddr(int arr[], int len)
{
	for (int i = 0; i < len; i++)
		printf("%d ", arr[i]);
	printf("\n");
}
int main()
{
	int arr[] = { 9,1,2,5,7,4,8,6,3,5 };
	int len = sizeof(arr) / sizeof(arr[0]);
	SelectSort(arr, len);
	PrintAddr(arr, len);
}

🚀二、冒泡排序

算法精炼依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面。

处理流程

  1. 第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。
  2. 比较第2和第3个数，将小数 放在前面，大数放在后面。…
  3. 如此继续，直到比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成
  4. 在上面一趟比较完成后，最后一个数一定是数组中最大的一个数，所以在比较第二趟的时候，最后一个数是不参加比较的。
  5. 在第二趟比较完成后，倒数第二个数也一定是数组中倒数第二大数，所以在第三趟的比较中，最后两个数是不参与比较的。
  6. 依次类推，每一趟比较次数减少依次

img

时间复杂度：

  • N个数字要排序完成，总共进行N-1趟排序
  • 每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数
  • 冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。
  • 如果我们的数据正序，总共只需要走一趟，这一趟比较N-1次，时间复杂度为O（N）
  • 最坏情况我们的数据是反序的，则需要进行n-1趟排序。每趟排序要进行n-i次比较，总共进行n(n-1)/2次比较。时间复杂度为O(N^2)

C语言代码实现：

#include <stdio.h>
 
void BubbleSort(int arr[],int len)
{
	if (len < 1 || arr==nullptr) return;
 
	for(int i=0;i<len;i++)
		for (int j=0; j < len-i-1; j++)
		{
			if (arr[j]> arr[j + 1])
			{
				int temp = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = temp;
			}
		}
}
 
void PrintAddr(int arr[], int len)
{
	for (int i = 0; i < len; i++)
		printf("%d ", arr[i]);
	printf("\n");
}
 
int main()
{
	int arr[] = { 10,1,35,61,89,36,55};
	int len = sizeof(arr) / sizeof(arr[0]);
	BubbleSort(arr, len);
	PrintAddr(arr, len);
}

🚀三、插入排序

**算法精炼:**通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用 in-place 排序（即只需用到 O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

具体描述：

  1. 从第一个元素开始，该元素可以认为已经被排序；
  2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
  3. 将该元素从后往前与每一个已排序元素比较，找到恰好的位置插入，大于前一个，小于后一个
  4. 将新元素插入到该位置；重复以上步骤 。

例子：

在这里插入图片描述

C语言代码实现：

#include <stdio.h>
 
void InsertSort(int arr[], int len)
{
	for (int i = 1; i < len; i++)
	{
		int curVaule = arr[i]; //从第二个元素开始
		int preIndex = i - 1;  //第一个元素下标
		
		while (preIndex >= 0 && arr[preIndex] > curVaule) //第一个数比新元素大
		{
			arr[preIndex + 1] = arr[preIndex];  //大的往后移
			preIndex--;  //继续判断前一个数
		}
		arr[preIndex + 1] = curVaule;  //直到找到小于或者等于新元素的数，while循环里面减去了1判断前一个，所以要加上
	}
}
 
void PrintAddr(int arr[], int len)
{
	for (int i = 0; i < len; i++)
		printf("%d ", arr[i]);
	printf("\n");
}
int main()
{
	int arr[] = { 171,161,163,165,167,169 };
	int len = sizeof(arr) / sizeof(arr[0]);
	InsertSort(arr, len);
	PrintAddr(arr, len);
}

🚀四、希尔排序

插入排序虽好,但是某些特殊情况也有很多缺点,比如像下面这种情况

在这里插入图片描述

169 前的元素基本不用插入操作就已经有序, 元素 1 和 2 的排序几乎要移动数组前面的所有元素!!! 于是,有个老帅哥就提出了优化此问题的希尔排序!

算法精炼：是希尔（Donald Shell）于 1959 年提出的一种排序算法。也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。它与插入排序的不同之处在于，它会优先比较距离较远的元素 。

基本步骤：

  1. 选择增量 ： gap=length/2，缩小增量： gap = gap/2
  2. 增量序列：用序列表示增量选择， {n/2, (n/2)/2, …, 1}
  3. 先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
    • 选择一个增量序列 t1，t2，…，tk，其中 ti>tj，tk=1；
    • 按增量序列个数 k，对序列进行 k 趟排序；
    • 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序;
    • 仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

img

C语言代码实现

#include<stdio.h>
void ShellSort(int arr[], int len)
{
	
	for (int gap = len / 2; gap > 0; gap /= 2)
	{
		for (int i = gap; i<len; i++) //每个组执行插入排序
		{
			int curValue = arr[i]; //arr[i]就是第一组的第二个数据
			int preIndex = i - gap; //自然这个就是第一组的第一个元素
 
			while (preIndex >= 0 && arr[preIndex] > curValue)
			{
				arr[preIndex + gap] = arr[preIndex];
				preIndex -= gap;
			}
			arr[preIndex + gap] = curValue;
		}
	}
}
void PrintAddr(int arr[], int len)
{
	for (int i = 0; i < len; i++)
		printf("%d ", arr[i]);
	printf("\n");
}
int main()
{
	int arr[] = { 8,9,1,7,2,3,5,4,6,0 };
	int len = sizeof(arr) / sizeof(arr[0]);
	ShellSort(arr, len);
	PrintAddr(arr, len);
}

🚀五、堆排序

**算法精炼：**指利用堆这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素

基本步骤：

  1. 第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置
  2. 然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾
  3. 以此类推，直到全部待排序的数据元素的个数为零

img

C语言代码实现

void heapSort(Heap &heap){
    if (heap.size<1) return ;
    
    while(heap.size>0){
        int tmp = heap.arr[0];
        heap.arr[0] = heap.arr[heap.size-1];
        heap.arr[heap.size-1] = tmp;
        
        heap.size--;
        adjustDown(heap, 0);// 向下执行堆调整
    }
}

其中要用到堆的向下调整算法，因为当我们将数组进行一次选择排序后，就不满足最大堆了。所以找到堆最大元素比较麻烦，但调整到最大堆后，就很方便找到为heap.arr[0]

堆相关的知识：【数据结构篇C++实现】- 树

堆的向下调整算法：

/*向下调整将当前的节点和子节点调整成最大堆*/
void adjustDown(Heap &heap, int index) { 
    int cur=heap.arr[index];//当前待调整的节点
	int parent,child;
/*判断否存在大于当前节点子节点，如果不存在 ，则堆本身是平衡的，不需要调整；如果存在，则将最大的子节点与之交换，交换后，如果这个子节点还有子节点，则要继续按照同样的步骤对这个子节点进行调整*/
	for(parent=index; (parent*2+1)<heap.size; parent=child) {
        child=parent*2+1;
        
        //取两个子节点中的最大的节点
        
        if(((child+1)<heap.size)&&(heap.arr[child]<heap.arr[child+1])) {
        	child++;
		}
        
            //判断最大的节点是否大于当前的父节点
         if(cur>=heap.arr[child]) {//不大于，则不需要调整，跳出循环
             break;
         }else {//大于当前的父节点，进行交换，然后从子节点位置继续向下调整
             heap.arr[parent]=heap.arr[child];
             heap.arr[child]=cur;
         }
    }
}

🚀六、归并排序

算法精炼：归并排序是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分为(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)

分治法：【算法篇C++实现】五大常规算法

img

可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）：

  1. 分阶段：可以理解为就是递归拆分子序列的过程，递归深度为log2n。
  2. 治阶段：**即合并相邻有序子序列：**我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。

img

img

C语言代码实现：

#include <stdio.h>
#include<string.h>
void MergeAdd(int arr[], int left, int mid, int right, int *temp)
{
	int lmin = left; //指向左边数组最小元素位置
	int rmin = mid;  //指向右边数组最小元素位置（实参是mid+1）
	int index = left; //临时数组下标
	
	while (lmin<mid && rmin<=right)
	{
		if (arr[lmin] < arr[rmin])
		{
			temp[index++] = arr[lmin++];	
		}
		else
		{
			temp[index++] = arr[rmin++];
		}
	}
 
    //如果是右边数组先移完
	while (lmin < mid)
		temp[index++] = arr[lmin++];
 
    //如果是左边数组先移完
	while (rmin <= right)
		temp[index++] = arr[rmin++];
 
	memcpy(arr + left, temp + left, sizeof(int)*(right - left + 1));
}
 
void MergeSort(int arr[], int left, int right, int *temp)
{
	if (left <0 || arr == nullptr) return;
 
	if (left < right)
	{
		int mid = (right+left)/2;
		MergeSort(arr, left, mid, temp);  	//左边一半递归实现
		MergeSort(arr, mid+1, right, temp); //右边一半递归实现
		MergeAdd(arr, left, mid + 1, right, temp); 	//分到最后，合并子列项
	}
}

void PrintAddr(int arr[], int len)
{
	for (int i = 0; i < len; i++)
		printf("%d ", arr[i]);
	printf("\n");
}
int main()
{
		int arr[] = { 8,9,1,7,2,3,5,4,6,0 };
		int len = sizeof(arr) / sizeof(arr[0]);
 
		int *temp = new int[len];
		MergeSort(arr,0,len-1,temp);
		PrintAddr(arr, len);
		delete temp;
}

🚀七、快速排序

**算法精炼：**每次选取第一个数为基准数；然后将大于和小于基准的元素分别放置于基准数两边–>“乾坤大挪移”；继续分别对基准数两侧未排序的数据使用分治法进行细分处理，直至整个序列有序。

img

img

C语言代码实现：

#include <stdio.h>
int partition(int arr[], int low, int high)
{
	int i = low;
	int j = high;
	int base = arr[low]; //选择第一个数作为基准
 
	if (low < high)
	{
		while (i < j)
		{
			while (i < j && arr[j] >= base) 
			{
				j--; //从右往左找到比基准数小的
			}
			if (i < j)//右边有比基数小的数（排除j<i的情况）
			{
				arr[i++] = arr[j];
			}
 
			while (i < j&&arr[i] < base) 
			{
				i++; //从左往右找到比基准数大的
			}
			if (i < j)//左边有比基数大的数
			{
				arr[j--] = arr[i];
			}
		}
 
		arr[i] = base;
	}
	return i;
}
//快速排序
void QuickSort(int arr[], int low, int high)
{
	if (low < high)
	{
		int index = partition(arr, low, high); //快速排序
		QuickSort(arr, low, index - 1); //左边一半快速排序
		QuickSort(arr, index + 1, high); //右边一半快速排序
	}
}
 
void PrintAddr(int arr[], int len)
{
	for (int i = 0; i < len; i++)
		printf("%d ", arr[i]);
	printf("\n");
}
int main()
{
	int arr[] = { 163, 161, 158, 165, 171, 170, 163, 159, 162 };
 
	int len = sizeof(arr) / sizeof(arr[0]);
	QuickSort(arr, 0, len - 1);
	PrintAddr(arr, len);
}

⛳总结：

排序算法平均时间复杂度最好情况最坏情况排序方式稳定性
冒泡排序O(n * n)O(n)O(n * n)In-place稳定
选择排序O(n * n)O(n * n)O(n * n)In-place不稳定
插入排序O(n * n)O(n)O(n * n)In-place稳定
希尔排序O(n * log n)O(n * log n)O(n * log n)In-place不稳定
归并排序O(n * log n)O(n * log n)O(n * log n)Out-place稳定
堆排序O(n * log n)O(n * log n)O(n * log n)In-place不稳定
快速排序O(n * log n)O(n * log n)O(n * n)In-place不稳定

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

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

相关文章

MySql存储过程详解

MySql存储过程详解

文章目录 存储过程1 介绍 基本语法创建:调用查看删除演示: 变量相关系统变量演示: 用户自定义变量局部变量 if语法参数介绍casewhilerepeatloop游标条件处理程序存储函数 存储过程 1 介绍 存储过程是事先经过编译并存储在数据库中的一段 SQL 语句的集合&#xff0c;调用存储过…
阅读更多...
章节3：Burp Suite模块详解及Proxy模块

章节3：Burp Suite模块详解及Proxy模块

章节3&#xff1a;Burp Suite模块详解及Proxy模块 3.1 Burp Suite界面布局 参考手册目录全文 https://portswigger.net/burp/documentation/contents 界面总览 旧版对比 菜单栏-Burp 搜索内容配置库用户选项Infiltrator&#xff08;渗透器&#xff09;Clickbandit&#xff…
阅读更多...
zerotier requesting configuration

zerotier requesting configuration

Q:zerotir无法获取physical ip A:路由器管理页面开启ipv6
阅读更多...
2.函数进阶

2.函数进阶

2.1函数提升 函数提升与变量提升比较类似&#xff0c;是指函数在声明之前即可被调用。 总结: 1.函数提升能够使函数的声明调用更灵活 2.函数表达式不存在提升的现象 3.函数提升出现在相同作用域当中 2.2函数参数 1.动态参数 arguments 是函数内部内置的伪数组变量&#xff…
阅读更多...
Java多线程知识点，看这一篇就够了！（超详细）

Java多线程知识点，看这一篇就够了！（超详细）

目录 一、认识线程&#xff08;Thread&#xff09; 1、概念 2、第一个多线程程序 &#xff08;1&#xff09;观察线程 3、创建线程 二、Thread 类及常见方法 1、Thread 的常见构造方法 2、Thread 的几个常见属性 3、启动一个线程&#xff1a;start 4、终止一个线程 &…
阅读更多...
【JavaEE进阶】SpringBoot 配置文件

【JavaEE进阶】SpringBoot 配置文件

文章目录 SpringBoot配置文件1. 配置文件的作用2. 配置文件的格式3. properties 配置文件说明3.1 properties 基本语法3.2 读取配置文件3.3 properties 优缺点分析 4. yml配置文件说明4.1 yml 基本语法4.2 yml 配置读取 5. properties和yml的对比 SpringBoot配置文件 1. 配置文…
阅读更多...
C++笔记之Eigen库的使用

C++笔记之Eigen库的使用

C笔记之Eigen库的使用 code review! 文章目录 C笔记之Eigen库的使用0.矩阵构造和矩阵初始化1.声明一个2\*3的float矩阵&#xff1a;Matrix<float, 2, 3> matrix_23;2.初始化Matrix<float, 2, 3> matrix_23;- 使用逗号初始化器&#xff1a;- 使用赋值运算符逐个赋…
阅读更多...
JZ38 字符串的排列

JZ38 字符串的排列

题目地址&#xff1a;字符串的排列_牛客题霸_牛客网 题目回顾&#xff1a; 解题思路&#xff1a; 这里用到了全排列和剪枝。 首先我们来说全排列&#xff0c;设置一个vis数组来记录当期元素是否被使用过&#xff0c;然后dfs遍历整个数组&#xff0c;列出所有符合条件的路径就是…
阅读更多...
【ts】【cocos creator】excel表格转JSON

【ts】【cocos creator】excel表格转JSON

需要将表格导出为text格式放到项目resources/text文件夹下 新建场景&#xff0c;挂载到Canvas上运行 表格文件格式&#xff1a; 保存格式选text tableToJson : import CryptoJS require(./FileSaver);const { ccclass, property } cc._decorator;ccclass export default c…
阅读更多...
完结，从零开始学python（十八）想成为一名APP逆向工程师，需要掌握那些技术点？

完结，从零开始学python（十八）想成为一名APP逆向工程师，需要掌握那些技术点？

作为从零学python的最后一篇文章&#xff0c;我们来简单的回顾一下内容 1.编程语法 语法编程并发编程 网络编程多线程/多进程/协程 数据库编程 MySQLRedisMongoDB 2.机器学习 3.全栈开发 4.数据分析 NumpypandasMatplotlibHadoopSpark 5.爬虫工程师养成 采集功底自动化…
阅读更多...
js合并数组对象（将数组中具有相同属性对象合并到一起，组成一个新的数组）

js合并数组对象（将数组中具有相同属性对象合并到一起，组成一个新的数组）

一、根据数组对象中某一key值&#xff0c;合并相同key值的字段&#xff0c;到同一个数组对象中&#xff0c;组成新的数组 1.原数组&#xff1a; var array [{ id: 1, name: Alice },{ id: 2, name: Bob },{ id: 1, age: 25 },{ id: 3, name: Charlie, age: 30 } ];2.合并后数…
阅读更多...
【JVM】Java内存泄露的排查思路？

【JVM】Java内存泄露的排查思路？

文章目录 Java内存为什么会泄露&#xff1f;java内存泄露的排查思路 Java内存为什么会泄露&#xff1f; Java内存泄露&#xff08;Memory Leak&#xff09;是指在Java程序中&#xff0c;无用的对象占用了堆内存&#xff0c;但无法被垃圾回收器回收释放&#xff0c;从而导致可用…
阅读更多...
Java地图专题课 基本API BMapGLLib 地图找房案例 MongoDB

Java地图专题课 基本API BMapGLLib 地图找房案例 MongoDB

本课程基于百度地图技术&#xff0c;由基础入门开始到应用实战&#xff0c;适合零基础入门学习。将企业项目中地图相关常见应用场景的落地实战&#xff0c;包括有地图找房、轻骑小程序、金运物流等。同时讲了基于Netty实现高性能的web服务&#xff0c;来处理高并发的问题。还讲…
阅读更多...
Vue前端 更具router.js 中的meta的roles实现路由卫士，实现权限判断。

Vue前端 更具router.js 中的meta的roles实现路由卫士，实现权限判断。

参考了之篇文章 1、我在登陆时获取到登录用户的角色名roles&#xff0c;并存入sessionStorage中&#xff0c;具体是在login页面实现&#xff0c;还是在menu页面实现都可以。在menu页面实现&#xff0c;可以显得登陆快一些。 2、编写router.js&#xff0c;注意&#xff0c;一个…
阅读更多...
链表（基础详解、实现、OJ笔试题）

链表（基础详解、实现、OJ笔试题）

文章目录 &#x1f9da;什么是链表&#xff08;链表概念及分类&#xff09;链表分类单链表和双链表的区别 &#x1f6b4;‍♂️单链表、双向链表的实现单链表的实现双向链表的实现 &#x1f349;链表经典OJ笔试题反转单链表移除链表元素合并两个有序链表链表分割链表的中间结点…
阅读更多...
Ajax入门+aixos+HTTP协议

Ajax入门+aixos+HTTP协议

一.Ajax入门 概念:AJAX是浏览器与服务器进行数据通信的技术 axios使用: 引入axios.js使用axios函数:传入配置对象,再用.then回调函数接受结果,并做后续处理 <!DOCTYPE html> <html><head><meta charset"utf-8"><title>01.axios使用…
阅读更多...
【软件工程】面向对象方法-RUP

【软件工程】面向对象方法-RUP

RUP&#xff08;Rational Unified Process&#xff0c;统一软件开发过程&#xff09;。 RUP特点 以用况驱动的&#xff0c;以体系结构为中心的&#xff0c;迭代增量式开发 用况驱动 用况是能够向用户提供有价值结果的系统中的一种功能用况获取的是功能需求 在系统的生存周期中…
阅读更多...
机器学习笔记：李宏毅 stable diffusion

机器学习笔记：李宏毅 stable diffusion

1 基本框架 ①&#xff1a;文字变成向量 ②&#xff1a;喂入噪声文字encoder&#xff0c;产生中间产物 ③&#xff1a;decoder 还原图片 2 text encoder 这张图越往右下表示效果越好&#xff0c;可以看到text encoder尺寸越大&#xff0c;对后续生成图片的增益越多 3 评价图…
阅读更多...
【linux基础操作】如何一键下载 各个版本的python库文件

【linux基础操作】如何一键下载 各个版本的python库文件

把需要下载的库名字&版本号&#xff0c;存在.txt文件中 2. 输入命令执行&#xff0c;下载 pip install -r your_file_name该命令的作用是从指定的文本文件中安装 Python 依赖库。 在这个命令中&#xff0c;-r 参数表示从一个文本文件&#xff08;通常以 .txt 结尾&#xf…
阅读更多...
FastAPI入门

FastAPI入门

目录 FastAPI FastAPI 是什么 为什么要用 FastAPI FastAPI 入门 安装 用 FastAPI 写个接口 调试接口 创建快捷请求 保存为快捷请求 发送请求 总结 FastAPI FastAPI 是什么 什么是 FastAPI 呢&#xff1f; FastAPI 是 Python 的一个框架&#xff0c;如果要类比的话…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023