排序（前篇）

news2024/11/23 5:23:20

1.排序的概念及其运用

2.插入排序的概念及实现

3.希尔排序的概念及实现 

4.选择排序概念及实现

总代码（对比各个排序在大量的数据情况排序所化的时间）：

1.排序的概念及其运用

1.1排序的概念


排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次
序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不断地在内外存之间移动数据的排序。

1.2排序的运用

在网上购物时，会出现综合，销量及评论数等，会以此为参考来排序，选出综合最高，销量最高的产品，以及院校排名这些，都使用了排序。

（以下图片仅参考）

1.3 常见的排序算法

2.插入排序的概念及实现

2.1插入排序的概念

就像扑克牌一样，每拿到一张牌都要放进已经排好序的牌里面，用这张牌跟里面的比较，再把这张牌放到合适的位置，插入排序的原理就是把数插入已经排好序的数里面，比较排好数的里面的每一个数，找到位置就插入。

代码：

#include<stdio.h>
void InsertSort(int* a,int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end+1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end+1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}
int main()
{
	int a[10] = { 3,4,5,1,2,6,7,8,2 };
	int size = sizeof(a) / sizeof(a[0]);
	InsertSort(a,size);
	for (int i = 0; i < 9; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

代码分析： 

while循环出去有俩种情况，1是触发break，二是while循环的条件不满足，在循环外把tmp赋给数组下标为end+1的位置， 是因为如果是while循环结束的话刚好也可以赋值，但是在里面的话，因为while结束的就无法把数据加回去（移动带来覆盖，会有一位重复，需要赋值来填回去）。

（动态图关于插入排序24年-05月27日--排序/动图/插入排序.gif · 比特杭哥/113期 - Gitee.com）

2.2冒牌排序的时间复杂度

冒泡排序的最坏情况：

假设if条件每次都会执行，那么时间复杂度就为O(N^2).

最好的情况：

上面冒泡代码不能做到O(N),需要对其优化才能使冒泡排序达到最好情况，

设置一个flag去判断是否触发了if条件，如果触发了就置为0，后面再去检验值是否为一开始的初始值，是就说明没有触发if条件，没触发就说明顺序是排好的，只执行了里面的if判断，所以时间复杂度是O(N)。

void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n; i++)
	{
		int flag = 1;
		for (int j = 0; j < n-i-1; j++)
		{
			
			if (a[j] > a[j + 1])
			{
				int tmp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = tmp;
				flag = 0;
			}
			
		}
		if (flag == 1)
		{
			break;
		}
	}
}

2.3插入排序的时间复杂度

按照最坏打算：

既逆序情况

最好的情况：

当数据是以升序排序时，里面的循环不执行（会从break跳出），则只有for循环执行，所以时间复杂度就为O(N)。

插入排序与冒泡排序的时间复杂度虽然是一样的，但插入排序是比冒泡排序好，因为插入排序最坏的情况很难达到，只有是逆序（或者接近这个情况）的情况下，插入排序才会慢下来，而冒泡排序一般都是O(N^2),因为冒泡每次遍历选出其中最大的放最后，if的条件任意触发。

void BubbleSort(int* a, int n)//冒泡排序
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n-i-1; j++)
		{
			if (a[j] > a[j + 1])
			{
				int tmp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = tmp;
			}
		}
	}
}

3.希尔排序的概念及实现 

3.1希尔排序概念

希尔排序与插入排序密不可分，基于插入排序来实现希尔排序的。

希尔排序：首先会对数据进行预排序（让数组接近有序），再进行插入排序（因为插入排序怕的是数组是逆序情况）。

预排序：把数组在逻辑上分成gap组，gap是间隔的距离，然后对每个gap组进行插入排序，这样可以使大的数据跑到比较后面的位置，小的数据会跑到比较前面的位置，gap设置的越大，大的数据越快到后面，小的数据越快到前面，越不接近有序，gap设置的越小，数据跳的慢，但是会越接近有序的情况，gap为1的时候就是插入排序了，希尔排序就是慢慢把gap的值调小（设置gap是为了最后一次gap为一做铺垫，为了插入排序能更快的完成），最后gap为一时执行插入排序。

