一篇博客读懂排序

news2024/12/24 21:59:19

目录

一、常见的排序

二、冒泡排序 

2.1基本思想：

2.2代码：

三、插入排序

3.1基本思想：

3.2思路讲解：

3.3代码：

3.4时间复杂度：

四、希尔排序

4.1基本思路：

4.2思路讲解：

4.3代码：

4.4时间复杂度：

五、选择排序

5.1基本思路：

5.2思路讲解：

5.3代码：

5.4时间复杂度：

六、堆排序

6.1基本思路：

6.2思路讲解：

6.3代码：

6.4时间复杂度：

七、快速排序（hoare版本）

7.1基本思路：

7.2思路讲解：

7.3代码：

7.4时间复杂度：

八、快速排序（挖坑法和前后指针版本）

8.1挖坑法

8.1.1挖坑法讲解

8.1.2代码：

 8.2前后指针版本

8.1.1前后指针讲解

8.1.2代码： 

九、归并排序 

9.1基本思路：

9.2思路讲解：

9.3代码：

9.4时间复杂度：

一、常见的排序

二、冒泡排序 

2.1基本思想：

冒泡排序，何为冒泡，即把数据最大的每次都排到最后一个位置，像冒泡一样。

2.2代码：

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

三、插入排序

3.1基本思想：

  把待排序的数据逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

3.2思路讲解：

以上图数据、升序为例。
为了便于理解，我们分为两大阵营，已排和未排。我们在没排序之前，这些数据全都是未排阵营，接着我们开始比较，由于已排阵营没有数据，所以9就是第一个。然后拿未排阵营的33和9比较，33放在9之后。
接着就是10和33比较，10放在33前；10和9排序，10放在9后，此趟结束。

46和33比较，46放在33后，此趟结束。

23和46比较，放在46前；23和33比较，放在33前；23和10比较，放在10后，此趟结束。

我相信说了这几趟，大家就能基本明白，插入排序就是把没排序的和已排序的从后向前依次比较然后找到不满足条件的位置把自己放进去。

3.3代码：

首先，我们先完成单趟排序。
然后，我们介绍一下需要新引入的变量：

其中，因为我们需要把数组看成两部分，所以我们引入end作为两者的分界点；当挪动数据时，我们用前一个数据覆盖后一个数据，所以需要tmp记录被覆盖元素的值，即当前插入的元素。
当我们的插入元素不满足条件时，即它在前后两个元素之间，此时end移动到了前一个元素，所以后来我们需要把end+1赋值为插入的数值：

void InsertSort(int arr[], int n)
{
	int end = 0;
	int tmp = arr[end + 1];
	
	while (end >= 0)
	{
		if (arr[end] > tmp)
		{
			arr[end + 1] = arr[end]; 
			end--;
		}
		else
		{
			break;
		}
	}
	arr[end + 1] = tmp;
}

我们把end作为了已排数列的最后一个元素的位置，由此可知我们的整套排序，end从0到n-1：

void InsertSort(int arr[], int n)
{
	int i = 0;
	for (; i < n - 1; i++)
	{
		int end = i;
		int tmp = arr[end + 1];

		while (end >= 0)
		{
			if (arr[end] > tmp)
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else
			{
				break;
			}
		}
		arr[end + 1] = tmp;

	}
}

3.4特点：

时间复杂度：

最坏情况：O(N^2) —— 逆序
最坏情况：O(N) —— 顺序有序

空间复杂度：

O(1)

稳定性：

稳定

什么是稳定性？

保证排序前相同的两个数的相对位置在排序后仍保持不变。 

四、希尔排序

4.1基本思路：

1.预排序：取间隔的数，为一组，对每一组进行插入排序
2.插入排序：对整体进行插入排序

4.2思路讲解：

4.3代码：

我们把插入排序的单趟间隔从1改为gap，完成希尔排序的第一步：

