【八大排序】冒泡排序 | 快速排序 + 图文详解！！

在这里插入图片描述

📷 江池俊： 个人主页
🔥个人专栏： ✅数据结构冒险记 ✅C语言进阶之路
🌅 有航道的人，再渺小也不会迷途。

在这里插入图片描述

文章目录

    • 交换排序
    • 一、冒泡排序
      • 1.1 算法步骤 + 动图演示
      • 1.2 冒泡排序的效率分析
      • 1.3 代码实现
      • 1.4 冒泡排序特性总结
    • 二、快速排序
      • ✨为什么要三数取中？
      • ✨为什么要进行小区间优化？
      • 2.1 hoare版本 + 动图演示
      • 2.2 挖坑法 + 动图演示
      • 2.3 前后指针法 + 动图演示
      • 2.4 快排的`非递归`
      • 2.5 快速排序特性总结

在这里插入图片描述

交换排序

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置。
交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

一、冒泡排序

冒泡排序（Bubble Sort）是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢 “浮” 到数列的顶端。

冒泡排序有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。

1.1 算法步骤 + 动图演示

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
  3. 针对所有的元素重复以上的步骤，除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

在这里插入图片描述

1.2 冒泡排序的效率分析

  1. 什么时候最快？
    当输入的数据已经是正序时（都已经是正序了，我还要你冒泡排序有何用啊）。

  2. 什么时候最慢？
    当输入的数据是反序时（写一个 for 循环反序输出数据不就行了，干嘛要用你冒泡排序呢，我是闲的吗）。

1.3 代码实现

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

// 冒泡排序
// 时间复杂度：O(N^2)
// 最好情况是多少：O(N)
void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		bool exchange = false;
		for (int j = 1; j < n - i; j++)
		{
			if (a[j - 1] > a[j])
			{
				Swap(&a[j - 1], &a[j]);
				exchange = true;
			}
		}
		if (exchange == false)
			break;
	}
}

1.4 冒泡排序特性总结

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

二、快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

建议：此处优化内容可以在学完一两个快排思路后再进行观看。
快速排序优化：

  1. 三数取中法选key（即尽可能将不大不小的数作为基准数）
  2. 递归到小的子区间时，可以考虑使用插入排序（小区间优化）

✨为什么要三数取中？

  1. 减少最坏情况发生的概率：在快速排序中，如果每次选择的基准值都是当前序列中的最大或最小元素，那么将导致最坏情况的发生，即每次划分只能将原序列分为两个子序列，一个为空，另一个几乎包含所有剩余元素。这种情况下，快速排序的时间复杂度会退化到O(n^2)。通过三数取中，可以减少选择到极端值作为基准值的可能性，从而提高算法的平均性能。
  2. 提高算法的稳定性：三数取中的方法通常涉及选取序列的左端、中间和右端三个元素，然后从中选择一个值作为基准值。这样的方法能够更好地反映整个序列的中位数，从而使得划分更加均衡。
  3. 适应不同的数据分布：不同的数据分布对基准值的选择有不同的影响。三数取中的方法能够在一定程度上适应不同的数据分布，提高算法的普适性和鲁棒性。

总的来说，三数取中是快速排序中的一种优化策略，旨在通过选择一个更好的基准值来提高排序效率，减少最坏情况的发生概率，并使算法更加稳定和鲁棒。

【三数取中代码实现】：

算法步骤：

  1. 首先，计算数组的中间位置midi。
  2. 判断中间值与首尾值的关系，根据不同的关系来决定返回哪个值作为基准值。
  3. 如果首值大于中间值，则：
    • 如果中间值大于尾值，返回中间值。
    • 否则，如果首值大于尾值，返回尾值。
    • 否则，返回首值。
  4. 如果首值小于等于中间值（即a[begin] <= a[midi]），则：
    • 如果中间值小于尾值，返回中间值。
    • 否则，如果首值小于尾值，返回尾值。
    • 否则，返回首值。
