【数据结构】八大排序

news2024/10/7 4:27:18

目录

1. 排序的概念及其作用

1.1 排序的概念

1.2 排序运用

1.3 常见的排序算法

2. 常见排序算法的实现

2.1 插入排序

2.1.1 基本思想

2.1.2 直接插入排序

2.1.3 希尔排序（缩小增量排序）

2.2 选择排序

2.2.1 基本思想

2.2.2 直接选择排序

2.2.3 堆排序

2.3 交换排序

2.3.1 基本思想

2.3.2 冒泡排序

2.3.3 快速排序

2.3.3.1 快速排序优化

2.3.3.2 快速排序非递归

2.4 归并排序

2.5 非比较排序

3. 排序算法复杂度及稳定性分析

1. 排序的概念及其作用

1.1 排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r [ i ] = r [ j ]，且 r [ i ] 在 r [ j ] 之前，而在排序后的序列中，r [ i ] 仍在 r [ j ] 之前，则称这种排序算法是稳定的；否则称为不稳定的。

内部排序：数据元素全部放在内存中的排序。

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

1.2 排序运用

1.3 常见的排序算法

// 排序实现的接口

// 插入排序
void InsertSort(int* a, int n);

// 希尔排序
void ShellSort(int* a, int n);

// 冒泡排序
void BubbleSort(int* a, int n);

// 堆排序
void HeapSort(int* a, int n);

// 选择排序
void SelectSort(int* a, int n);

// 快速排序 递归实现
void QuickSort(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);

// 计数排序
void CountSort(int* a, int n);

2. 常见排序算法的实现

2.1 插入排序

2.1.1 基本思想

直接插入排序是一种简单的插入排序法，其基本思想是：

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

实际中我们玩扑克牌时，就用了插入排序的思想

2.1.2 直接插入排序

当插入第 i（i >= 1）个元素时，前面的 array[0]，array[1]，…，array[i-1] 已经排好序，此时用 array[i] 的排序码与 array[i-1]，array[i-2], … 的排序码顺序进行比较，找到插入位置即将 array[i] 插入，原来位置上的元素顺序后移。

// 直接插入排序
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];
			}
			else
			{
				break;
			}
			--end;
		}
		a[end + 1] = tmp;
	}
}

直接插入排序的特性总结：

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定

2.1.3 希尔排序（缩小增量排序）

希尔排序（Shell Sort）是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL.Shell于1959年提出而得名。希尔排序是记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

我们分割待排序记录的目的是减少待排序记录的个数，并使整个序列向基本有序发展。而如上面这样分完组后，就各自排序的方法达不到我们的要求。因此，我们需要采取跳跃分割的策略；将相距某个“增量”的记录组成一个子序列，这样才能保证在子序列内分别进行直接插入排序后得到的结果是基本有序而不是局部有序。

// 希尔排序
void ShellSort(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 (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

希尔排序的特性总结：

        1. 希尔排序是对直接插入排序的优化。

        2. 当 gap > 1 时都是预排序，目的是让数组更接近于有序。当 gap == 1 时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

        3. 希尔排序的时间复杂度不好计算，因为 gap 的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定：

《数据结构(C语言版)》--- 严蔚敏

《数据结构-用面相对象方法与C++描述》--- 殷人昆

因为咋们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：O(n^{1.25}) 到 O(1.6*n^{1.25}) 来算。

        4. 稳定性：不稳定

2.2 选择排序

2.2.1 基本思想

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

2.2.2 直接选择排序

  • 在元素集合 array[ i ] -- array[ n-1 ] 中选择关键码最大(小)的数据元素
  • 若它不是这组元素中的最后一个（第一个）元素，则将它与这组元素中的最后一个（第一个）元素交换
  • 在剩余的 array[ i ] -- array[ n-2 ]（array[ i+1 ] -- array[ n-1 ]）集合中，重复上述步骤，直到集合剩余1个元素

// 直接选择排序
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]);
		// max如果被换走了，修正一下
		if (maxi == begin)
		{
			maxi = mini;
		}
		Swap(&a[end], &a[maxi]);
		++begin;
		--end;
	}
}