void ShellSort(int arr[], int n)
{
	int end = 0;
	int gap = 3;
	int tmp = arr[end + 1];

	while (end >= 0)
	{
		if (arr[end] > tmp)
		{
			arr[end + gap] = arr[end];
			end -= gap;
		}
		else
		{
			break;
		}
	}
	arr[end + gap] = tmp;
}

把以上操作重复gap次即为所求代码： 

void ShellSort(int arr[], int n)
{
	int gap = 3;
	for (int j = 0; j < gap; j++)
	{
		for (int i = j; i < n - gap; i += gap)
		{
			int end = i;
			int tmp = arr[end + 1];

			while (end >= 0)
			{
				if (arr[end] > tmp)
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = tmp;
		}
	}
}

 我们可以对上述代码进行优化，让它变为gap组同时排序：

void ShellSort(int arr[], int n)
{
	int gap = 3;
	
	for (int i = 0; i < n - gap; i++)
	{
		int end = i;
		int tmp = arr[end + gap];

		while (end >= 0)
		{
			if (arr[end] > tmp)
			{
				arr[end + gap] = arr[end];
				end -= gap;
			}
			else
			{
				break;
			}
		}
		arr[end + gap] = tmp;
	}
}

我们这还只是完成了第一步，接下来我们要进行插入排序：

void ShellSort(int arr[], int n)
{
	int gap = 3;
	
	for (int i = 0; i < n - gap; i++)
	{
		int end = i;
		int tmp = arr[end + gap];

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

		while (end >= 0)
		{
			if (arr[end] > tmp)
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else
			{
				break;
			}
		}
		arr[end + 1] = tmp;
	}
}

学到这里，其实这些分布的并非是真正的希尔排序，gap到底取多少的值？真的要分成两步？其实希尔排序的gap是随时变换的，最后gap的值为1时，才正好进行最后的插入排序，但gap的取值官方也未说明何时最好，我们只需要保证最后一次排序gap的值刚好为1即可：

void ShellSort(int arr[], 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 = arr[end + gap];

			while (end >= 0)
			{
				if (arr[end] > tmp)
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = tmp;
		}
	}
}

4.4特点：

希尔排序的复杂度分析是个复杂的问题，它的计算还涉及到数学领域中尚未解决的难题，但有人指出当n在特定范围时，其复杂度接近O(n^1.3)，当n->无穷大时，可以减少到O(n*(logn)^2)

时间复杂度：O(n^1.3)

空间复杂度：O(1)

稳定性：不稳定

五、选择排序

5.1基本思路：

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

5.2思路讲解：

选择排序其实没有什么难点，就是挨个比较然后将最小的换到首位，但其实我们可以同时找最大和最小值，然后让其找到对应的位置后再继续找次大的和次小的。

但是有一点需要注意，那就是当最后我们交换时，如果begin位置和maxi位置重合，那么先交换mini和begin的话，就无法找到正确的maxi值，反之同理，所以我们要多加一层判断来确保。

5.3代码：

首先我们先看一下我们需要新添加的变量：
1.标记交换最小值位置的begin和交换最大值位置的end，当一次选择完成后，他们标记的位置就会向后和向前挪动1个单位。
2.标记最大值最小值位置的maxi和mini，我们要记录当前最大值与最小值的元素下标，当每趟结束后与先前记录的begin和end交换。

void SelectSort(int arr[], int n)
{
	int begin = 0;
	int end = n - 1;
	
	while (begin < end)
	{
		int mini = begin;
		int maxi = begin;
		for (int i = begin; i <= end; i++)
		{
			if (arr[i] < arr[mini])
			{
				mini = i;
			}
			if (arr[i] > arr[maxi])
			{
				maxi = i;
			}
		}
		Swap(&arr[mini], &arr[begin]);
		if (maxi == begin)
		{
			maxi = mini;
		}
		Swap(&arr[maxi], &arr[end]);
		begin++;
		end--;
	}
}

5.4特点：

时间复杂度：

最好的情况：O(n^2)
最坏的情况：O(n^2)

空间复杂度：O(1)

稳定性：不稳定

六、堆排序

6.1基本思路：