3.2希尔排序的代码实现

代码实现1：

void swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void ShellSort1(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > tmp)
				{
					swap(&a[end], &a[end + gap]);
					end--;
				}
				else
					break;

			}
			a[end + gap] = tmp;

		}
	}
}

代码实现二：

void ShellSort2(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		for (int j = 0; j < gap; j++)
		{
			for (int i = j; i < n - gap; i += gap)
			{
				int end = i;
				int tmp = a[end + gap];
				while (end >= 0)
				{
					if (a[end] > tmp)
					{
						swap(&a[end], &a[end + gap]);
						end -= gap;
					}
					else
						break;

				}
				a[end + gap] = tmp;

			}
		}
	}
}

代码分析：上面俩个代码的样子不一样，但是效率是一样的俩种都可以使用，

n是数组的个数，一般gap的值都为个数的三分之一+1，加一是为了最后gap的值能达到一进行插入排序，gap/2的效率不如gap/3（大量数据实验得出的），代码一是多个gap组同时进行预排序，每次i加一，但是比的是gap距离的数据，gap第一组的第一个跟其gap距离的比完后，第二个gap组的第一个跟其gap距离的比，再到第三个gap组的第一个与其gap距离的数据比较，再到第二个等等，代码二则是第一个gap组会一直比完才到第二个gap组比。还需要注意的是循环终止条件是n-gap，是因为循环里面有end+gap，n+gap-gap刚好是为n，也就是数组最后一个数据下标的下一个，有效数据的下一个是不能访问的，会造成越界访问，数组最多能访问到n-1的位置，如果是i<n，则a[end+gap]就会越界了。

3.3希尔排序的时间复杂度（简单分析）

希尔排序的时间复杂度为O(N^1.3)。

4.选择排序概念及实现

选择排序就是遍历数组找到最小的数据并把它放在最前面，可以对它进行优化，就是在遍历的同时把最大和最小的数据找出来并放在俩边

代码实现：

void SelectSort(int* a, int n)
{
	int begin, end;
	begin = 0;
	end = n - 1;
	while (begin < end)
	{
		int mini, max;
		mini = max = begin;
		for (int i = begin+1; i <= end; i++)
		{
			if (a[mini] > a[i])
			{
				mini = i;
			}
			if (a[max] < a[i])
			{
				max = i;
			}
		}
	
		swap(&a[mini], &a[begin]);
		swap(&a[max], &a[end]);
		end--;
		begin++;
	}	
}

代码分析：

因为是找最大和最小并放在俩边，所以begin和end会慢慢往中间靠近，在定义最小值和最大值去和数组的每一个数比较，比定义的最大值大就交换一下下标，比最小值小就交换 下标，遍历完后在交换值，并且把begin++和end--，因为begin和end都放好了对应的值，要放其它位置的值。

总代码（对比各个排序在大量的数据情况排序所化的时间）：

test.c文件：

#include"Sort.h"

