[数据结构笔记]常见排序算法

news2024/11/28 16:44:27

分类与性能

在这里插入图片描述

排序方法平均情况最好情况最坏情况辅助空间稳定性
冒泡排序O(N^2)O(N)O(N^2)O(1)稳定
简单选择排序O(N^2)O(N^2)O(N^2)O(1)不稳定
直接插入排序O(N^2)O(N)O(N^2)O(1)稳定
希尔排序O(N*logN) ~ O(N^2)O(N^1.3)O(N^2)O(1)不稳定
堆排序O(N*logN)O(N*logN)O(N*logN)O(1)不稳定
归并排序O(N*logN)O(N*logN)O(N*logN)O(N)稳定
快速排序O(N*logN)O(N*logN)O(N^2)O(logN) ~ O(N)不稳定

代码实现

栈实现

Stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int STDatatype;

typedef struct Stack {
	STDatatype* arr;
	int capacity;
	int top;//栈顶元素的下一位的下标
}ST;

void StackInit(ST* ps);//初始化
void StackDestroy(ST* ps);//销毁
void StackPush(ST* ps,STDatatype x);//入栈
void StackPop(ST* ps);//出栈

bool StackEmpty(ST* ps);//检测空
int StackSize(ST* ps);//返回元素数量
STDatatype StackTop(ST* ps);//取栈顶元素

Stack.c

#include"Stack.h"

void StackInit(ST* ps) {
	assert(ps);
	ps->arr = (STDatatype*)malloc(sizeof(STDatatype) * 4);
	if (ps->arr == NULL) {
		perror("malloc failed");
		exit(-1);
	}
	ps->top = 0;//栈顶元素的下一位的下标
	ps->capacity = 4;
}

void StackDestroy(ST* ps) {
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
	ps->top = ps->capacity = 0;
}

void StackPush(ST* ps, STDatatype x) {
	assert(ps);
	if (ps->top == ps->capacity) {
		STDatatype* tmp = (STDatatype*)realloc(ps->arr, sizeof(STDatatype) * ps->capacity * 2);
		if (tmp == NULL) {
			perror("realloc failed");
			exit(-1);
		}
		ps->arr = tmp;
		ps->capacity *= 2;
	}
	ps->arr[ps->top] = x;
	ps->top++;
}

bool StackEmpty(ST* ps) {
	assert(ps);
	return ps->top == 0;//判断的结果本身就是布尔值
}

void StackPop(ST* ps) {
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
	//tip:动态开辟的一段空间不能只free一部分

}

STDatatype StackTop(ST* ps) {
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->arr[ps->top - 1];//top是栈顶后一位的下标,要-1才是栈顶的下标
}

int StackSize(ST* ps) {
	assert(ps);
	return ps->top;//top的值即为元素数量
}

排序算法实现

Sort.h

#pragma once
#include<stdio.h>

void PrintArray(int* a, int n);

void InsertSort(int* a, int n);
void ShellSort(int* a, int n);
void SelectSort(int* a, int n);
void HeapSort(int* a, int n);
void BubbleSort(int* a, int n);
void QuickSort(int* a, int begin, int end);
int PartSort1(int* a, int begin, int end);
int PartSort2(int* a, int begin, int end);
int PartSort3(int* a, int begin, int end);
void QuickSortNonR(int* a, int begin, int end);
void MergeSort(int* a, int n);
void MergeSortNonR(int* a, int n);

Sort.c

#include"Sort.h"
#include"Stack.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;
}

//向下调整-堆排附属
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n) {
		// 确认child指向大的那个孩子
		if (child + 1 < n && a[child + 1] > a[child]) {
			++child;
		}

		// 1、孩子大于父亲，交换，继续向下调整
		// 2、孩子小于父亲，则调整结束
		if (a[child] > a[parent]) {
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else {
			break;
		}
	}
}

