排序介绍和学习：史上最全的排序算法

最新推荐文章于 2021-12-15 22:56:26 发布
最新推荐文章于 2021-12-15 22:56:26 发布
阅读量130 收藏
点赞数 1
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42989738/article/details/109015915
版权

一、冒泡排序

#include<sys/timeb.h> //这个可以精确到毫秒

#define MAX 10000

//获取精确的时间函数
long getSystemTime()
{
	struct timeb tb;
	ftime(&tb);
	return tb.time * 1000 + tb.millitm;
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#include<sys/timeb.h> //这个可以精确到毫秒

#define MAX 10000

//获取精确的时间函数
long getSystemTime()
{
	struct timeb tb;
	ftime(&tb);
	return tb.time * 1000 + tb.millitm;
}

//交换函数
void swap(int *a, int *b)
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

//冒泡排序
void BubbleSort(int arr[],int len)
{
	for (int i = 0; i < len - 1; i++)//i = 0; i<len - 1
	{ for (int j = 0; j < len - i - 1; j++) //j = 0; j<len - j - 1
		{
			if (arr[j] > arr[j+1])
			{
				swap(&arr[j], &arr[j+1]);
			}
		}
	}		
}

void PrintArray(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}


int main(void)
{
	int arr[MAX];
	srand((unsigned int)time(NULL));
	for (int i = 0; i < MAX; i++)
	{
		arr[i] = rand() % MAX;
	}
	printf("排序前:\n  ");
	PrintArray(arr,MAX);
	long tstart = getSystemTime();
	BubbleSort(arr,MAX);
	long tend = getSystemTime(); 
	printf("排序后:\n  ");
	PrintArray(arr, MAX);
	printf("冒泡排序%d个元素，所需时间%ld\n",MAX,tend-tstart);

	system("pause");
	return 0;
}

二、选择排序

在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#include<sys/timeb.h> //这个可以精确到毫秒

#define MAX 100000

//获取精确的时间函数
long getSystemTime()
{
	struct timeb tb;
	ftime(&tb);
	return tb.time * 1000 + tb.millitm;
}

//交换函数
void swap(int *a, int *b)
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

//冒泡排序
void BubbleSort(int arr[],int len)
{
	for (int i = 0; i < len - 1; i++)//i = 0; i<len - 1
	{ for (int j = 0; j < len - i - 1; j++) //j = 0; j<len - j - 1
		{
			if (arr[j] > arr[j+1])
			{
				swap(&arr[j], &arr[j+1]);
			}
		}
	}		
}

void PrintArray(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}

//选择排序
void SelectSort(int arr[],int len)
{
	//选择排序是不是减少交换次数
	for (int i = 0; i < len; i++)	
	{
		int min = i;
		for (int j = i + 1; j < len; j++)
		{
			if (arr[j] < arr[min])
			{
				min = j;
			}
		}
		if (min != i)
		{
			swap(&arr[min], &arr[i]);
		}

	}
}
int main(void)
{
	int arr[MAX];
	srand((unsigned int)time(NULL));
	for (int i = 0; i < MAX; i++)
	{
		arr[i] = rand() % MAX;
	}
	//冒泡排序
	long tbubble_start = getSystemTime();
	BubbleSort(arr,MAX);
	long tbubble_end = getSystemTime();
	printf("冒泡排序%d个元素，所需时间%ld\n",MAX, tbubble_end- tbubble_start);

	//选择排序
	long tselect_start = getSystemTime();
	SelectSort(arr, MAX);
	long tselect_end = getSystemTime();
	printf("冒泡排序%d个元素，所需时间%ld\n", MAX, tselect_end - tselect_start);

	system("pause");
	return 0;
}

三、插入排序

在这里插入图片描述

插入排序

//基本有序的排列的情况下，效率是非常高的，或者元素的个数比较少的时候，效率也是比较高的
在这里插入图片描述
将序列分为两部分，一部分是有序的，一部分是无序的。
核心代码：

//插入排序
//基本有序的排列的情况下，效率是非常高的，或者元素的个数比较少的时候，效率也是比较高的
void InsertSort(int arr[], int len)
{
	int j=0;
	for (int i = 1; i < len; i++)
	{
		if (arr[i] < arr[i - 1])
		{
			int temp = arr[i];
			for (int j = i - 1; j >= 0 && temp < arr[j]; j--)//两个判断条件
			{
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = temp;
		}
	}
}

完整代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#include<sys/timeb.h> //这个可以精确到毫秒

#define MAX 10000

//获取精确的时间函数
long getSystemTime()
{
	struct timeb tb;
	ftime(&tb);
	return tb.time * 1000 + tb.millitm;
}

//交换函数
void swap(int *a, int *b)
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

//冒泡排序
void BubbleSort(int arr[],int len)
{
	for (int i = 0; i < len - 1; i++)//i = 0; i<len - 1
	{ for (int j = 0; j < len - i - 1; j++) //j = 0; j<len - j - 1
		{
			if (arr[j] > arr[j+1])
			{
				swap(&arr[j], &arr[j+1]);
			}
		}
	}		
}

void PrintArray(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}

//选择排序
void SelectSort(int arr[],int len)
{
	//选择排序是不是减少交换次数
	for (int i = 0; i < len; i++)	
	{
		int min = i;
		for (int j = i + 1; j < len; j++)
		{
			if (arr[j] < arr[min])
			{
				min = j;
			}
		}
		if (min != i)
		{
			swap(&arr[min], &arr[i]);
		}

	}
}

//插入排序
//基本有序的排列的情况下，效率是非常高的，或者元素的个数比较少的时候，效率也是比较高的
void InsertSort(int arr[], int len)
{
	int j=0;
	for (int i = 1; i < len; i++)
	{
		if (arr[i] < arr[i - 1])
		{
			int temp = arr[i];
			for (int j = i - 1; j >= 0 && temp < arr[j]; j--)//两个判断条件
			{
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = temp;
		}
	}
}
int main(void)
{
	int arr[MAX];
	srand((unsigned int)time(NULL));
	for (int i = 0; i < MAX; i++)
	{
		arr[i] = rand() % MAX;
	}
	//冒泡排序
	long tbubble_start = getSystemTime();
	BubbleSort(arr,MAX);
	long tbubble_end = getSystemTime();
	printf("冒泡排序%d个元素，所需时间%ld\n",MAX, tbubble_end- tbubble_start);

	//选择排序
	long tselect_start = getSystemTime();
	SelectSort(arr, MAX);
	long tselect_end = getSystemTime();
	printf("冒泡排序%d个元素，所需时间%ld\n", MAX, tselect_end - tselect_start);
	printf("------------------------\n");;
	//PrintArray(arr, MAX);
	//InsertSort(arr, MAX);
	srand((unsigned int)time(NULL));
	for (int i = 0; i < MAX; i++)
	{
		arr[i] = rand() % MAX;
	}
	long tinsert_start = getSystemTime();
	InsertSort(arr, MAX);
	long tinsert_end = getSystemTime();
	printf("冒泡排序%d个元素，所需时间%ld\n", MAX, tinsert_end - tinsert_start);

	system("pause");
	return 0;
}

在这里插入图片描述
如图可以看出来，各种排序的算法快慢！
对于插入排序，元素的序列基本有序的情况下
插入排序在数据量比较小的情况下，效果较好！
由此：可以思考
分组，插入排序
先分组 然后对每一组分别进行插入排序

希尔排序

在这里插入图片描述
核心代码：

//希尔排序
void ShellSort(int arr[], int len)
{
	int i, j=0,k=0;
	int increasement = len;
	do {
		//确定分组的增量
		increasement = increasement / 3 + 1;
		for (i = 0; i < increasement; i++)
		{
			for (j = i + increasement; j < len; j += increasement)
			{
				if (arr[j] < arr[j - increasement])
				{
					int temp = arr[j];
					for (k = j - increasement; k >= 0 && temp < arr[k]; k -= increasement)
					{
						arr[k + increasement] = arr[k];
					}
					arr[k + increasement] = temp;
				}
			}
		}
	} while (increasement > 1);
}

完整代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#include<sys/timeb.h> //这个可以精确到毫秒

#define MAX 50000

//获取精确的时间函数
long getSystemTime()
{
	struct timeb tb;
	ftime(&tb);
	return tb.time * 1000 + tb.millitm;
}

//交换函数
void swap(int *a, int *b)
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

//冒泡排序
void BubbleSort(int arr[],int len)
{
	for (int i = 0; i < len - 1; i++)//i = 0; i<len - 1
	{ for (int j = 0; j < len - i - 1; j++) //j = 0; j<len - j - 1
		{
			if (arr[j] > arr[j+1])
			{
				swap(&arr[j], &arr[j+1]);
			}
		}
	}		
}

void PrintArray(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}

//选择排序
void SelectSort(int arr[],int len)
{
	//选择排序是不是减少交换次数
	for (int i = 0; i < len; i++)	
	{
		int min = i;
		for (int j = i + 1; j < len; j++)
		{
			if (arr[j] < arr[min])
			{
				min = j;
			}
		}
		if (min != i)
		{
			swap(&arr[min], &arr[i]);
		}

	}
}

//插入排序
//基本有序的排列的情况下，效率是非常高的，或者元素的个数比较少的时候，效率也是比较高的
void InsertSort(int arr[], int len)
{
	int j=0;
	for (int i = 1; i < len; i++)
	{
		if (arr[i] < arr[i - 1])
		{
			int temp = arr[i];
			for (int j = i - 1; j >= 0 && temp < arr[j]; j--)//两个判断条件
			{
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = temp;
		}
	}
}

//希尔排序
void ShellSort(int arr[], int len)
{
	int i, j=0,k=0;
	int increasement = len;
	do {
		//确定分组的增量
		increasement = increasement / 3 + 1;
		for (i = 0; i < increasement; i++)
		{
			for (j = i + increasement; j < len; j += increasement)
			{
				if (arr[j] < arr[j - increasement])
				{
					int temp = arr[j];
					for (k = j - increasement; k >= 0 && temp < arr[k]; k -= increasement)
					{
						arr[k + increasement] = arr[k];
					}
					arr[k + increasement] = temp;
				}
			}
		}
	} while (increasement > 1);
}
int main(void)
{
	int arr[MAX];
	srand((unsigned int)time(NULL));
	for (int i = 0; i < MAX; i++)
	{
		arr[i] = rand() % MAX;
	}
	//冒泡排序
	long tbubble_start = getSystemTime();
	BubbleSort(arr,MAX);
	long tbubble_end = getSystemTime();
	printf("冒泡排序%d个元素，所需时间%ld\n",MAX, tbubble_end- tbubble_start);

	//选择排序
	long tselect_start = getSystemTime();
	SelectSort(arr, MAX);
	long tselect_end = getSystemTime();
	printf("选择排序%d个元素，所需时间%ld\n", MAX, tselect_end - tselect_start);
	printf("------------------------\n");
	//PrintArray(arr, MAX);
	//InsertSort(arr, MAX);
	srand((unsigned int)time(NULL));
	for (int i = 0; i < MAX; i++)
	{
		arr[i] = rand() % MAX;
	}
	long tinsert_start = getSystemTime();
	InsertSort(arr, MAX);
	long tinsert_end = getSystemTime();
	printf("插入排序%d个元素，所需时间%ld\n", MAX, tinsert_end - tinsert_start);

	printf("------------------------\n");
	for (int i = 0; i < MAX; i++)
	{
		arr[i] = rand() % MAX;
	}
	long tShell_start = getSystemTime();
	ShellSort(arr,MAX);
	long eShell_end = getSystemTime();
	printf("Shell排序%d个元素，所需时间%ld\n", MAX, eShell_end - tShell_start);
	system("pause");
	return 0;
}

在这里插入图片描述
以上排序完整代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#include<sys/timeb.h> //这个可以精确到毫秒

#define MAX 50000

//获取精确的时间函数
long getSystemTime()
{
	struct timeb tb;
	ftime(&tb);
	return tb.time * 1000 + tb.millitm;
}

//交换函数
void swap(int *a, int *b)
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

//冒泡排序
void BubbleSort(int arr[],int len)
{
	for (int i = 0; i < len - 1; i++)//i = 0; i<len - 1
	{ for (int j = 0; j < len - i - 1; j++) //j = 0; j<len - j - 1
		{
			if (arr[j] > arr[j+1])
			{
				swap(&arr[j], &arr[j+1]);
			}
		}
	}		
}

void PrintArray(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}

//选择排序
void SelectSort(int arr[],int len)
{
	//选择排序是不是减少交换次数
	for (int i = 0; i < len; i++)	
	{
		int min = i;
		for (int j = i + 1; j < len; j++)
		{
			if (arr[j] < arr[min])
			{
				min = j;
			}
		}
		if (min != i)
		{
			swap(&arr[min], &arr[i]);
		}

	}
}

//插入排序
//基本有序的排列的情况下，效率是非常高的，或者元素的个数比较少的时候，效率也是比较高的
void InsertSort(int arr[], int len)
{
	int j=0;
	for (int i = 1; i < len; i++)
	{
		if (arr[i] < arr[i - 1])
		{
			int temp = arr[i];
			for (int j = i - 1; j >= 0 && temp < arr[j]; j--)//两个判断条件
			{
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = temp;
		}
	}
}

//希尔排序
void ShellSort(int arr[], int len)
{
	int i, j=0,k=0;
	int increasement = len;
	do {
		//确定分组的增量
		increasement = increasement / 3 + 1;
		for (i = 0; i < increasement; i++)
		{
			for (j = i + increasement; j < len; j += increasement)
			{
				if (arr[j] < arr[j - increasement])
				{
					int temp = arr[j];
					for (k = j - increasement; k >= 0 && temp < arr[k]; k -= increasement)
					{
						arr[k + increasement] = arr[k];
					}
					arr[k + increasement] = temp;
				}
			}
		}
	} while (increasement > 1);
}
int main(void)
{
	int arr[MAX];
	srand((unsigned int)time(NULL));
	for (int i = 0; i < MAX; i++)
	{
		arr[i] = rand() % MAX;
	}
	//冒泡排序
	long tbubble_start = getSystemTime();
	BubbleSort(arr,MAX);
	long tbubble_end = getSystemTime();
	printf("冒泡排序%d个元素，所需时间%ld\n",MAX, tbubble_end- tbubble_start);

	//选择排序
	long tselect_start = getSystemTime();
	SelectSort(arr, MAX);
	long tselect_end = getSystemTime();
	printf("选择排序%d个元素，所需时间%ld\n", MAX, tselect_end - tselect_start);
	printf("------------------------\n");
	//PrintArray(arr, MAX);
	//InsertSort(arr, MAX);
	srand((unsigned int)time(NULL));
	for (int i = 0; i < MAX; i++)
	{
		arr[i] = rand() % MAX;
	}
	long tinsert_start = getSystemTime();
	InsertSort(arr, MAX);
	long tinsert_end = getSystemTime();
	printf("插入排序%d个元素，所需时间%ld\n", MAX, tinsert_end - tinsert_start);

	printf("------------------------\n");
	for (int i = 0; i < MAX; i++)
	{
		arr[i] = rand() % MAX;
	}
	long tShell_start = getSystemTime();
	ShellSort(arr,MAX);
	long eShell_end = getSystemTime();
	printf("Shell排序%d个元素，所需时间%ld\n", MAX, eShell_end - tShell_start);
	system("pause");
	return 0;
}

（完！）

贪玩老学长
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排序学习（Learning to rank）
whaty6的博客
02-22 1491
一、信息检索的评价指标 MAP与NDCG是推荐召回中最常用的排序指标。 1、MAP（Mean Average Precision) 平均准确率，相关文档检索出后的准确率的平均值。检索出来的相关文档越靠前（rank越高），MAP就越高。 （1）公式 其中m是主题数量，先计算每个主题的AP，再求平均值； AP可以简单认为是： 其中R表示相关文档的总个数，position( r)表示第 r 篇文档搜索出来的rank排名A。 （2）实例 topic docs rank AP 1 1,
图解排序算法：快速排序
tyrroo的博客
09-04 261
快速排序算法 首先选一个基准 pivot，然后过一遍数组， 把小于 pivot 的都挪到 pivot 的左边， 把大于 pivot 的都挪到 pivot 的右边。 这样一来，这个 pivot 的位置就确定了，也就是排好了 1 个元素。 然后对 pivot 左边 ???? 的数排序， 对 pivot 右边 ???? 的数排序， 就完成了。 那怎么排左边和右边？ 答：同样的方法。 所以快排也是用的分治法的思想。 「分」 选择一个 pivot，就把问题分成了 pivot 左边 pivot 右
排序算法最全介绍（写的实在太好）
qq_38356760的博客
07-12 323
0、排序算法说明0.1 排序的定义对一序列对象根据某个关键字进行排序。0.2 术语说明稳定：如果a原本在b前面...
数据结构和算法-排序算法（java实现）
WaXiaoHui的博客
07-29 110
文章目录 文章目录文章目录前言内容1、归并排序2、堆排序3、基数排序4、冒泡排序5、快速排序6、希尔排序7、插入排序8、选择排序总结 前言 建议大家还是看看目录，自测一下 提示：以下是本篇文章正文内容，下面代码只是核心代码的实现，使用时做些小改动就可以 内容 1、归并排序 public int[] sort(int[] a,int low,int high){ int mid=(low+high)/2; if(low<hig){ sort(a,low,mid); sort(a,mid
排序算法一览（c语言实现）
julia_xueli的博客
12-15 1349
前言 本文主要介绍四大排序思想，详情看旁栏目录。 先附上用于检验的主函数以及相关准备工作。 #include <stdio.h> #include <stdlib.h> #define LeftChild(i) (2*(i)+1) #define cutoff (3) void print(int arr[],int N) { for(int i=0; i<N; i++) { printf("%d ",arr[i]); } printf("\n"); } void
System.nanoTime()和System.currentTimeMillis()区别 (还是直接看API比较清晰)
随笔记录-分享&记忆
02-09 4101
先来看看System的静态方法nanoTime() public static long nanoTime() 返回最准确的可用系统计时器的当前值，以毫微秒为单位。 此方法只能用于测量已过的时间，与系统或钟表时间的其他任何时间概念无关。返回值表示从某一固定但任意的时间算起的毫微秒数（或许从以后算起，所以该值可能为负）。此方法提供毫微秒的精度，但不是必要的毫微秒的准确度。它对于值的更改频
史上最全经典排序算法总结(Java实现).zip
最新发布
01-14
跨平台性（Write Once, Run Anywhere）： Java的代码可以在不同的平台上运行，只需编写一次代码，就可以在任何支持Java的设备上执行。这得益于Java虚拟机（JVM），它充当了代码和底层硬件之间的中介。 面向对象： ...
史上最清晰 - Java经典算法教程：冒泡排序
09-13
冒泡排序是一种基础的排序算法，适用于初学者学习和理解排序的基本思想。它的核心机制是通过重复遍历待排序的数组，比较相邻的元素并根据需要进行交换，以确保每一轮遍历结束后，最大的元素都能被移动到正确的位置。...
最快的排序算法 计算机最快的算法-史上14个最快速算法：孩子的计算能力爆表！大脑堪比计算机！...，排序算法数据结构
04-07
在计算机科学领域中，排序算法是一种基本的算法，它可以将数据按照一定的顺序排列，以便更好地存储、检索和处理数据。排序算法的速度和效率对程序的性能有着至关重要的影响。 1.冒泡排序算法 冒泡排序算法是一种...
史上最清晰、最详细的归并排序算法详解：Java示例代码和逻辑解析 保证你是小白也能看懂
09-13
归并排序（Merge Sort）是一种基于分治策略的高效排序算法，它的核心思想是将大问题分解为小问题，再将小问题的解组合成原问题的解。具体来说，归并排序的过程包括两个主要步骤：分割（Divide）和合并（Merge）。 1...
两个SYSTEMTIME比较差异（秒数、天数……）的方法
小米的修行之路
11-19 8063
[cpp] view plain copy time_t FileTimeToTime_t(const FILETIME &ft)   {       ULARGE_INTEGER ui;       ui.LowPart = ft.dwLowDateTime;       ui.HighPart = ft.dwHighDateTime;       ret
【学习排序】 Learning to Rank 中Listwise关于ListNet算法讲解及实现
weixin_33810006的博客
02-05 997
前一篇文章"Learning to Rank中Pointwise关于PRank算法源码实现"讲述了基于点的学习排序PRank算法的实现.该篇文章主要讲述Listwise Approach和基于神经网络的ListNet算法及Java实现.包括： 1.基于列的学习排序(Listwise)介绍 2.ListNet算法介绍 3...
排序算法-八大排序实现和性能比较
林元煌
12-28 2万+
概述   常见的八大排序算法，他们之间关系如下：   本文的开发语言是用Java，为了更好的演示，这里先新建一个工具类NumberUtils ，用来生成随机数组和打印排序前后数组的内容。 public class NumberUtils { /** * 获取随机int类型数组 */ public static int[] getRandomArs...
十大经典排序，学习排序的时候，参照某位大佬的
weixin_42232639的博客
10-18 872
今天再学习排序算法的时候，没有太大的头绪，然后就果断百度了一下，发现大神很多，没有细心的去发现，接下来这篇文章来自于一个大神，说的很详细，也很不错，然后就先搞下来，以便日后查看！！ 感谢博主 原文戳他-->https://www.cnblogs.com/onepixel/p/7674659.html 0.1 算法分类 十种常见排序算法可以分为两大类： 比较类排序：通过比较...
排序学习（Learning to rank）综述
热门推荐
anshuai_aw1的博客
01-09 4万+
Learning to rank(简写 LTR、L2R) 也叫排序学习，指的是机器学习中任何用于排序的技术。 目录 一、LTR引言 1.1 LTR的出现背景 1.2 LTR基本框架 二、训练数据的获取 2.1人工标注 2.2搜索日志 2.3公共数据集 三、特征提取 四、模型训练 4.1 单文档方法（PointWise Approach） 4.2文档对方法（PairW...
两个SYSTEMTIME比较
awu999328的专栏
04-25 2249
转自：
排序学习概述
乐享极客
05-26 5282
排序学习 排序学习简单说就是在排序任务中使用机器学习的方法，在信息检索、自然语言处理与数据挖掘等许多领域中有重要的应用。 用文档检索来举例，如下图： 排序学习的核心就是要学习到一个排序模型f(q,d) ， q 表示查询，d 表示文档，然后利用排序模型，在给定查询q的时候给出相关文档的排序。 传统排序，例如BM25: 基于条件概率分布，f(q,d)=p(r|q,d)f(q,d)=p(...
ACM算法模板集：史上最全面的编程指南
5. 图论算法：模板集涵盖了图论的核心算法，如最小生成树（Kruskal和Prim算法）、单源最短路径（Bellman-Ford和Dijkstra算法）、全源最短路径（Floyd算法）、拓扑排序、网络流问题（预流、最大流、最小费用最大流）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值