void TestInsertSort()
{
	int a[] = { 2,4,1,7,8,3,9,2 };
	InsertSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

void TestShellSort()
{
	int a[] = { 9,1,2,5,7,4,6,3,5,9,1,2,5,7,4,6,3,5,9,1,2,5,7,4,6,3,5,9,1,2,5,7,4,6,3,5,9,1,2,5,7,4,6,3,5 };
	//InsertSort(a, sizeof(a) / sizeof(int));

	PrintArray(a, sizeof(a) / sizeof(int));

	ShellSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

void TestSelectSort()
{
	//int a[] = { 9,1,2,5,7,4,6,3,5,9,1,2,5,7,4,6,3,5,9,1,2,5,7,4,6,3,5,9,1,2,5,7,4,6,3,5,9,1,2,5,7,4,6,3,5 };
	//InsertSort(a, sizeof(a) / sizeof(int));
	//int a[] = { 2,4,1,7,8,3,9,2 };
	int a[] = { 9,1,2,5,7,4,6,3 };

	PrintArray(a, sizeof(a) / sizeof(int));
	SelectSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

void TestOP()
{
	srand(time(0));
	const int N = 1000000;
	int* a1 = (int*)malloc(sizeof(int) * N);
	int* a2 = (int*)malloc(sizeof(int) * N);
	int* a3 = (int*)malloc(sizeof(int) * N);
	int* a4 = (int*)malloc(sizeof(int) * N);
	int* a5 = (int*)malloc(sizeof(int) * N);
	int* a6 = (int*)malloc(sizeof(int) * N);
	int* a7 = (int*)malloc(sizeof(int) * N);

	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand()+i;
		a2[i] = a1[i];
		a3[i] = a1[i];
		a4[i] = a1[i];
		a5[i] = a1[i];
		a6[i] = a1[i];
		a7[i] = a1[i];
	}

	int begin1 = clock();
	//InsertSort(a1, N);
	int end1 = clock();

	int begin2 = clock();
	ShellSort(a2, N);
	int end2 = clock();

	int begin3 = clock();
	//SelectSort(a3, N);
	int end3 = clock();

	int begin4 = clock();
	HeapSort(a4, N);
	int end4 = clock();

	int begin5 = clock();
	//QuickSort(a5, 0, N - 1);
	int end5 = clock();

	int begin6 = clock();
	//MergeSort(a6, N);
	int end6 = clock();

	int begin7 = clock();
	//BubbleSort(a7, N);
	int end7 = clock();

	printf("InsertSort:%d\n", end1 - begin1);
	printf("ShellSort:%d\n", end2 - begin2);
	printf("SelectSort:%d\n", end3 - begin3);
	printf("HeapSort:%d\n", end4 - begin4);
	printf("QuickSort:%d\n", end5 - begin5);
	printf("MergeSort:%d\n", end6 - begin6);
	printf("BubbleSort:%d\n", end7 - begin7);

	free(a1);
	free(a2);
	free(a3);
	free(a4);
	free(a5);
	free(a6);
	free(a7);
}


int main()
{
	//TestInsertSort();
	//TestShellSort();
	TestSelectSort();

	//TestOP();

	return 0;
}

Sort.h文件：

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<time.h>

void PrintArray(int* a, int n);

// 有实践意义
void InsertSort(int* a, int n);

void ShellSort(int* a, int n);

void ShellSort(int* a, int n);

void HeapSort(int* a, int n);

// 适合教学，实践中没啥价值
void BubbleSort(int* a, int n);

void SelectSort(int* a, int n)

Sort.c文件：

#include"Sort.h"

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

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

// 时间复杂度：O(N^2)  什么情况最坏：逆序
// 最好：顺序有序，O(N)
// 插入排序
void InsertSort(int* a, int n)
{
	//  [0, n-1]
	for (int i = 0; i < n - 1; i++)
	{
		// [0, n-2]是最后一组
		// [0,end]有序 end+1位置的值插入[0,end]，保持有序
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				--end;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

// O(N^1.3)
//void ShellSort(int* a, int n)
//{
//	/*int gap = 3;
//	for (int j = 0; j < gap; j++)
//	{
//		for (size_t i = j; i < n - gap; i += gap)
//		{
//			int end = i;
//			int tmp = a[end + gap];
//			while (end >= 0)
//			{
//				if (tmp < a[end])
//				{
//					a[end + gap] = a[end];
//					end -= gap;
//				}
//				else
//				{
//					break;
//				}
//			}
//			a[end + gap] = tmp;
//		}
//	}*/
//
//	int gap = n;
//	while (gap > 1)
//	{
//		// +1保证最后一个gap一定是1
//		// gap > 1时是预排序
//		// gap == 1时是插入排序
//		gap = gap / 3 + 1;
//
//		for (size_t i = 0; i < n - gap; ++i)
//		{
//			int end = i;
//			int tmp = a[end + gap];
//			while (end >= 0)
//			{
//				if (tmp < a[end])
//				{
//					a[end + gap] = a[end];
//					end -= gap;
//				}
//				else
//				{
//					break;
//				}
//			}
//			a[end + gap] = tmp;
//		}
//		//printf("gap:%2d->", gap);
//		//PrintArray(a, n);
//	}
//}

// O(N ^ 1.3)
void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		// +1保证最后一个gap一定是1
		// gap > 1时是预排序
		// gap == 1时是插入排序
		gap = gap / 3 + 1;

		for (size_t i = 0; i < n - gap; ++i)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}


void AdjustDown(int* a, int n, int parent)
{
	// 先假设左孩子小
	int child = parent * 2 + 1;

	while (child < n)  // child >= n说明孩子不存在，调整到叶子了
	{
		// 找出小的那个孩子
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}

		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* a, int n)
{
	// 向下调整建堆 O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}

	// O(N*logN)
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

// O(N^2) 最坏
// O(N)   最好
void BubbleSort(int* a, int n)
{
	for (int j = 0; j < n; j++)
	{
		// 单趟
		int flag = 0;
		for (int i = 1; i < n - j; i++)
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				flag = 1;
			}
		}

		if (flag == 0)
		{
			break;
		}
	}
}

void SelectSort(int* a, int n)
{
	int begin = 0, end = n - 1;

	while (begin < end)
	{
		int mini = begin, maxi = begin;
		for (int i = begin + 1; i <= end; ++i)
		{
			if (a[i] > a[maxi])
			{
				maxi = i;
			}

			if (a[i] < a[mini])
			{
				mini = i;
			}
		}

		Swap(&a[begin], &a[mini]);
		Swap(&a[end], &a[maxi]);
		++begin;
		--end;
	}
}

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

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

相关文章

linux中逻辑卷管理与扩展

linux中逻辑卷管理与扩展

逻辑卷管理与扩展 逻辑卷 作用&#xff1a; 1.整合分散的空间2.空间支持扩大 逻辑卷制作过程&#xff1a;将众多的物理卷&#xff08;PV&#xff09;组建成卷组&#xff08;VG&#xff09;&#xff0c;再从卷组中划分出逻辑卷&#xff08;LV&#xff09; 逻辑卷的逻辑思路 …
阅读更多...
前端项目开发，3个HTTP请求工具

前端项目开发，3个HTTP请求工具

这一小节&#xff0c;我们介绍一下前端项目开发中&#xff0c;HTTP请求会用到的3个工具&#xff0c;分别是fetch、axios和js-tool-big-box中的jsonp请求。那么他们都有哪些小区别呢&#xff1f;我们一起来看一下。 目录 1 fetch 2 axios 3 js-tool-big-box 的 jsonp 请求 …
阅读更多...
一个月速刷leetcodeHOT100 day13 二叉树结构 以及相关简单题

一个月速刷leetcodeHOT100 day13 二叉树结构 以及相关简单题

树是一种分层数据的抽象模型 二叉树 二叉树中的节点最多只能有两个子节点&#xff0c;一个是左侧子节点&#xff0c;另一个是右侧子节点 二叉搜索树 二叉搜索树&#xff08;BST&#xff09;是二叉树的一种&#xff0c;但是只允许你在左侧节点存储&#xff08;比父节点&…
阅读更多...
扎气球最高分-第13届蓝桥杯选拔赛Python真题精选

扎气球最高分-第13届蓝桥杯选拔赛Python真题精选

[导读]&#xff1a;超平老师的Scratch蓝桥杯真题解读系列在推出之后&#xff0c;受到了广大老师和家长的好评&#xff0c;非常感谢各位的认可和厚爱。作为回馈&#xff0c;超平老师计划推出《Python蓝桥杯真题解析100讲》&#xff0c;这是解读系列的第74讲。 扎气球最高分&…
阅读更多...
IntelliJ IDEA内置自带Maven的使用注意事项

IntelliJ IDEA内置自带Maven的使用注意事项

一、内置自带Maven的位置 IDEA中是有自带Maven的，虽然可能不够个性化，不太好用，但是如果知道怎么设置，还是能自定义一点的。它作为IDEA的自带插件，位置在IDEA所在目录的“\plugins\plugins\maven\lib\maven3\”文件夹中。 二、本地仓库位置 因为Maven主要功能就是统一下…
阅读更多...
MoE模型大火，源2.0-M32诠释“三个臭皮匠，顶个诸葛亮”！

MoE模型大火，源2.0-M32诠释“三个臭皮匠，顶个诸葛亮”！

文 | 智能相对论 作者 | 陈泊丞 近半年来&#xff0c;MoE混合专家大模型彻底是火了。 在海外&#xff0c;OpenAI的GPT-4、谷歌的Gemini、Mistral AI的Mistral、xAI的Grok-1等主流大模型都采用了MoE架构。而在国内&#xff0c;浪潮信息也刚刚发布了基于MoE架构的“源2.0-M3…
阅读更多...
无人机操作界面来了，起点就很高呀。

无人机操作界面来了，起点就很高呀。

无人机操作界面设计需要考虑以下几个方面&#xff1a; 易用性&#xff1a;无人机操作界面应该简单直观&#xff0c;易于操作和理解。操作按钮和控键应该布局合理&#xff0c;易于触摸或点击。重要的操作功能应该易于找到和使用&#xff0c;避免用户迷失或困惑。实时反馈&#…
阅读更多...
【Uniapp微信小程序】自定义水印相机、微信小程序地点打卡相机

【Uniapp微信小程序】自定义水印相机、微信小程序地点打卡相机

效果图 template 下方的image图片自行寻找替换！ <template><view><camerav-if="!tempImagePath && cameraHeight !== 0":resolution="high":frame-size="large":device-position="device":flash="flas…
阅读更多...
RAID配置实战

RAID配置实战

概念 raid磁盘阵列&#xff1a;可以用不同的硬盘分区&#xff0c;组成一个逻辑上的硬盘。具有高可用 raid级别&#xff1a; raid0 &#xff1a;条带化存储&#xff1a;数据分散在多个物理硬盘上的存储方式。利用多个磁盘并行读取和写入。存储性能和读写性能是最好的。没有冗…
阅读更多...
朗读亭主要作用有哪些？

朗读亭主要作用有哪些？

朗读亭的主要作用有以下几个方面&#xff1a; 1. 提供朗读服务&#xff1a;朗读亭是一个专门的场所&#xff0c;提供给人们朗读的环境和场地。人们可以在朗读亭中选择自己喜欢的书籍或文章&#xff0c;并通过朗读将其表达出来。这样可以帮助人们提高朗读能力&#xff0c;增强自…
阅读更多...
【C语言训练题库】杨辉三角(下三角型和金字塔型)

【C语言训练题库】杨辉三角(下三角型和金字塔型)

&#x1f525;博客主页&#x1f525;&#xff1a;【 坊钰_CSDN博客 】 欢迎各位点赞&#x1f44d;评论✍收藏⭐ 目录 题目&#xff1a;打印杨辉三角 1. 下三角型 1.1 图例: 1.2. 解析: 1.3. 代码: 1.4. 运行&#xff1a; 2. 金字塔型 2.1 图例 2.2. 解析 2.2.1. 打印金…
阅读更多...
[猫头虎分享21天微信小程序基础入门教程]第21天：小程序的社交分享与消息推送

[猫头虎分享21天微信小程序基础入门教程]第21天：小程序的社交分享与消息推送

[猫头虎分享21天微信小程序基础入门教程]第21天&#xff1a;小程序的社交分享与消息推送 第21天&#xff1a;小程序的社交分享与消息推送 &#x1f4f2; 自我介绍 大家好&#xff0c;我是猫头虎&#xff0c;一名全栈软件工程师。今天我们继续微信小程序的学习&#xff0c;重…
阅读更多...
买入看跌期权怎么理解？

买入看跌期权怎么理解？

今天带你了解买入看跌期权怎么理解&#xff1f;看跌期权买入者往往预期市场价格将下跌。 买入看跌期权怎么理解&#xff1f; 买入看跌期权是指购买者支付权利金&#xff0c;获得以特定价格向期权出售者卖出一定数量的某种特定商品的权利。看跌期权买入者往往预期市场价格将下跌…
阅读更多...
基于python实现生命游戏

基于python实现生命游戏

文章目录 一、生命游戏是什么二、生命游戏规则解释1.相邻细胞2.细胞状态 三、代码实现1.邻居细胞2.更新状态 四、整体代码 一、生命游戏是什么 生命游戏&#xff08;Game of Life&#xff09;是由英国数学家约翰何顿康威在1970年发明的一种细胞自动机&#xff08;Cellular Aut…
阅读更多...
备份服务器的安全风险以及如何通过TDE透明加密提升安全性

备份服务器的安全风险以及如何通过TDE透明加密提升安全性

备份服务器的潜在安全风险主要包括以下几个方面&#xff1a; 1. 数据泄露风险&#xff1a; 备份数据可能包含敏感信息&#xff0c;如用户个人信息、商业机密等。如果备份数据未经适当保护&#xff0c;例如存储在不安全的位置或未加密&#xff0c;黑客或未授权的人员可能会获取…
阅读更多...
家政预约小程序08服务详情

家政预约小程序08服务详情

目录 1 创建页面2 创建URL参数3 配置数据详情组件4 从分类页跳转到详情页5 搭建详情页总结 现在我们的小程序已经在首页和分类页展示了服务的列表信息&#xff0c;当用户点击具体的内容的时候需要打开详情页&#xff0c;本篇介绍一下详情页的开发。 1 创建页面 打开应用编辑器…
阅读更多...
【第7章】SpringBoot整合Mybatis-Plus

【第7章】SpringBoot整合Mybatis-Plus

文章目录 前言一、引入库二、案例1.UserMapper2.UserController3. 结果 三、配置总结 前言 MyBatis-Plus 是一个 MyBatis 的增强工具&#xff0c;在 MyBatis 的基础上只做增强不做改变&#xff0c;为简化开发、提高效率而生。 上一篇内容已经整合过Mybatis&#xff0c;这里在…
阅读更多...
拼接字符串

拼接字符串

自学python如何成为大佬(目录):https://blog.csdn.net/weixin_67859959/article/details/139049996?spm1001.2014.3001.5501 使用“”运算符可完成对多个字符串的拼接&#xff0c;“”运算符可以连接多个字符串并产生一个字符串对象。 例如&#xff0c;定义两个字符串&#…
阅读更多...
05-28 周二 TTFT， ITL， TGS 计算过程以及LLama2推理代码调试过程

05-28 周二 TTFT， ITL， TGS 计算过程以及LLama2推理代码调试过程

05-28 周二 LLama2推理代码调试过程 时间版本修改人描述2024年5月28日15:03:49V0.1宋全恒新建文档 简介 本文主要用于求解大模型推理过程中的几个指标&#xff1a; 主要是TTFT&#xff0c;ITL&#xff0c; TGS 代码片段 import osdata_dir "/workspace/models/" m…
阅读更多...
【2024最新华为OD-C卷试题汇总】披萨大作战 (100分) - 支持在线评测+三语言AC题解(Python/Java/Cpp)

【2024最新华为OD-C卷试题汇总】披萨大作战 (100分) - 支持在线评测+三语言AC题解(Python/Java/Cpp)

&#x1f36d; 大家好这里是清隆学长 &#xff0c;一枚热爱算法的程序员 ✨ 本系列打算持续跟新华为OD-C卷的三语言AC题解 &#x1f4bb; ACM银牌&#x1f948;| 多次AK大厂笔试 &#xff5c; 编程一对一辅导 &#x1f44f; 感谢大家的订阅➕ 和 喜欢&#x1f497; 文章目录 前…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023