//三数取中，用于快排选key的优化
int GetMidIndex(int* a, int begin, int end) {
	int mid = (begin + end) / 2;
	if (a[begin] < a[mid]) {
		if (a[mid] < a[end]) {
			return mid;
		}
		else if (a[begin] > a[end]) {
			return begin;
		}
		else {
			return end;
		}
	}
	else {//a[begin]>a[mid]
		if (a[mid] > a[end]) {
			return mid;
		}
		else if (a[begin] < a[end]) {
			return begin;
		}
		else {
			return end;
		}
	}
}

//插入排序
void InsertSort(int* a, int n) {
//向前插入排序：先令前n-1个元素有序，再将第n个向前比较然后插入
//最坏O(N^2)，逆序等差数列
//最好O(N)，接近顺序有序
	for (int i = 0; i < n-1; i++) {//下标从0开始，所以结束条件不能是n
		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;
	}
}

//希尔排序
void ShellSort(int* a, int n) {
//希尔排序(最小增量排序)：改良的插入排序，在插排之前先进行预排序(以gap为步长分成gap组，再组内排序(普通插入排序看作gap=1))
//每组最坏情况挪动次数：(1+2+...+n/gap-1)*gap 。实际排序中只在最开始时可能有最差情况，后续每组越来越接近有序
//最好O(N)
	int gap = n;
	while (gap > 1){//gap>1则预排序，gap==1则直接插入排序
		gap = gap / 3 + 1;//自适应gap，n越大gap越大。除3必须+1以保证gap最少为1。
		for (int i = 0; i < n - gap; i++) {//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;
		}
		PrintArray(a, n);
	}
}

//直接选择排序
void SelectSort(int* a, int n) {
//O(N^2)
//相比之下直接插入更好，因其对于有序或局部有序的情况效率更高。
//而直接选择排序任何情况下都是O(N^2)，所以直接选择排序是最差的排序方式。
	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[mini]) {
				mini = i;
			}
			if (a[i] > a[maxi]) {
				maxi = i;
			}
		}
		//将最小的元素换到begin处，最大的换到end处
		Swap(&a[begin], &a[mini]);
		//若交换前最大元素为首元素，则第一次交换会将最大元素交换到最小元素原本的位置去
		//，而此时maxi依旧“指向”begin位置。
		//于是在交换最大元素前，maxi实质上“指向”的会是刚交换过来的最小元素。需要对此情况单独处理。
		//(若是先交换max再交换min，则需考虑最小元素在end位置的情况)
		if (maxi == begin) {
			maxi = mini;//将maxi“指向”刚被交换过去的，身为最大元素的原首元素，以完成修正。
		}
		Swap(&a[end], &a[maxi]);
		begin++;
		end--;
	}
}