利用大堆或小堆，每次找到一个最大值或最小值作为根结点并输出，再次进行堆排序，找到次大或次小值，重复上述操作。

6.2思路讲解：


6.3代码：

void AdjustUp(int* a, int child)
{
	while (child > 0)
	{
		int parent = (child - 1) / 2;
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
		}
		else
		{
			return;
		}
	}
}
void AdjustDown(int* a, int size, int parent)
{
	//假设左孩子小
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && a[child] < a[child + 1])
		{
			child = child + 1;
		}
		if (a[parent] < a[child])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = child * 2 + 1;
		}
		else
		{
			return;
		}
	}
}
//升序
void HeapSort(int* a, int n)
{
	//建大堆
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

6.4特点：

时间复杂度：O(N*logN)

空间复杂度：O(1)

稳定性：不稳定

七、快速排序（hoare版本）

7.1基本思路：

任取待排序元素序列中 的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

7.2思路讲解：

我们需要用两个指针，一个从前走，一个从后走，依次筛选满足条件的值，若不满足条件则交换。
还有一个小细节：我们要让右边指针先走，这样左右指针相遇时永远指向比key小的值，这样让left和key交换才能完成排序。

下面我们先来完成单趟，选用一个key值作为基准值，小的排在左边，大的排在右边，这样一次可以把整个数组分为两部分，然后我们还要进行基准值位置的调整，此时的left位置就是key应在的位置。

然后我们再分别对左右两边进行同样的步骤，即递归，当只剩下一个元素时就可以结束我们的递归操作，此时我们的数组也全部排序完成。

7.3代码：

首先我们来看新加变量，left和right指针，负责分别从两侧检索，keyi为此次所选的基准值的下标，但是需要注意的是，我们的left指针和keyi指针不能指向一个位置，我们的keyi指向的元素是不能和right指向的值进行交换的！

void QuickSort(int* a, int n)
{
	int right = n - 1;
	int keyi = 0;
	int left = keyi + 1;
	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]);
}

完成了单趟排序以后，我们要进行递归调用，所以此时我们函数体引用不便再使用n作为区间标记，而是需要改用begin和end作为区间的分割点，使我们调用函数更加准确，然后递归调用的区间就是[begin,keyi-1] key [key+1,end]

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	int keyi = begin;
	int right = end;
	int left = begin;//left和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[keyi], &a[left]);
	keyi = left;
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

7.4特点：

时间复杂度：O(N*logN)
空间复杂度：O(N)
稳定性：不稳定

八、快速排序（挖坑法和前后指针版本）

8.1挖坑法

8.1.1挖坑法讲解

这个方法我原称其为左右横跳方法。这个坑一直在左右横跳，当左右指针相遇时，把Key值填入即可。而且我们可以发现左右指针的规律，没有指向坑的指针走。


8.1.2代码：

我们先把QuickSort的代码改一改，让它能更方便的测试我们的三个方法：
 

//hoare版本
int PartSort1(int* a, int begin, int end)
{
	
	int keyi = begin;
	int right = end;
	int left = 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[keyi], &a[left]);
	return left;
}

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int keyi = PartSort1(a, begin, end);
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

我们再来看挖坑法：我们使用数组额外的新变量key来直接控制基准值，我认为这比用数组的某个下标控制更加稳定，然后每次都把坑用key的值填上也是为了更加稳定的控制：

//挖坑法
int PartSort2(int* a, int begin, int end)
{
	int hole = begin;
	int key = a[begin];
	while (begin < end)
	{
		if (begin != hole)
		{
			while (begin < end && a[begin] <= key)
			{
				begin++;
			}
			a[end] = a[begin];
			a[begin] = key;
			hole = begin;
		}
		if (end != hole)
		{
			while (begin < end && a[end] >= key)
			{
				end--;
			}
			a[begin] = a[end];
			a[end] = key;
			hole = end;
		}
	}
	return hole;
}

 8.2前后指针版本

8.1.1前后指针讲解