直接选择排序的特性总结：

  1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

2.2.3 堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

// 向下调整
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (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)
{
	// 向下调整建堆
	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;
	}
}

堆排序的特性总结：

  1. 堆排序使用堆来选数，效率就高了很多。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

2.3 交换排序

2.3.1 基本思想

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

2.3.2 冒泡排序

// 冒泡排序
void BubbleSort(int* a, int n)
{
	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;
	}
}

冒泡排序的特性总结：

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

2.3.3 快速排序

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

// 假设按照升序对a数组中[begin, end]区间中的元素进行排序
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;

    // 按照基准值对a数组的[begin, end]区间中的元素进行划分
	int keyi = PartSort1(a, begin, end);

    // 划分成功后以keyi为边界形成了左右两部分[begin, keyi-1]和[keyi+1, end]
    // 递归排[begin, keyi-1]
	QuickSort(a, begin, keyi - 1);

    // 递归排[keyi+1, end]
	QuickSort(a, keyi + 1, end);
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，大家在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。

将区间按照基准值划分为左右两半部分的常见方式有：

        1. hoare版本

// 快速排序Hoare版本
int PartSort1(int* a, int left, int right)
{
    // 三数取中优化，下面会讲
	int midi = GetMidi(a, left, right);
	Swap(&a[left], &a[midi]);

	int keyi = left;
	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[keyi], &a[left]);
	return left;
}

        2. 挖坑法

// 快速排序挖坑法
int PartSort2(int* a, int left, int right)
{
	int midi = GetMidi(a, left, right);
	Swap(&a[left], &a[midi]);

	int key = a[left];
	// 保存key的值后，左边形成第一个坑
	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;
	return hole;
}

        3. 前后指针版本

// 快速排序前后指针法
int PartSort3(int* a, int left, int right)
{
	int midi = GetMidi(a, left, right);
	Swap(&a[left], &a[midi]);

	int prev = left;
	int cur = prev + 1;
	int keyi = left;
	while (cur <= right)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		++cur;
	}
	Swap(&a[prev], &a[keyi]);
	return prev;
}
2.3.3.1 快速排序优化
  1. 三数取中法选key
  2. 递归到小的子区间时，可以考虑使用插入排序
// 三数取中
int GetMidi(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])	// mid是最大值
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else    // a[left] > a[mid]
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])	// mid是最小值
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}
// 添加小区间优化的快速排序
void QuickSort1(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	// 小区间优化，小区间不再递归分割排序，降低递归次数
	if ((end - begin + 1) > 10)
	{
		int keyi = PartSort3(a, begin, end);
		QuickSort1(a, begin, keyi - 1);
		QuickSort1(a, keyi + 1, end);
	}
	else
	{
		InsertSort(a + begin, end - begin + 1);
	}
}
2.3.3.2 快速排序非递归
void QuickSortNonR(int* a, int begin, int end)
{
	ST st;
	STInit(&st);
	STPush(&st, end);
	STPush(&st, begin);

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

		int keyi = PartSort1(a, left, right);
		if (keyi + 1 < right)
		{
			STPush(&st, right);
			STPush(&st, keyi + 1);
		}
		if (left < keyi - 1)
		{
			STPush(&st, keyi - 1);
			STPush(&st, left);
		}
	}

	STDestroy(&st);
}

快速排序的特性总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(logN)
  4. 稳定性：不稳定

2.4 归并排序

基本思想：

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：