// 三数取中
int GetMidi(int* a, int begin, int end)
{
	int midi = (begin + end) / 2;
	// begin midi end 三个数选中位数
	if (a[begin] > a[midi])
	{
		if (a[midi] > a[end])
			return midi;
		else if (a[begin] > a[end]) 
			return end;
		else 
 			return begin;
	}
	else  // a[begin] <= a[midi]
	{
		if (a[midi] < a[end])
			return midi;
		else if (a[begin] < a[end]) 
			return end;
		else  // a[end] <= a[begin] <= a[midi] 
			return begin;
	}
}

✨为什么要进行小区间优化？

  1. 减少递归深度：当快速排序处理的数组或子数组较小时，递归的深度会减少，从而能够更快地完成排序，减少函数调用开销。
  2. 避免栈溢出：对于较小的子数组使用非递归的方法可以避免在深层递归时出现栈溢出的问题。
  3. 提升平均性能：小区间优化通过结合递归和迭代，能够有效平衡不同情况下的性能，从而提升快速排序的平均性能。

综上所述，小区间优化是快速排序中一个重要的性能提升措施，它有助于降低算法在实际应用中的最坏情况时间复杂度，提高整体的排序效率。

【小区间优化快排代码】：

// 快排（霍尔法 + 小区间优化）
void QuickSort1(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	// 小区间优化
	if (end - begin + 1 <= 10) // 数组元素个数为小于10时调用直接插入排序
	{
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		// 三数取中，优化快排
		// begin midi end 三个数选中位数
		int midi = GetMidi(a, begin, end);
		Swap(&a[begin], &a[midi]);

		int left = begin, right = end;
		int keyi = begin;
		while (left < right)
		{
			// 右边找小
			while (left < right && a[right] >= a[keyi])
			{
				--right;
			}

			// 左边找大
			while (left < right && a[left] <= a[keyi])
			{
				++left;
			}

			Swap(&a[left], &a[right]);
		}

		Swap(&a[left], &a[keyi]);
		keyi = left;

		// [begin, keyi-1] keyi [keyi+1, end]
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

2.1 hoare版本 + 动图演示

算法步骤：

  1. 选择基准值：从待排序数列中选取第一个数作为基准值。
  2. 分区：重新排列数列，所有比基准值小的元素移到基准值的左边，所有比基准值大的元素移到基准值的右边。这个过程称为一趟快速排序。
  3. 递归排序：对基准值左、右两边的子序列重复上述步骤，直到所有子序列长度不超过1，此时待排序数列就变成了有序数列。

在这里插入图片描述

void Swap(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
// 快速排序递归实现
// hoare版快排的单趟排序
int PartSort1(int* a, int begin, int end)
{
	// 三数取中，优化快排
	// begin midi end 三个数中选中位数
	int midi = GetMidi(a, begin, end);
	Swap(&a[begin], &a[midi]);

	int left = begin, right = end;
	int keyi = begin;
	while (left < right)
	{
		// 注意：第一步是先从右边开始找小
		// 右边找小
		while (left < right && a[right] >= a[keyi])
		{
			--right;
		}

		// 左边找大
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}

		Swap(&a[left], &a[right]);
	}

	Swap(&a[left], &a[keyi]);

	return left;
}
// 快排
void QuickSort(int* a, int begin, int end)
{
    // 递归出口
	if (begin >= end)
		return;

	int keyi = PartSort1(a, begin, end);

	// [begin, keyi-1] keyi [keyi+1, end]
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

2.2 挖坑法 + 动图演示

算法步骤：

  1. 选择基准值：从待排序数列中选取第一个数作为基准值。
  2. 挖坑：将基准值放在待排序数列中的一个“坑”的位置上，这个“坑”的位置相当于基准值的索引。
  3. 分区：将比基准值小的元素移到基准值的左边，将比基准值大的元素移到基准值的右边。这一步实际上是在填平“坑”的过程，同时也使得基准值左边的元素都比它小，右边的元素都比它大。
  4. 递归排序：对基准值左、右两边的子序列重复上述步骤，直到所有子序列长度不超过 1，此时待排序数列就变成了有序数列。

在这里插入图片描述

void Swap(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
// 挖坑法
int PartSort2(int* a, int begin, int end)
{
	// 三数取中，优化快排
	// begin midi end 三个数选中位数
	int midi = GetMidi(a, begin, end);
	Swap(&a[begin], &a[midi]);

	int key = a[begin]; // 保存基准值
	int hole = begin; // 初始化坑位为基准值的下标
	while (begin < end)
	{
		// 右遍找小，填到左边的坑
		while (begin < end && a[end] >= key)
		{
			--end;
		}

		a[hole] = a[end]; // 填坑
		hole = end; // 更新坑位

		// 左边找大，填到右边的坑
		while (begin < end && a[begin] <= key)
		{
			++begin;
		}

		a[hole] = a[begin]; // 填坑
		hole = begin; // 更新坑位
	}
	a[hole] = key; // 将基准值归位
	return hole; // 返回基准值的正确下标
}
// 快排
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int keyi = PartSort2(a, begin, end);

	// [begin, keyi-1] keyi [keyi+1, end]
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

2.3 前后指针法 + 动图演示

算法步骤：

  1. 选择基准值：从待排序数列中选取第一个数作为基准值(key)。
  2. 创建前后指针：创建两个指针，prev和cur，prev指向数组序列首元素位置，cur指向prev的下一个位置。
  3. 遍历：通过遍历，如果cur指针找到比key小的数，然后判断prev的下一个位置是否为cur所处的位置，如果不是，则将两个值进行交换，如果是，则继续往后遍历，直到cur遍历结束。
  4. 归位：最后要将key基准值与prev指向的值进行互换，最终确认基准值处于数组序列的中间位置。
  5. 递归排序：递归地对基准值左边和右边的子数组进行排序。

在这里插入图片描述

void Swap(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
// 前后指针法
int PartSort3(int* a, int begin, int end)
{
	// 三数取中，优化快排
	// begin midi end 三个数选中位数
	int midi = GetMidi(a, begin, end);
	Swap(&a[begin], &a[midi]);
	int keyi = begin;

	int prev = begin;
	int cur = prev + 1;
	while (cur <= end)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
			Swap(&a[prev], &a[cur]);

		++cur;
	}

	Swap(&a[keyi], &a[prev]);
	return prev;
}
// 快排
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int keyi = PartSort3(a, begin, end);

	// [begin, keyi-1] keyi [keyi+1, end]
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

2.4 快排的非递归

快速排序的非递归实现可以使用栈来模拟递归过程。以下是算法步骤和思想：

算法步骤：

  1. 初始化栈：创建一个空栈，用于 存储待处理的子数组的起始和结束位置。
  2. 初始状态入栈：将整个待排序数组的起始和结束位置作为初始状态入栈。
  3. 循环处理栈中的状态：当 栈不为空时，执行以下操作：
    • 弹出栈顶元素，即当前待处理的子数组的起始和结束位置。
    • 进行分区操作，找到基准值的正确位置，如果 左右两个子数组起始位置小于结束位置则将左右两个子数组的起始和结束位置入栈。
  4. 分区操作：在每个子数组上执行分区操作，将小于基准值的元素放在左边，大于基准值的元素放在右边。
  5. 更新栈：根据分区结果，将左子数组的起始和结束位置以及右子数组的起始和结束位置入栈。
  6. 重复循环：重复步骤3-5，直到栈为空，此时整个数组已经有序。

算法思想：

  1. 模拟递归：通过使用栈来模拟递归调用的过程，避免了函数调用的开销。
  2. 迭代处理：通过循环处理栈中的状态，实现了对整个数组的遍历和排序。
  3. 分区操作：在每个子数组上执行分区操作，将小于基准值的元素放在左边，大于基准值的元素放在右边。
  4. 更新栈：根据分区结果，将左子数组的起始和结束位置以及右子数组的起始和结束位置入栈，以便后续处理。

总的来说，快速排序的非递归实现利用了栈来模拟递归过程，通过迭代的方式对整个数组进行遍历和排序。这种方法可以避免函数调用的开销，并且可以更直观地理解快速排序的工作原理。

辅助栈代码：

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;		// 标识栈顶位置的
	int capacity;
}ST;

// 初始化栈
void STInit(ST* pst)
{
	assert(pst);

	pst->a = NULL;
	pst->capacity = 0;

	// 表示top指向栈顶元素的下一个位置
	pst->top = 0;

	// 表示top指向栈顶元素
	//pst->top = -1;
}
// 栈的销毁
void STDestroy(ST* pst)
{
	assert(pst);

	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

// 栈顶插入删除
void STPush(ST* pst, STDataType x)
{
	assert(pst);

	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		pst->a = tmp;
		pst->capacity = newcapacity;
	}

	pst->a[pst->top] = x;
	pst->top++;
}
// 栈顶元素出栈
void STPop(ST* pst)
{
	assert(pst);
	// 不为空
	assert(pst->top > 0);

	pst->top--;
}
// 取栈顶元素
STDataType STTop(ST* pst)
{
	assert(pst);
	// 不为空
	assert(pst->top > 0);

	return pst->a[pst->top - 1];
}
// 判断栈空
bool STEmpty(ST* pst)
{
	assert(pst);

	/*if (pst->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/

	return pst->top == 0;
}
// 获取栈的大小
int STSize(ST* pst)
{
	assert(pst);

	return pst->top;
}

快排的非递归代码：

// 快排（非递归）
void QuickSortNonR(int* a, int begin, int end)
{
	ST s;
	STInit(&s);
	// 把区间 [begin, end]压栈
	STPush(&s, end);
	STPush(&s, begin);

	while (!STEmpty(&s))
	{
		int left = STTop(&s);
		STPop(&s);
		int right = STTop(&s);
		STPop(&s);

		int keyi = PartSort3(a, left, right); // 三种方法都可
		// [left, keyi-1] keyi [keyi+1, right]
		// 判断当前基准值左右区间是否满足条件（即区间内的元素个数是否大于1），满足就将区间位置压入栈中
		if (keyi + 1 < right)
		{
			STPush(&s, right);
			STPush(&s, keyi + 1);
		}

		if (left < keyi - 1)
		{
			STPush(&s, keyi - 1);
			STPush(&s, left);
		}
	}

	STDestroy(&s);
}

2.5 快速排序特性总结

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)
    在这里插入图片描述
  3. 空间复杂度：O(logN)（递归开销）
  4. 稳定性：不稳定

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Vue】组件间通信的7种方法（全）

【Vue】组件间通信的7种方法（全）

目录 组件之前的通信方法 1. props/$emit 2.parent/children 3.ref 4.v-model 5.sync 6.attrs,attrs,attrs,listeners 7.provide/inject 7.eventBus 组件之前的通信方法 1. props/$emit 父传子 props 这个只能够接收父组件传来的数据 不能进行修改 可以静态传递 也可…
阅读更多...
【计算机视觉】目标检测 |滑动窗口算法、YOLO、RCNN系列算法

【计算机视觉】目标检测 |滑动窗口算法、YOLO、RCNN系列算法

一、概述 首先通过前面对计算机视觉领域中的卷积神经网络进行了解和学习&#xff0c;我们知道&#xff0c;可以通过卷积神经网络对图像进行分类。 如果还想继续深入&#xff0c;会涉及到目标定位(object location)的问题。在图像分类的基础上(Image classification)的基础上…
阅读更多...
Maven快速入门——基础篇

Maven快速入门——基础篇

本篇对Maven基础进行总结&#xff0c;主要对Maven的定义、作用、Maven坐标、依赖管理、依赖配置、依赖传递特性以及Maven的生命周期进行总结&#xff0c;后面会对springboot以及Maven高级进行总结。 文章目录 目录 一、Maven是什么&#xff1f; 二、Maven的作用&#xff1a; 三…
阅读更多...
基于YOLOv8深度学习的水稻叶片病害智能诊断系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战

基于YOLOv8深度学习的水稻叶片病害智能诊断系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战

《博主简介》 小伙伴们好&#xff0c;我是阿旭。专注于人工智能、AIGC、python、计算机视觉相关分享研究。 ✌更多学习资源&#xff0c;可关注公-仲-hao:【阿旭算法与机器学习】&#xff0c;共同学习交流~ &#x1f44d;感谢小伙伴们点赞、关注&#xff01; 《------往期经典推…
阅读更多...
openGauss学习笔记-213 openGauss 性能调优-总体调优思路

openGauss学习笔记-213 openGauss 性能调优-总体调优思路

文章目录 openGauss学习笔记-213 openGauss 性能调优-总体调优思路213.1 调优思路概述213.2 调优流程 openGauss学习笔记-213 openGauss 性能调优-总体调优思路 213.1 调优思路概述 openGauss的总体性能调优思路为性能瓶颈点分析、关键参数调整以及SQL调优。在调优过程中&…
阅读更多...
python使用两个栈实现队列

python使用两个栈实现队列

这里主要是使用两个栈来实现一个队列，并实现队列的入队和出队函数。 对于一个单词hello，如果正常情况下按照队列中先进先出的特点，会按照hello的顺序入队，同样也会按照hello的顺序出队。 添加图片注释，不超过 140 字（可选） 因此如果想要利用两个栈来形成队列，就要将后…
阅读更多...
基于SpringBoot+Vue的高校在线答疑管理系统

基于SpringBoot+Vue的高校在线答疑管理系统

末尾获取源码作者介绍&#xff1a;大家好&#xff0c;我是墨韵&#xff0c;本人4年开发经验&#xff0c;专注定制项目开发 更多项目&#xff1a;CSDN主页YAML墨韵 学如逆水行舟&#xff0c;不进则退。学习如赶路&#xff0c;不能慢一步。 目录 一、项目简介 二、开发技术与环…
阅读更多...
前端学习笔记 | 响应式网页+Boostrap

前端学习笔记 | 响应式网页+Boostrap

一、响应式网页 一套代码适应多端 1、媒体查询media(条件){css} max-width 小于等于max-width生效min-width 【案例】左侧隐藏 因为CSS的层叠性&#xff0c;书写顺序&#xff1a;max-width从大到小&#xff1b;min-width从小到大。 【媒体查询完整写法】 在html中link用于不同…
阅读更多...
JSP和JSTL板块：第二节 JSP的指令和动作 来自【汤米尼克的JAVAEE全套教程专栏】

JSP和JSTL板块：第二节 JSP的指令和动作 来自【汤米尼克的JAVAEE全套教程专栏】

JSP和JSTL板块&#xff1a;第二节 JSP的指令和动作 一、page指令&#xff1a;页面设置&#xff08;1&#xff09;导入包&#xff1a;import属性&#xff08;2&#xff09;设定字符集&#xff1a;pageEncoding属性&#xff08;3&#xff09;设定错误页面&#xff1a;errorPage/i…
阅读更多...
Docker上安装配置tomcat

Docker上安装配置tomcat

目录 1. 拉取镜像 2. 创建运行镜像 3. 查看是否创建成功 ps&#xff1a;如果出现404错误 tomcat目录结构 1. 拉取镜像 这里使用 tomcat:8.5.40 版本作为安装 docker pull tomcat:8.5.40 2. 创建运行镜像 docker run -d --name tomcat -p 8080:8080 \--privilegedtrue …
阅读更多...
day07-CSS高级

day07-CSS高级

01-定位 作用&#xff1a;灵活的改变盒子在网页中的位置 实现&#xff1a; 1.定位模式&#xff1a;position 2.边偏移&#xff1a;设置盒子的位置 left right top bottom 相对定位 position: relative 特点&#xff1a; 不脱标&#xff0c;占用自己原来位置 显示模…
阅读更多...
题目：有1，2，3，4共四个数字，能组成多少个不相同而且无重复数字的三位数有多少个，都是多少？lua

题目：有1，2，3，4共四个数字，能组成多少个不相同而且无重复数字的三位数有多少个，都是多少？lua

这是作者的思路&#xff0c; 创建三个表&#xff0c; 第一个数是从四个数遍历&#xff0c; 第二个是数剔除第一个数进行遍历 第三个是剔除第一第二个数遍历 脚本如下 local a{1,2, 3, 4} local b{} local c{} local d{} local function copy(tbl) local ctbl{} for k,v in…
阅读更多...
【JS】基于node-media-server搭建流媒体服务器示例

【JS】基于node-media-server搭建流媒体服务器示例

&#x1f60f;★,:.☆(&#xffe3;▽&#xffe3;)/$:.★ &#x1f60f; 这篇文章主要介绍基于node-media-server搭建流媒体服务器示例。 学其所用&#xff0c;用其所学。——梁启超 欢迎来到我的博客&#xff0c;一起学习&#xff0c;共同进步。 喜欢的朋友可以关注一下&…
阅读更多...
【机器学习】常见算法详解第2篇：KNN之kd树介绍（已分享，附代码）

【机器学习】常见算法详解第2篇：KNN之kd树介绍（已分享，附代码）

本系列文章md笔记&#xff08;已分享&#xff09;主要讨论机器学习算法相关知识。机器学习算法文章笔记以算法、案例为驱动的学习&#xff0c;伴随浅显易懂的数学知识&#xff0c;让大家掌握机器学习常见算法原理&#xff0c;应用Scikit-learn实现机器学习算法的应用&#xff0…
阅读更多...
Windows Server安装部署FTP服务

Windows Server安装部署FTP服务

文章目录 建立FTP目录通过IIS在Server上安装FTP服务配置FTP站点配置身份验证和授权测试FTP服务FTP软件推荐FTP客户端软件FTP服务器软件适合Ubuntu的FTP软件 推荐阅读 在Windows操作系统中安装和配置FTP服务&#xff0c;主要是基于Internet Information Services (IIS)的FTP服务…
阅读更多...
ABAP 笔记--内表结构不一致，无法更新数据库MODIFY和UPDATE

ABAP 笔记--内表结构不一致，无法更新数据库MODIFY和UPDATE

目录 ABAP 笔记内表结构不一致&#xff0c;无法更新数据库MODIFY和UPDATE ABAP 笔记 内表结构不一致&#xff0c;无法更新数据库 MODIFY和UPDATE 如果是使用MODIFY或者UPDATE
阅读更多...
【2024.2.3练习】修剪灌木

【2024.2.3练习】修剪灌木

题目描述 题目分析 数学思维题。首先容易看出从左往右树的最大高度是对称的&#xff0c;不妨只看前棵树&#xff0c;由于此时右边的灌木数量不少于左边灌木数量&#xff0c;所以要想长到最高一定是修剪到最右边再剪回来&#xff0c;设该树右边共有棵树&#xff0c;那么它能长到…
阅读更多...
python基于django的公交线路查询系统mf383

python基于django的公交线路查询系统mf383

1.个人信息的管理&#xff1a;对用户名&#xff0c;密码的增加、删除等 2.线路信息的管理&#xff1a;对线路的增加、修改、删除等 3.站点信息的管理&#xff1a;对站点的增加、修改、删除等 4.车次信息的管理&#xff1a;对车次的增加、修改、删除等 5.线路查询、站点查询 …
阅读更多...
JAVASE进阶：Collection高级（1）——源码分析contains方法、lambda遍历集合

JAVASE进阶：Collection高级（1）——源码分析contains方法、lambda遍历集合

&#x1f468;‍&#x1f393;作者简介&#xff1a;一位大四、研0学生&#xff0c;正在努力准备大四暑假的实习 &#x1f30c;上期文章&#xff1a;JAVASE进阶&#xff1a;函数式编程——lambda表达式替代匿名内部类 &#x1f4da;订阅专栏&#xff1a;JAVASE进阶 希望文章对你…
阅读更多...
2024 高级前端面试题之 HTTP模块 「精选篇」

2024 高级前端面试题之 HTTP模块 「精选篇」

该内容主要整理关于 HTTP模块 的相关面试题&#xff0c;其他内容面试题请移步至 「最新最全的前端面试题集锦」 查看。 HTTP模块精选篇 1. HTTP 报文的组成部分2. 常见状态码3. 从输入URL到呈现页面过程3.1 简洁3.2 详细 4. TCP、UDP相关5. HTTP2相关6. https相关7. WebSocket的…
阅读更多...
最新文章

Copyright @ 2022~2023