其实画图把整个流程完整的走一遍我们就可以知道我们的目的是为了让prev和cur指针中间的值都是比key大的值，然后prev++负责记录下一个大的值，cur负责记录比key小的值，每次找到就交换，最后再把prev的值变为key即可。
如果看不懂，建议自己画一遍实操一下即可。

8.1.2代码： 

//前后指针版本
int PartSort3(int* a, int begin, int end)
{
	int key = a[begin];
	int prev = begin;
	int cur = begin + 1;
	while (cur <= end)
	{
		if (a[cur] < key)
		{
			prev++;
			Swap(&a[cur], &a[prev]);
		}
		cur++;
	}
	Swap(&a[prev], &a[begin]);
	return prev;
}

 我们也可以在第一个大while循环中把if换成while：

int PartSort3(int* a, int begin, int end)
{
	int key = a[begin];
	int prev = begin;
	int cur = begin + 1;
	while (cur <= end)
	{
		while (cur <= end && a[cur] > key)
		{
			cur++;
		}
		if (cur <= end)
		{
			prev++;
			Swap(&a[prev], &a[cur]);
			cur++;
		}
	}
	Swap(&a[prev], &a[begin]);
	return prev;
}

九、归并排序 

9.1基本思路：

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

9.2思路讲解：

我们的归并排序是运用分治法的一个排序，下面是分的过程：

 我们看到了控制分停止的条件就是begin>=end，下面我们看合的过程：

每次合都会把合到一起的几个元素排序，因为我们是数组， 所以我们还需要一个新数组负责挪动数据。 

9.3代码：

根据思路讲解，我们先来看分的过程：

if (begin >= end)
		return;
	//分
	int mid = (begin + end) / 2;
	MergeSort(a, begin, mid, tmp);
	MergeSort(a, mid + 1, end, tmp);

然后我们只需要完成一次合的过程：

    //合
	int begin1 = begin;
	int end1 = mid;

	int begin2 = mid + 1;
	int 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++];
	}

最后把tmp复制到我们正式的数组上即可：

memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
void MergeSort(int* a, int begin, int end, int* tmp)
{
	if (begin >= end)
		return;
	//分
	int mid = (begin + end) / 2;
	MergeSort(a, begin, mid, tmp);
	MergeSort(a, mid + 1, end, tmp);
	
	//合
	int begin1 = begin;
	int end1 = mid;

	int begin2 = mid + 1;
	int 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));
}

9.4特点：

时间复杂度：O(N*logN)
每层的时间复杂度是O(N)，因为二分，一共有logN层。
空间复杂度：O(N)
稳定性：

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

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

相关文章

[BSidesCF 2020]Had a bad day

[BSidesCF 2020]Had a bad day

先看url&#xff0c;发现可能有注入 http://655c742e-b427-485c-9e15-20a1e7ef1717.node5.buuoj.cn:81/index.php?categorywoofers 试试能不能查看index.php直接?categoryindex.php不行&#xff0c;试试伪协议 把.php去掉试试 base64解码 <?php$file $_GET[category];…
阅读更多...
JS高频面试题（下）

JS高频面试题（下）

11. 线程和进程的区别 进程是资源分配的最小单元&#xff0c;线程是代码执行的最小单元。 一个应用程序可能会开启多个进程&#xff0c;进程之间数据不共享&#xff0c;一个进程内部可以开启多个线程&#xff0c;线程之间的数据可以共享的&#xff0c;所以多线程的情况下&…
阅读更多...
【STM32】STM32学习笔记-W25Q64简介(37)

【STM32】STM32学习笔记-W25Q64简介(37)

00. 目录 文章目录 00. 目录01. SPI简介02. W25Q64简介03. 硬件电路04. W25Q64框图05. Flash操作注意事项06. 预留07. 附录 01. SPI简介 在大容量产品和互联型产品上&#xff0c;SPI接口可以配置为支持SPI协议或者支持I 2 S音频协议。SPI接口默认工作在SPI方式&#xff0c;可以…
阅读更多...
uniapp page宽度设置为750rpx，子元素宽度100%，大小不一致