// 子函数 方便递归
void _MergeSort(int* a, int* tmp, int begin, int end)
{
	if (end <= begin)
		return;
	int mid = (end + begin) / 2;
	// [begin, mid] [mid + 1, end]
	_MergeSort(a, tmp, begin, mid);
	_MergeSort(a, tmp, mid + 1, end);
	// 归并到tmp数组，再拷贝回去
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int index = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[index++] = a[begin1++];
		}
		else
		{
			tmp[index++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[index++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[index++] = a[begin2++];
	}
	// 拷贝回原数组
	memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}

// 归并排序 递归实现
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	_MergeSort(a, tmp, 0, n - 1);
	free(tmp);
}
// 归并排序 非递归实现
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			// [begin1, end1] [begin2, end2] 归并
			// 如果第二组不存在，这一组不用归并了
			if (begin2 >= n)
			{
				break;
			}
			// 如果第二组的右边界越界，修正一下
			if (end2 >= n)
			{
				end2 = n - 1;
			}
			int index = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[index++] = a[begin1++];
				}
				else
				{
					tmp[index++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[index++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[index++] = a[begin2++];
			}
			// 拷贝回原数组
			memcpy(a + i, tmp + i, (end2 - i + 1) * sizeof(int));
		}
		gap *= 2;
	}
	free(tmp);
}

归并排序的特性总结：

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(N)
  4. 稳定性：稳定

2.5 非比较排序

思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：

  1. 统计相同元素出现次数
  2. 根据统计的结果将序列回收到原来的序列中

// 计数排序
void CountSort(int* a, int n)
{
	int min = a[0], max = a[0];
	for (int i = 0; i < n; i++)
	{
		if (a[i] < min)
			min = a[i];
		if (a[i] > max)
			max = a[i];
	}
	int range = max - min + 1;
	int* count = (int*)malloc(sizeof(int) * range);
	printf("range:%d\n", range);
	if (count == NULL)
	{
		perror("malloc fail");
		return;
	}
	memset(count, 0, sizeof(int) * range);
	// 统计数据出现次数
	for (int i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}
	// 排序
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (count[i]--)
		{
			a[j++] = i + min;
		}
	}
}

计数排序的特性总结：

  1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
  2. 时间复杂度：O(MAX(N, 范围))
  3. 空间复杂度：O(范围)
  4. 稳定性：稳定

3. 排序算法复杂度及稳定性分析

排序方法平均情况最好情况最坏情况辅助空间稳定性
冒泡排序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(nlogn)\sim O(n^{2})O(n^{1.3})O(n^{2})O(1)不稳定
堆排序O(nlogn)O(nlogn)O(nlogn)O(1)不稳定
归并排序O(nlogn)O(nlogn)O(nlogn)O(n)稳定
快速排序O(nlogn)O(nlogn)O(n^{2})O(nlogn)\sim O(n)不稳定

本文完

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

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

相关文章

掌握Java中的volatile关键字

掌握Java中的volatile关键字

高速缓存 什么是高速缓存 高速缓存&#xff08;Cache&#xff09;是一种用于存储计算机数据的临时存储设备&#xff0c;用于加速数据访问速度&#xff0c;减少对主存储器&#xff08;RAM&#xff09;或磁盘的频繁访问。高速缓存通过将最常用的数据存储在更接近CPU的位置&…
阅读更多...
使用Perl和WWW::Mechanize库编写

使用Perl和WWW::Mechanize库编写

以下是一个使用Perl和WWW::Mechanize库编写的网络爬虫程序的内容。代码必须使用以下代码&#xff1a;jshk.com.cn/get_proxy 首先&#xff0c;确保已经安装了Perl和WWW::Mechanize库。如果没有&#xff0c;请使用以下命令安装&#xff1a; cpan WWW::Mechanize创建一个新的Pe…
阅读更多...
删除vxe-table右上角的工具栏

删除vxe-table右上角的工具栏

删掉红框内的属性
阅读更多...
【MATLAB源码-第52期】基于matlab的4用户DS-CDMA误码率仿真，对比不同信道以及不同扩频码。

【MATLAB源码-第52期】基于matlab的4用户DS-CDMA误码率仿真，对比不同信道以及不同扩频码。