//堆排序(基于二叉树的一种选择排序)
void HeapSort(int* a, int n){	
// O(N*logN)
// 向下调整建堆 -- O(N)
// 升序：建大堆
	for (int i = (n - 1 - 1) / 2; i >= 0; --i){
		AdjustDown(a, n, i);
	}
	int end = n - 1;
	while (end > 0){
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

//冒泡排序(一种交换排序)
void BubbleSort(int* a, int n) {
//O(N^2)
	for (int j = 0; j < n; j++) {
		int exchange = 0;
		for (int i = 1; i < n - j; i++) {
			if (a[i - 1] > a[i]) {
				Swap(&a[i - 1], &a[i]);
				exchange = 1;
			}
			if (exchange == 0) {//若一趟冒泡过程中未发生交换，则该部分已为有序，可以跳过
				break;
			}
		}
	}
}

//从Hoare的原版快排拆出的单趟排序
int PartSort1(int* a, int begin, int end) {
	//优化最值位于两端之一时key的选择，使得快排几乎不会出现最坏情况，在原版基础上进行此优化后近似为O(N*logN)
	int mid = GetMidIndex(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int left = begin, right = end;
	int keyi = left;
	while (left < right) {
		//右先走，找小的
		while (left < right && a[right] >= a[keyi]) {//left<right&&防止越界，>=而不是>以防止死循环
			right--;
		}
		//左先走，找大的
		while (left < right && a[left] <= a[keyi]) {//left<right&&防止越界，<=而不是<以防止死循环
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[keyi]);
	keyi = left;
	return keyi;
}

//快排-挖坑法:左边挖坑右边填，最初的坑内数据由临时变量key保存，然后右边挖坑左边填，直到二者于同一坑相遇，key内数据填入坑中
int PartSort2(int* a, int begin, int end) {
	int mid = GetMidIndex(a, begin, end);
	Swap(&a[begin], &a[mid]);
	int left = begin, right = end;
	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;//左边挖新坑
	}
	a[hole] = key;//左右相遇后，key内数据填入最后的坑中
	return hole;//返回hole就是返回本趟排序的key3
}

//快排-前后指针法
int PartSort3(int* a, int begin, int end){
	int mid = GetMidIndex(a, begin, end);
	Swap(&a[begin], &a[mid]);
	int keyi = begin;
	int prev = begin, cur = begin + 1;
	while (cur <= end){//<=而不是<,防越界
	//cur找到比key小的值时停下，++prev，然后交换prev与cur位置的值。
	//由此可确保prev与cur之间的值比key大，而prev与cur构成的区间本身在向后移动，如此便使得比key大的值集中在后部
		if (a[cur] < a[keyi] && ++prev != cur)//++prev != cur 跳过无意义的自我交换
			Swap(&a[prev], &a[cur]);
		cur++;
	}
	Swap(&a[prev], &a[keyi]);//交换prev与key，以使得key大于前方元素而小于等于后方元素
	keyi = prev;
	return keyi;
}

//快速排序及其优化(基于二叉树的一种交换排序)
void QuickSort(int* a, int begin, int end) {
//原版快排单趟O(N)
	if (begin >= end) {
		return;//待排序元素只剩一个的情况为递归终止条件
	}
	//小区间优化，对于少于15个元素(未规定具体数值)的区间不再递归处理，而是直接使用插入排序
	if ((end - begin + 1) < 15) {
		InsertSort(a + begin, end - begin + 1);
	}
	else {
		int keyi = PartSort3(a, begin, end);//这里将单趟排序拆分并单独作一个函数，便于比较各种单趟实现方式
		//单趟排序结束，已分成三个区间: [begin,keyi-1] keyi [keyi+1,end] 
		//然后开始对每个区间递归地进行排序
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

//快排-非递归。递归层数多了总归是容易爆栈的，非递归实现比较稳妥。
//简单的递归改非递归通常使用循环代替，而复杂的经常使用栈来辅助实现
void QuickSortNonR(int* a, int begin, int end){
//用栈保存区间，动态开辟的空间位于内存的堆区，远比函数递归调用时用的栈区的空间大
	ST st;
	StackInit(&st);
	StackPush(&st, begin);
	StackPush(&st, end);
	while (!StackEmpty(&st)){
		int right = StackTop(&st);
		StackPop(&st);
		int left = StackTop(&st);
		StackPop(&st);
		int keyi = PartSort3(a, left, right);
		//[left, keyi-1] keyi [keyi+1, right]
		if (keyi + 1 < right){
			StackPush(&st, keyi + 1);
			StackPush(&st, right);
		}
		if (left < keyi - 1){
			StackPush(&st, left);
			StackPush(&st, keyi - 1);
		}
	}
	StackDestroy(&st);
}

//归并排序递归用的子函数
void _MergeSort(int* a, int begin, int end, int* tmp){
//时间复杂度：O(N*logN)
//空间复杂度：O(N)
	if (begin >= end)
		return;
	int mid = (begin + end) / 2;
	// [begin, mid] [mid+1, end] 递归让子区间有序
	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid + 1, end, tmp);
	// 归并[begin, mid] [mid+1, end]
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int i = begin;
	while (begin1 <= end1 && begin2 <= end2){
		if (a[begin1] <= a[begin2]){
			tmp[i++] = a[begin1++];
		}
		else{
			tmp[i++] = a[begin2++];
		}
	}
	while (begin1 <= end1){
		tmp[i++] = a[begin1++];
	}
	while (begin2 <= end2){
		tmp[i++] = a[begin2++];
	}
	memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}

//归并排序-递归实现
void MergeSort(int* a, int n) {

	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL) {
		perror("malloc failed");
		exit(-1);
	}
	_MergeSort(a, 0, n - 1, tmp);
	free(tmp);
	tmp = NULL;
}

//归并排序-非递归实现
void MergeSortNonR(int* a, int n){
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL){
		perror("malloc failed\n");
		exit(-1);
	}
	//归并的每组数据个数。从1开始是因为单1个元素视作有序，可直接归并
	int rangeN = 1;
	while (rangeN < n){
		for (int i = 0; i < n; i += 2 * rangeN){
			//[begin1,end1][begin2,end2] 归并
			int begin1 = i, end1 = i + rangeN - 1;
			int begin2 = i + rangeN, end2 = i + 2 * rangeN - 1;
			int j = i;
			// 修正区间  ->拷贝数据 归并完了整体拷贝 or 归并每组拷贝
			if (end1 >= n){
				end1 = n - 1;
				//不存在区间
				begin2 = n;
				end2 = n - 1;
			}
			else if (begin2 >= n){
				// 不存在区间
				begin2 = n;
				end2 = n - 1;
			}
			else if (end2 >= n){
				end2 = n - 1;
			}
			while (begin1 <= end1 && begin2 <= end2){
				if (a[begin1] <= a[begin2]){
					tmp[j++] = a[begin1++];
				}
				else{
					tmp[j++] = a[begin2++];
				}
			}
			while (begin1 <= end1){
				tmp[j++] = a[begin1++];
			}
			while (begin2 <= end2){
				tmp[j++] = a[begin2++];
			}
		}
		//也可整体归并完再拷贝
		memcpy(a, tmp, sizeof(int) * (n));
		rangeN *= 2;
	}
	free(tmp);
	tmp = NULL;
}

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

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

相关文章

英文视频字幕生成和翻译工具、AI拟声工具

英文视频字幕生成和翻译工具、AI拟声工具

文章目录一、Autosub-ahk&#xff1a;英文视频字幕生成工具二、VideoSrt&#xff1a;英文视频字幕生成和翻译工具三、SubtitleEdit&#xff1a;字幕编辑工具四、PotPlayer&#xff1a;视频播放器&#xff08;可导入字幕&#xff09;五、MockingBird&#xff1a;AI拟声工具一、A…
阅读更多...
软件架构知识3-系统复杂度-高可用性、可扩展性、低成本、安全、规模

软件架构知识3-系统复杂度-高可用性、可扩展性、低成本、安全、规模

高可用性 系统无中断地执行其功能的能力&#xff0c;代表系统的可用性程度&#xff0c;是进行系统设计时的准则之一。 高可用的“冗余”解决方案&#xff0c;单纯从形式上来看&#xff0c;和之前讲的高性能是一样的&#xff0c;都是通过增加更多机 器来达到目的&#xff0c;但…
阅读更多...
MyBatis案例 | 使用映射配置文件实现CRUD操作——删除数据

MyBatis案例 | 使用映射配置文件实现CRUD操作——删除数据

本专栏主要是记录学习完JavaSE后学习JavaWeb部分的一些知识点总结以及遇到的一些问题等&#xff0c;如果刚开始学习Java的小伙伴可以点击下方连接查看专栏 本专栏地址&#xff1a;&#x1f525;JavaWeb Java入门篇&#xff1a; &#x1f525;Java基础学习篇 Java进阶学习篇&…
阅读更多...
Linux--网络基础(1)--0211 12

Linux--网络基础(1)--0211 12

1.网络传输基本流程 1.1 同一个网段内的两台主机进行文件传输 局域网中的两态主机是可以直接通信的。&#xff08;手机和电视链接同一个wifi就可以投屏&#xff09; 从逻辑上讲&#xff0c;应用层的数据可以直接给另一个人的应用层。 从物理上讲&#xff0c;应用的数据需要自…
阅读更多...
分库分表索引设计：分布式环境下的 主键索引、二级索引、全局索引的最佳设计实践

分库分表索引设计：分布式环境下的 主键索引、二级索引、全局索引的最佳设计实践

文章目录主键选择索引设计全局表唯一索引总结结语主键选择 对主键来说&#xff0c;要保证在所有分片中都唯一&#xff0c;它本质上就是一个全局唯一的索引。如果用大部分同学喜欢的自增作为主键&#xff0c;就会发现存在很大的问题。 因为自增并不能在插入前就获得值&#xf…
阅读更多...
TDengine 3.0.2.5 查询再优化！揭秘索引文件的工作原理

TDengine 3.0.2.5 查询再优化！揭秘索引文件的工作原理

TDengine 3.0 虽然对底层做了大规模的优化重构&#xff0c;但是相对于数据文件的工作逻辑和 2.0 相比是整体保持不变的。本系列文章的主旨在于帮助用户深入理解产品&#xff0c;并且拥有基本的性能调试思路&#xff0c;从而获得更好的产品体验。本期文章会在讲解 TDengine 时序…
阅读更多...
今天是情人节呐，我利用Python制作了好多表白的东西，快来吧~

今天是情人节呐，我利用Python制作了好多表白的东西，快来吧~

今天是情人节那&#xff0c;有没有现在没有对象的宝子&#xff0c;评论里扣个111哈哈 目录 玫瑰 爱心树 丘比特 多彩气球 阿玥的小课堂 一、情人节的由来 二、情人节的来历和意义 玫瑰 局部代码实现如下&#xff1a; # 花瓣1 turtle.left(150) turtle.circle(-90, 70) …
阅读更多...
【STM32笔记】低功耗模式下的RTC唤醒（非闹钟唤醒，而是采用RTC_WAKEUPTIMER）

【STM32笔记】低功耗模式下的RTC唤醒（非闹钟唤醒，而是采用RTC_WAKEUPTIMER）

【STM32笔记】低功耗模式下的RTC唤醒&#xff08;非闹钟唤醒&#xff0c;而是采用RTC_WAKEUPTIMER&#xff09; 前文&#xff1a; blog.csdn.net/weixin_53403301/article/details/128216064 【STM32笔记】HAL库低功耗模式配置&#xff08;ADC唤醒无法使用、低功耗模式无法烧录…
阅读更多...
C语言思维导图大总结 可用于期末考试 C语言期末考试题库

C语言思维导图大总结 可用于期末考试 C语言期末考试题库

目录 一.C语言思维导图 二.C语言期末考试题库 一.C语言思维导图 导出的图可能有点糊&#xff0c;或者查看链接&#xff1a;https://share.weiyun.com/uhf1y2mp 其实原图是彩色的不知道为什么导出时颜色就没了 部分原图&#xff1a; 也可私信我要全图哦。 图里的链接可能点不…
阅读更多...
软件测试工程师，月薪8000是一个什么样的工作状态？

软件测试工程师，月薪8000是一个什么样的工作状态？

这个工资得看是在什么地方&#xff0c;如果是在北上深&#xff0c;在互联网圈子里面&#xff0c;这个工资偏低&#xff0c;而且8000的话要解决生活各种开销&#xff0c;基本最后都是所剩无几。但是如果是在生存压力没有那么大的城市&#xff0c;8000基本算是很不错的一个薪资待…
阅读更多...
IP多播技术详解

IP多播技术详解

文章目录前言IP多播技术的相关基本概念IP多播地址和多播组在局域网上进行硬件多播IP多播地址和多播MAC地址映射关系在因特网上进行IP多播网际组管理协议IGMP多播路由选择协议前言 随着计算机网络的发展和个人计算机的普及&#xff0c;人们能够方便的在网络上畅游&#xff0c;进…
阅读更多...
【大数据】YARN节点标签Node Label特性

【大数据】YARN节点标签Node Label特性

简介 YARN 的 Node-label 特性能够将不同的机器类型进行分组调度&#xff0c;也可以根据不同的资源要求进行分区调度。运维人员可以根据节点的特性将其分为不同的分区来满足业务多维度的使用需求。YARN的Node-label功能将很好的试用于异构集群中&#xff0c;可以更好地管理和调…
阅读更多...
使用 RGB 值设置颜色

使用 RGB 值设置颜色

使用 RGB 值设置颜色 另一种可以在 CSS 中表示颜色的方法是使用 RGB 值。 RGB 即红色、绿色、蓝色&#xff08;英语&#xff1a;Red, Green, Blue&#xff09;。 ● 红色&#xff08;R&#xff09;0 到 255 间的整数&#xff0c;代表颜色中的红色成分。。 ● 绿色&#xff08;G…
阅读更多...
【数据结构】基础：图的最小生成树（附C++源代码）

【数据结构】基础：图的最小生成树（附C++源代码）

【数据结构】基础&#xff1a;图的最小生成树&#xff08;附C源代码&#xff09; 摘要&#xff1a;将会在数据结构专题中开展关于图论的内容介绍&#xff0c;其中包括四部分&#xff0c;分别为图的概念与实现、图的遍历、图的最小生成树以及图的最短路径问题。本文主要介绍Krus…
阅读更多...
机器学习经典算法总结

机器学习经典算法总结

一&#xff0c;KNN 算法 K 近邻算法&#xff08;KNN&#xff09;是一种基本分类和回归方法。KNN 算法的核心思想是如果一个样本在特征空间中的 k 个最相邻的样本中的大多数属于一个类别&#xff0c;那该样本也属于这个类别&#xff0c;并具有这个类别上样本的特性。该方法在确…
阅读更多...
知识图谱表示

知识图谱表示

知识图谱表示 用某种语言对知识图谱进行建模&#xff0c;从而方便知识运算。 符号知识表示 &#xff1a;以符号逻辑为基础的知识表示方法。 特点&#xff1a;易于刻画显示、离散的知识。具有内生的可解释性。 不足&#xff1a;部分隐性知识不易符号化表示&#xff0c;故知识表…
阅读更多...
Pr LOGO片头动画

Pr LOGO片头动画

哈喽&#xff0c;各位小伙伴&#xff01;今天我们来学习一下如何制作简约文字LOGO片头动画&#xff1f; 新建序列 新建一个1920*1080的序列&#xff0c;在字幕上打上我们的文字&#xff08;例&#xff1a;Ultraman&#xff09; 调出基本面板&#xff0c;调整文字的位置&…
阅读更多...
全栈项目【尚医通】预约挂号系统项目介绍

全栈项目【尚医通】预约挂号系统项目介绍

&#x1f43c;个人主页&#xff1a;爪哇斗罗 &#x1f43c;博主介绍&#xff1a;一名打工人 &#x1f43c;签名&#xff1a;圣人之道&#xff0c;为而不争。 &#x1f43c;一起交流&#xff0c;一起进步&#xff0c;一起互动。 ​ 目录 一.项目介绍 二.技术架构 2.1 架构选…
阅读更多...
SpringBoot集成Swagger3（powernode document）（内含源代码）

SpringBoot集成Swagger3（powernode document）（内含源代码）

SpringBoot集成Swagger3&#xff08;powernode document&#xff09;&#xff08;内含源代码&#xff09; 源代码下载链接地址&#xff1a;https://download.csdn.net/download/weixin_46411355/87449720 目录SpringBoot集成Swagger3&#xff08;powernode document&#xff0…
阅读更多...
数据库锁的12连问，你顶得了嘛？

数据库锁的12连问，你顶得了嘛？

前言 金三银四很快就要来啦&#xff0c;准备了数据库锁的12连问&#xff0c;相信大家看完肯定会有帮助的。 1. 为什么需要加锁 在日常生活中&#xff0c;如果你心情不好想静静&#xff0c;不想被比别人打扰&#xff0c;你就可以把自己关进房间里&#xff0c;并且反锁。这就是…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023