uniapp page宽度设置为750rpx，子元素宽度100%，大小不一致

uniapp page宽度设置为750rpx&#xff0c;子元素宽度100%&#xff0c;大小不一致。 原因是我在page加了margin: 0 auto;去掉就正常了&#xff08;但是如果在超大屏幕还是会出现&#xff0c;我猜是使用rpx导致的&#xff0c;rpx渲染成页面时会转成精确到一个小数点几位数的rem&a…
阅读更多...
row_to_json 用法：postgresql将数据转化为json

row_to_json 用法：postgresql将数据转化为json

如图示&#xff0c;表名为tbl_res_disposal_report,想将查出来的数据转化为json格式 sql: select row_to_json(tbl_res_disposal_report) from tbl_res_disposal_report where 11;查询结果如下图 如果只想转化其中的部分字段&#xff0c; select row_to_json(row(id,dept_n…
阅读更多...
自动化网络故障管理

自动化网络故障管理

故障管理是网络管理的组成部分&#xff0c;涉及检测、隔离和解决问题&#xff0c;如果实施得当&#xff0c;网络故障管理可以使连接、应用程序和服务保持在最佳水平&#xff0c;提供容错能力并最大限度地减少停机时间&#xff0c;专门为此目的设计的平台或工具称为故障管理系统…
阅读更多...
前端开发_JavaScript之WebAPI

前端开发_JavaScript之WebAPI

WebAPI作用和分类 作用: 就是使用 JS 去操作 html 和浏览器 分类&#xff1a;DOM (文档对象模型)、BOM&#xff08;浏览器对象模型&#xff09; DOM DOM&#xff08;Document Object Model——文档对象模型&#xff09;是用来呈现以及与任意 HTML 或 XML文档交互的API DOM…
阅读更多...
静态分析C语言生成函数调用关系的利器——cally和egypt

静态分析C语言生成函数调用关系的利器——cally和egypt

大纲 准备工作安装graphviz安装cally安装egypt简单分析GCC产生RTL&#xff08;Register transfer language&#xff09;文件callyegypt总结 高级分析callyegypt 总结参考资料 在《静态分析C语言生成函数调用关系的利器——cflow》和《静态分析C语言生成函数调用关系的利器——c…
阅读更多...
【CentOS】Linux 文件权限与权限修改

【CentOS】Linux 文件权限与权限修改

目录 1、Linux 中的文件属性 2、如何修改文件属性与权限 3、目录权限与文件权限的区别 4、Linux 中的文件扩展名 用户与用户组是Linux文件权限的重要组成部分。 首先&#xff0c;一定要明确用户与用户组的概念&#xff1a; Linux 一般将文件可读写的身份分为三个类别&#…
阅读更多...
Linux系统中虚拟文件系统原理与方法

Linux系统中虚拟文件系统原理与方法

在 Unix 的世界里&#xff0c;有句很经典的话&#xff1a;一切对象皆是文件。这句话的意思是说&#xff0c;可以将 Unix 操作系统中所有的对象都当成文件&#xff0c;然后使用操作文件的接口来操作它们。Linux 作为一个类 Unix 操作系统&#xff0c;也努力实现这个目标。 虚拟文…
阅读更多...
苹果AI新动向：隐秘收购与人才招募揭示其下一代AI技术布局

苹果AI新动向：隐秘收购与人才招募揭示其下一代AI技术布局

AI圈的隐形“大佬” 苹果公司于2023年7月被传出正在积极涉足生成式AI领域&#xff0c;据传正在开发名为“AJAX”的大型语言模型。他们甚至为员工内部开发了类似 ChatGPT的聊天机器人&#xff0c;可能被称为“Apple GPT”。这一创新工作由苹果公司的机器学习与AI部门主管John G…
阅读更多...
【数据结构】 循环队列的基本操作 （C语言版）

【数据结构】 循环队列的基本操作 （C语言版）