操作环境&#xff1a; MATLAB 2022a 1、算法描述 1. DS-CDMA系统 DS-CDMA (Direct Sequence Code Division Multiple Access) 是一种多址接入技术&#xff0c;其基本思想是使用伪随机码序列来调制发送信号。DS-CDMA的特点是所有用户在同一频率上同时发送和接收信息&#xf…
阅读更多...
抖音热搜榜：探索热门话题的独特魅力

抖音热搜榜：探索热门话题的独特魅力

在信息爆炸的时代&#xff0c;我们每天都会接收到大量的信息&#xff0c;而抖音热搜榜就像是一个窗口&#xff0c;让我们能够窥见当下最受欢迎、最具话题性的内容。作为全球最受欢迎的短视频平台之一&#xff0c;抖音凭借其海量的内容、独特的推荐算法&#xff0c;让越来越多的…
阅读更多...
阿里低代码Low Code Engine快速上手

阿里低代码Low Code Engine快速上手

一、环境准备 在正式开始之前，我们需要先安装相应的软件：WSL、Node等。Window 环境需要使用 WSL 在 windows 下进行低代码引擎相关的开发。安装教程➡️ WSL 安装教程。对于 Window 环境来说，之后所有需要执行命令的操作都是在 WSL 终端执行的。 2.1 Node 推荐安装Node 1…
阅读更多...
Topaz Photo AI forMac/win：革命性的图片降噪软件

Topaz Photo AI forMac/win：革命性的图片降噪软件

Topaz Photo AI是一款革命性的图片降噪软件&#xff0c;它利用人工智能技术对图片进行降噪处理&#xff0c;让你的照片焕然一新。与传统的降噪软件不同&#xff0c;Topaz Photo AI不仅降噪效果更出色&#xff0c;而且操作简单&#xff0c;让你可以轻松地提升图片质量。 Topaz …
阅读更多...
CUDA学习笔记6——事件计时

CUDA学习笔记6——事件计时

事件计时 CUDA事件是直接在GPU上实现的&#xff0c;因此它们不适用于对同时包含设备代码和主机代码的混合代码计时。 cudaEventCreate 创建一个事件cudaEventRecord 记录一个事件cudaEventElapsedTime 计算两个事件之间经历的时间&#xff0c;第一个参数为某个浮点变量的地址…
阅读更多...
MS12_020 3389远程溢出漏洞

MS12_020 3389远程溢出漏洞

1.search ms12_020 搜索ms12_020 2.use auxiliary/scanner/rdp/ms12_020_check 检查是否存在ms12_020漏洞 show options 查看所需参数 set RHOSTS x.x.x.x 设置目标IP地址 run 执行 检测出来有Ms12_020漏洞 3.use auxiliary/dos/windows/rdp/ms12_020_maxchannelids 选择…
阅读更多...
SMOS土壤水分产品下载

SMOS土壤水分产品下载

SMOS土壤水分产品下载 打开下载网站 打开网站 打开DATA下的SMOS 然后找到SMOS的L1和L2data 首先需要注册一下&#xff0c;在该网站 然后找到了SMOS的NRT土壤水分产品&#xff0c;该产品从2010年开始&#xff0c;一直发布到现在&#xff0c;是基于L波段。 这里就是每天的土…
阅读更多...
卷积神经网络CNN学习笔记-MaxPool2D函数解析

卷积神经网络CNN学习笔记-MaxPool2D函数解析

目录 1.函数签名:2.学习中的疑问3.代码 1.函数签名: torch.nn.MaxPool2d(kernel_size, strideNone, padding0, dilation1, return_indicesFalse, ceil_modeFalse) 2.学习中的疑问 Q:使用MaxPool2D池化时,当卷积核移动到某位置,该卷积核覆盖区域超过了输入尺寸时,MaxPool2D会…
阅读更多...
emqx 启动正常，但是1883端口无法telnet，emqx无法正常工作

emqx 启动正常，但是1883端口无法telnet，emqx无法正常工作