目录 一、顺序队列 1、顺序队列的定义&#xff1a; 2、顺序队列的优缺点&#xff1a; 二、循环队列 1、循环队列的定义&#xff1a; 2、循环队列的优缺点&#xff1a; 三、循环队列的基本操作算法&#xff08;C语言&#xff09; 1、宏定义 2、创建结构体 3、循环队…
阅读更多...
[docker] Docker 网络

[docker] Docker 网络

一、Docker 网络 1.1 Docker 网络实现原理 Docker使用Linux桥接&#xff0c;在宿主机虚拟一个Docker容器网桥(docker0)&#xff0c;Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址&#xff0c;称为Container-IP&#xff0c;同时Docker网桥是每个容器的默认…
阅读更多...
【嵌入式学习】网络通信基础-项目篇：简单UDP聊天室

【嵌入式学习】网络通信基础-项目篇：简单UDP聊天室

源码已在GitHub开源&#xff1a;0clock/LearnEmbed-projects/chat 实现的功能 客户端功能&#xff1a; 上线发送登录的用户名[yes] 发送消息和接收消息[yes] quit退出 服务器端功能&#xff1a; 统计用户上线信息&#xff0c;放入链表中[yes] 接收用户信息并给其他用户发送消…
阅读更多...
基于springboot+vue的在线商城系统(前后端分离)

基于springboot+vue的在线商城系统(前后端分离)

博主主页&#xff1a;猫头鹰源码 博主简介&#xff1a;Java领域优质创作者、CSDN博客专家、公司架构师、全网粉丝5万、专注Java技术领域和毕业设计项目实战 主要内容&#xff1a;毕业设计(Javaweb项目|小程序等)、简历模板、学习资料、面试题库、技术咨询 文末联系获取 项目介绍…
阅读更多...
“探索C语言操作符的神秘世界：从入门到精通的全方位解析“

“探索C语言操作符的神秘世界：从入门到精通的全方位解析“

各位少年&#xff0c;我是博主那一脸阳光&#xff0c;今天来分享深度解析C语言操作符&#xff0c;C语言操作符能帮我们解决很多逻辑性的问题&#xff0c;减少很多代码量&#xff0c;就好比数学的各种符号&#xff0c;我们现在深度解剖一下他们。 前言 在追求爱情的道路上&…
阅读更多...
Conda python管理packages二 从入门到精通

Conda python管理packages二 从入门到精通

Conda系列&#xff1a; 翻译: Anaconda 与 miniconda的区别Miniconda介绍以及安装Conda python运行的包和环境管理 入门Conda python管理环境environments 一 从入门到精通Conda python管理环境environments 二 从入门到精通Conda python管理环境environments 三 从入门到精通…
阅读更多...
华为服务器RAID5

华为服务器RAID5

0、BIOS默认密码 TaiShan 100服务器BIOS系统的默认密码为**“Huawei12#$”&#xff0c; TaiShan 200服务器BIOS系统的默认密码为“Admin9000”**。 1、服务器开机选择DEL,进行设置 2、选择设备管理器进入配置页面 3、选择AVAGO MegaRAID configuration utility 进入raid配置…
阅读更多...
【软件测试】学习笔记-性能测试场景的分类

【软件测试】学习笔记-性能测试场景的分类

性能测试场景的重要程度类似于业务测试的 case&#xff0c;case 是你进行业务测试的指引&#xff0c;case 是否完善也直接决定了测试的覆盖率。同理&#xff0c;场景是传递执行性能测试的步骤和目的&#xff0c;关于这两点是你一定要清楚的。 首先认识下最重要的三个性能场景&…
阅读更多...
C#从网址上读取json数据

C#从网址上读取json数据

需求&#xff1a;从客户给的网址中读取json格式的数据。 找了好多资料&#xff0c;都不太好使&#xff0c;看到了一篇很有帮助的文章。以下大部分内容和这篇找到的文章近似。太不容易了&#xff0c;同时也感谢这篇文章的作者心所欲。 https://www.cnblogs.com/zoujinhua/p/10…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023