emqx一直正常工作&#xff0c;后面突然就不工作了&#xff0c;查找日志&#xff0c;发现报错说设备空间不足&#xff0c;但是我记得华为云SSD从40G扩容到500G&#xff0c;不至于空间不足&#xff0c;于是运行df -Dh确实显示只有40G&#xff0c;运行lsblk确实有500G&#xff0c;…
阅读更多...
2016-2023全国MPA国家A类线趋势图：浙大MPA要高多少？

2016-2023全国MPA国家A类线趋势图：浙大MPA要高多少？

公共管理硕士&#xff08;MPA&#xff09;项目的国家线这些年相对比较平稳&#xff0c;虽然以体制内考生为主的项目总体应试能力是比较强的&#xff0c;但因为全国mpa项目众多&#xff0c;能力参差不齐&#xff0c;导致每年的国家线划定也需要考虑综合情况。根据专注浙大的杭州…
阅读更多...
Qt实现一个电子相册

Qt实现一个电子相册

一、要实现的功能 在窗口中可以显示图片&#xff0c;并且能够通过两个按钮进行图片的前进和后退的顺序切换。有一个按钮&#xff0c;通过这个按钮可以从所存图片资源中随机选取一个图片进行展示通过按钮可以控制图片自动轮播顺序切换的开始与停止&#xff0c;显示当前系统的时…
阅读更多...
Spring framework day 03:Spring 整合 Mybatis(分页)

Spring framework day 03:Spring 整合 Mybatis(分页)

前言 在当今快速发展的软件开发领域&#xff0c;Java作为一种广泛使用的编程语言&#xff0c;以其强大的生态系统和丰富的框架而备受推崇。而在Java开发中&#xff0c;Spring框架几乎成为了事实上的标准&#xff0c;它为开发者提供了一种优雅且高效的方式来构建企业级应用程序…
阅读更多...
CVE-2019-0708漏洞实战

CVE-2019-0708漏洞实战

使用命令&#xff1a;search 0708搜索exp脚本 搜索网段中主机漏洞 use auxiliary/scanner/rdp/cve_2019_0708_bluekeep 照例&#xff0c;show options 看一下配置 设置网段set RHOSTS x.x.x.x run运行就行了 使用攻击模块 use exploit/windows/rdp/cve_2019_0708_bluekee…
阅读更多...
PAM从入门到精通（十八）

PAM从入门到精通（十八）

接前一篇文章&#xff1a;PAM从入门到精通&#xff08;十七&#xff09; 本文参考&#xff1a; 《The Linux-PAM Application Developers Guide》 PAM 的应用开发和内部实现源码分析 先再来重温一下PAM系统架构&#xff1a; 更加形象的形式&#xff1a; 六、整体流程示例 2.…
阅读更多...
Java学习笔记（五）——数组、排序和查找

Java学习笔记（五）——数组、排序和查找

一、数组 数组可以存放多个同一类型的数据。数组也是一种数据类型&#xff0c;是引用类型。即数组就是一组数据。 &#xff08;一&#xff09;数组的使用 1、使用方式1——动态初始化 &#xff08;1&#xff09;数组的定义&#xff1a; 数据类型 数组名[] new 数据类型…
阅读更多...
ubuntu安装rust教程

ubuntu安装rust教程

参考【Rust】Linux上安装Rust开发环境 sudo apt-get install curl# 注意&#xff0c;不开代理很可能下不到&#xff0c;一直报403 export RUSTUP_DIST_SERVERhttps://mirrors.ustc.edu.cn/rust-static export RUSTUP_UPDATE_ROOThttps://mirrors.ustc.edu.cn/rust-static/rustu…
阅读更多...
【软考-中级】系统集成项目管理工程师 【19 项目收尾管理】

【软考-中级】系统集成项目管理工程师 【19 项目收尾管理】

持续更新。。。。。。。。。。。。。。。 【第十九章】收尾管理 &#xff08;选择题1分&#xff09; 19.1 项目验收19.2 项目总结19.3系统维护19.3.1软件项目的后续工作19.3.2系统集成项目的后续工作 19.4 项目后评价1. 信息系统目标评价2. 信息系统过程评价3. 信息系统效益评价…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023