【算法】常用排序算法

这篇具有很好参考价值的文章主要介绍了【算法】常用排序算法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

【算法】常用排序算法


需要云服务器等云产品来学习Linux的同学可以移步/-->腾讯云<--/-->阿里云<--/-->华为云<--/官网,轻量型云服务器低至112元/年,新用户首次下单享超低折扣。


目录

 一、常见排序算法 

二、直接插入排序

1、直接插入排序思想

2、直接插入排序代码

二、希尔排序

1、希尔排序思想

2、希尔排序代码

三、选择排序

1、选择排序思想

2、选择排序的代码

四、堆排序

1、堆排序思想

2、堆排序代码

五、冒泡排序

1、冒泡排序思想

2、冒泡排序代码

六、快速排序

1、hoare版

1.1hoare版单趟排序动图

1.2代码

1.3思想

1.4三数取中,优化选key

1.5小区间优化,减少递归次数

2、挖坑法

2.1挖坑法单趟排序动图

2.2挖坑法思想

2.3挖坑法代码

3、前后指针法

3.1前后指针法单趟排序动图

3.2前后指针法思想

3.3前后指针法代码

4、快排的非递归方法

4.1非递归的思想

4.2非递归代码

七、归并排序

1、归并排序的递归方法

1.1归并排序的思想

1.2归并排序代码

2、归并排序的非递归

2.1归并排序的非递归思想

2.2归并排序的非递归代码

八、计数排序

1、计数排序的思想

2、计数排序代码


 一、常见排序算法 

类别

排序方法

时间复杂度

空间复杂度

稳定性

适用场景

平均

最好

最坏

插入排序

直接插入排序

O()

O(N)有序场景

O()逆序场景

O(1)

稳定

数据有序或接近有序,

时间O()中最强排序

希尔排序

O()

O(N)有序场景

O()每两个数进行一次比较并交换

O(1)

不稳定

插入排序怕大量无序不重复数据,希尔是插入的改良

选择排序

直接选择排序

O()

~~

~~

O(1)

不稳定例如89855

最差排序

堆排序

O(N*logN)

~~

~~

O(1)

不稳定

1、首次建堆可以用于找最大/最小。2、top k问题

交换排序

冒泡排序

O()

~~

~~

O(1)

稳定

”那你先写个冒泡排序吧“

快速排序

O(N*logN)

~~

O()有序场景

O(logN)

不稳定

官方库采用的排序算法,遇事不决用快排

归并

归并排序

O(N*logN)

~~

~~

O(N)

稳定

外排序

非比较排序

计数排序

O(N+range)

~~

~~

O(range)

稳定

适合排序数据范围小的数据,不能排序浮点数

二、直接插入排序

1、直接插入排序思想

扑克牌玩过吧,扑克牌抽牌,边抽边排的思想。

【算法】常用排序算法

虽然直接插入排序是一个的算法,但可以认为它是所有算法中最优的。当直接插入排序遇到重复数据较多、有序、接近有序的数据时,时间复杂度将会降为O()。

直接插入排序的缺点就是时间复杂度过大,针对大量无序不重复数据,排序吃力,所以就有了希尔排序。

2、直接插入排序代码

void InsertSort(int* arr, int size)//插入排序O(N^2)
{
	for (int i = 0; i < size - 1; ++i)
	{
		int end = i;//end是最后一个有序数字的下标
		int tmp = arr[end + 1];
		while (end >= 0)
		{
			if (arr[end] > tmp)
			{
				arr[end + 1] = arr[end];
				--end;
			}
			else
				break;
		}
		arr[end + 1] = tmp;//最后把tmp放到数组end+1位置处
	}
}

二、希尔排序

1、希尔排序思想

【算法】常用排序算法

希尔排序是直接插入排序的改进,gap可以除三加一,也可以除二。每次循环gap是变化的。

gap大于1,称为预排序。希尔排序的预排序是将gap间隔的数据分为一组,进行直接插入排序,让数组接近有序。

gap越大,数组内的数字跳的越快,但排完还不是有序。gap越小,数字跳的越慢,但排完越接近有序。希尔排序gap先大后小。

在数据均不相等的情况下,数据较少,希尔排序优于O(),反之,希尔排序劣于O()

2、希尔排序代码

void ShellSort(int* arr, int size)//希尔排序(N^1.3)
{
	int gap = size;
	while (gap > 1)//gap等于1时说明已经有序,退出循环
	{
		gap = gap / 3 + 1;
		for (int i = 0; i < size - gap; ++i)
		{
			int end=i;//end是数组最后一个元素的下标
			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;
		}
	}
}

三、选择排序

1、选择排序思想

【算法】常用排序算法

以升序为例,选择排序每次遍历数组,选出最大的那个数。可以认为它是最菜的排序算法。

以下代码为选择排序的优化,遍历一次选出最大和最小的数字。

2、选择排序的代码

void CelectSort(int* arr, int size)//选择排序
{
	int begin = 0, end = size - 1;
	while (begin < end)
	{
		int min = begin, max = begin;
		for (int i = begin+1; i <=end; ++i)
		{
			if (arr[i] > arr[max])
				max = i;
			if (arr[i] < arr[min])
				min = i;
		}
		if (max == begin)
		{
			max = min;
		}
		Swap(&arr[begin], &arr[min]);
		Swap(&arr[end], &arr[max]);
		++begin;
		--end;
	}
}

注意:一趟遍历选出最大和最小的写法,需要考虑max==begin的情况。防止max在初始位置,但该点的值被min换走的情况。

四、堆排序

1、堆排序思想

1、以升序为例:先找到最后一个非叶节点,采用向下调整算法,再找到倒数第二个非叶节点,重复向下调整算法,把一个数组建成堆。这个时候,堆顶就是数组中最大的数。该步时间复杂度O(N)

动图如下:

【算法】常用排序算法

2、将数组调整成大堆后,将堆顶数据(最大的数)和堆底数据进行互换,锁定这个最大的数。这个时候原有的堆形态被破坏,需要重新使用向下调整算法对这个数组重建堆。迭代锁定。该步时间复杂度O(N*logN)

动图如下:

【算法】常用排序算法

2、堆排序代码

void Adjustdown(int* arr, int size, int parent)//向下调整算法
{
	int maxChild = 2 * parent + 1;
	while (maxChild<size)
	{
		if (maxChild + 1 < size && arr[maxChild] < arr[maxChild + 1])
		{
			++maxChild;
		}
		if (arr[maxChild] > arr[parent])
		{
			Swap(&arr[maxChild], &arr[parent]);
		}
		parent = maxChild;
		maxChild = 2 * parent + 1;
	}
}
void HeapSort(int* arr, int size)//堆排序O(N*logN)
{
	//初始化建堆O(N)
	for (int i = (size - 1 - 1) / 2; i >= 0; --i)
	{
		Adjustdown(arr, size, i);
	}
	//重建堆O(N*logN)
	for (int i = 0; i < size - 1; ++i)
	{
		Swap(&arr[0], &arr[size - 1 - i]);
		Adjustdown(arr, size-1-i, 0);
	}
}

五、冒泡排序

1、冒泡排序思想

【算法】常用排序算法

一对一对地交换

2、冒泡排序代码

void BubbleSort(int* arr, int size)//冒泡排序(N^2)
{
	for (int i = 0; i < size - 1; ++i)//趟数
	{
		int flag = 0;
		for (int j = 0; j < size - 1 - i; ++j)
		{
			if (arr[j] > arr[j + 1])
			{
				Swap(&arr[j], &arr[j + 1]);
				flag = 1;
			}
		}
		if (flag == 0)
			break;
	}
}

立个flag,当flag没变,说明一趟走完没有进行两两交换,数组已经有序,跳出循环结束排序。

六、快速排序

1、hoare版

1.1hoare版单趟排序动图

【算法】常用排序算法

1.2代码

//[left,right]
int PartSort(int* arr, int left, int right)//单趟排完不是有序,只是key左边比key小,右边比key大
{
	int keyi = left;//选left做key,keyi是下标
	while (left < right)
	{
		//我们选了left做key,那么右边先走。反之左边先走。
		while (left < right && arr[right] >= arr[keyi])//R找小
		{
			--right;
		}
		while (left < right && arr[left] <= arr[keyi])//L找大
		{
			++left;
		}
		Swap(&arr[left], &arr[right]);
	}
	int meet = left;//meet是left和right的相遇点下标
	Swap(&arr[meet], &arr[keyi]);
	return meet;
}
//[begin,end]
void QuickSort(int* arr, int begin,int end)//快排
{
	if (begin >= end)
		return;
	int keyi = PartSort(arr, begin, end);
	//[begin,keyi-1] key [keyi+1,end]
	QuickSort(arr, begin, keyi - 1);//快排
	QuickSort(arr, keyi + 1, end);//快排
}

1.3思想

1、PartSort是单趟排序,我们先在数组中选择一个位置做key,一般是数组开头或末尾那个位置。

上面代码中,是用数组首元素做key,为了保证小人相遇位置的值小于key,必须让右边的小人先行动。如果用数组末尾做key,那么需要左边的小人先走。

右边小人一直走,遇到比key小的数则停下,左边小人再走,遇到比key大的数停下。再交换左右小人脚下的数字。交换完成后一直重复此步骤,直到左右小人相遇。

将相遇点与keyi位置交换(注意我们是要改变数组,所以需要交换相遇点与keyi位置的值,而不是交换相遇点与key的值)

单趟排序完成后,keyi左边的值都比key小,keyi右边的值都比key大。

2、QuickSort中利用二叉树的递归,完成排序。

该方法存在缺陷

1、递归层数过多有爆栈风险 2、面对有序或者接近有序的待排序数据,时间复杂度就变成了O()

所以需要作如下优化:

1.4三数取中,优化选key

1、随机选key(听着就很随机,虽然不靠谱,但有的场景还是可以使用随即选key的方法)

2、针对有序情况,选正中间数据做key(前提是知道有序)

3、三数取中(选出左中右三数中间大小的做key)(三数取中后,对于缺陷2,直接由最坏情况变成最好情况)

三数取中代码实现:

int GetMidIndex(int* arr, int left, int right)//三数取中
{
	int mid = left + (right-left) / 2;
	if (arr[left] >= arr[right])
	{
		if (arr[left] > arr[mid])
		{
			if (arr[mid] >= arr[right])
				return mid;
			else
				return right;
		}
		else
			return left;
	}
	else
	{
		if (arr[right] > arr[mid])
		{
			if (arr[mid] >= arr[left])
				return mid;
			else
				return left;
		}
		else
			return right;
	}
}
//[left,right]
int PartSort(int* arr, int left, int right)//单趟排完不是有序,只是key左边比key小,右边比key大
{
	int mid = GetMidIndex(arr, left, right);
	Swap(&arr[mid], &arr[left]);
	int keyi = left;//选left做key,keyi是下标
	while (left < right)
	{
		//我们选了left做key,那么右边先走。反之左边先走。
		while (left < right && arr[right] >= arr[keyi])//R找小
		{
			--right;
		}
		while (left < right && arr[left] <= arr[keyi])//L找大
		{
			++left;
		}
		Swap(&arr[left], &arr[right]);
	}
	int meet = left;//meet是left和right的相遇点下标
	Swap(&arr[meet], &arr[keyi]);
	return meet;
}
//[begin,end]
void QuickSort(int* arr, int begin,int end)//快排
{
	if (begin >= end)
		return;
	int keyi = PartSort(arr, begin, end);
	//[begin,keyi-1] key [keyi+1,end]
	QuickSort(arr, begin, keyi - 1);//快排
	QuickSort(arr, keyi + 1, end);//快排
}

三数取中后,我们继续进行下一个优化:

1.5小区间优化,减少递归次数

我们知道。二叉树的最后一层节点个数近乎占整棵树节点的一半,倒数第二层占25%,倒数第三层占12.5%。也就是说,后三层就占了整颗二叉树节点的87.5%。

那么,我们可以在递归时加一个限制条件:当递归时,区间剩余元素少于8个时(可自定义剩余个数),改为使用插入排序来排序这些小区间。

hoare版本最终代码:

int GetMidIndex(int* arr, int left, int right)//三数取中
{
	int mid = left + (right-left) / 2;
	if (arr[left] >= arr[right])
	{
		if (arr[left] > arr[mid])
		{
			if (arr[mid] >= arr[right])
				return mid;
			else
				return right;
		}
		else
			return left;
	}
	else
	{
		if (arr[right] > arr[mid])
		{
			if (arr[mid] >= arr[left])
				return mid;
			else
				return left;
		}
		else
			return right;
	}
}
//[left,right]
int PartSort(int* arr, int left, int right)//单趟排完不是有序,只是key左边比key小,右边比key大
{
	int mid = GetMidIndex(arr, left, right);
	Swap(&arr[mid], &arr[left]);
	int keyi = left;//选left做key,keyi是下标
	while (left < right)
	{
		//我们选了left做key,那么右边先走。反之左边先走。
		while (left < right && arr[right] >= arr[keyi])//R找小
		{
			--right;
		}
		while (left < right && arr[left] <= arr[keyi])//L找大
		{
			++left;
		}
		Swap(&arr[left], &arr[right]);
	}
	int meet = left;//meet是left和right的相遇点下标
	Swap(&arr[meet], &arr[keyi]);
	return meet;
}
//[begin,end]
void QuickSort(int* arr, int begin,int end)//递归快排
{
	if (begin >= end)
		return;
	if (end - begin <= 8)//小区间优化
	{
		InsertSort(arr+begin, end -begin + 1);//插入排序O(N^2)
		return;
	}
	else
	{
		int keyi = PartSort3(arr, begin, end);
		//[begin,keyi-1] key [keyi+1,end]
		QuickSort(arr, begin, keyi - 1);//快排
		QuickSort(arr, keyi + 1, end);//快排
	}
}

2、挖坑法

2.1挖坑法单趟排序动图

【算法】常用排序算法

2.2挖坑法思想

三数取中后,我们把数组最左边当成坑,并记录这个位置的值key(动态中坑的初始下标是0,key是6)

同样的,右边小人先走,找到比key小的数字停下来,将脚下位置的数字填入坑中,同时,脚下变成了新的坑。

左边小人再行动,找到比key大的数字停下来,将脚下位置的数字填入坑中,同时,脚下变成新的坑。

循环上述过程,直到两小人相遇。相遇时,脚下必定是坑,那么把刚开始的key填入这个坑中。完成了单趟排序。

挖坑法同样可以适用于三数取中和小区间优化。

2.3挖坑法代码

//挖坑法
int PartSort(int* arr, int left, int right)
{
	int mid = GetMidIndex(arr, left, right);
	Swap(&arr[mid], &arr[left]);
	int key = arr[left];//选left做key,key是值
	int hole = left;//坑
	while (left < right)
	{
		while (left < right && arr[right] >= key)//右边找小,填到左边坑
		{
			--right;
		}
		arr[hole] = arr[right];
		hole = right;
		while (left < right && arr[left] <= key)//左边找小,填到右边坑
		{
			++left;
		}
		arr[hole] = arr[left];
		hole = left;
	}
	arr[hole] = key;//最后把key放到坑里
	return hole;//返回最后的坑位
}
//[begin,end]
void QuickSort(int* arr, int begin,int end)//递归快排
{
	if (begin >= end)
		return;
	if (end - begin <= 8)//小区间优化
	{
		InsertSort(arr+begin, end -begin + 1);//插入排序O(N^2)
		return;
	}
	else
	{
		int keyi = PartSort3(arr, begin, end);
		//[begin,keyi-1] key [keyi+1,end]
		QuickSort(arr, begin, keyi - 1);//快排
		QuickSort(arr, keyi + 1, end);//快排
	}
}

3、前后指针法

3.1前后指针法单趟排序动图

【算法】常用排序算法

3.2前后指针法思想

prev指向初始位置,cur指向prev的下一个位置

prev先走,cur后走,当cur遇到比key大的值,prev停下,cur继续走,直到cur遇到比key小的数,prev再往前走,prev向前走完后,交换cur与prev的值

循环上述过程,直到cur>right,交换keyi和prev的值

动图看起来就像是prev在后面推着key大的数字往前走,当然该方法也要用三数取中和小区间优化。

3.3前后指针法代码

int PartSort(int* arr, int left, int right)
{
	int mid = GetMidIndex(arr, left, right);
	Swap(&arr[mid], &arr[left]);
	int keyi = left;//选left做key,keyi是下标
	int prev = left, cur = prev + 1;
	while (cur <= right)
	{
		if (arr[cur] < arr[keyi] && ++prev!=cur)
		{
			Swap(&arr[cur], &arr[prev]);
		}
		++cur;
	}
	Swap(&arr[prev], &arr[keyi]);
	return prev;
}
//[begin,end]
void QuickSort(int* arr, int begin,int end)//快排
{
	if (begin >= end)
		return;
	int keyi = PartSort(arr, begin, end);
	//[begin,keyi-1] key [keyi+1,end]
	if (end - begin <= 8)//小区间优化
	{
		InsertSort(arr+begin, end -begin + 1);//插入排序O(N^2)
		return;
	}
	else
	{
		QuickSort(arr, begin, keyi - 1);//快排
		QuickSort(arr, keyi + 1, end);//快排
	}
}

4、快排的非递归方法

【算法】常用排序算法

4.1非递归的思想

从递归的方法可以看出,在第一次选出keyi时,可以对左右区间进行递归操作,重复选出keyi,不断对小区间进行排序,直至有序。同样的,非递归方法使用栈来模拟递归的过程,每次将左右区间的下标压入栈中,就执行一次该区间的单趟排序。直到栈空,说明数组已经有序。

4.2非递归代码

void NonFQuickSort(int* arr, 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(arr, left, right);//keyi是下标,单趟排序
		//[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);//销毁
}

七、归并排序

1、归并排序的递归方法

1.1归并排序的思想

现在想对一组无序数组排序,那么将这个数组均分成左右两个部分,只要左区间有序,右区间有序,那就可以借助额外的空间,将左右两个数组中小的数不断尾插,形成有序,最后将额外空间中的数据拷贝回原数组即可。那么左右区间怎么才能有序呢?通过递归的方法,对左右区间不断均分至区间内仅剩一个数,开始归并。

归并的缺点在于需要额外O(N)的空间,常用于解决磁盘的外排序。

【算法】常用排序算法

1.2归并排序代码

void _MergeSort(int* arr, int begin, int end, int* tmp)
{
	if (begin >= end)
		return;
	int mid = begin + (end - begin) / 2;//将左右区间二分
	//[begin,mid][mid+1,end]
	_MergeSort(arr, begin, mid, tmp);
	_MergeSort(arr, mid+1, end, tmp);
	//升序归并,取小的尾插,重新定义起始位置,防止begin和end被改变
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int i = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (arr[begin1] <= arr[begin2])
		{
			tmp[i++] = arr[begin1++];
		}
		else
		{
			tmp[i++] = arr[begin2++];
		}
	}
	//左右区间必定有一个还没有尾插完
	while (begin1 <= end1)
	{
		tmp[i++] = arr[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = arr[begin2++];
	}
	//将tmp部分区域数据拷贝回原数组
	memcpy(arr + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
void MergeSort(int* arr, int size)
{
	int* tmp = (int*)malloc(sizeof(int) * size);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	_MergeSort(arr, 0, size - 1, tmp);
	free(tmp);
}

2、归并排序的非递归

2.1归并排序的非递归思想

因为递归版本是将数组内元素不断均分,直至区间内仅剩一个元素时,开始归并。那么非递归版本直接一一归并···两两归并····四四归并······直至整体有序。注意分类讨论边界问题:begin1是不可能越界的,当end1和begin2越界时,直接break即可;当end2越界时,修正end2=size-1继续进行归并。

2.2归并排序的非递归代码

void MergeSortNonR(int* arr, int size)
{
	int* tmp = (int*)malloc(sizeof(int) * size);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	int gap = 1;
	while (gap < size)
	{
		for (int j = 0; j < size; j += 2 * gap)
		{
			int begin1 = j, end1 = j + gap - 1;
			int begin2 = j + gap, end2 = j + 2 * gap - 1;
			//判断边界
			if (end1 >= size)
			{
				break;
			}
			if (begin2 >= size)
			{
				break;
			}
			if (end2 >= size)//修正end2,继续归并
			{
				end2 = size - 1;
			}
			int i = j;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (arr[begin1] <= arr[begin2])
				{
					tmp[i++] = arr[begin1++];
				}
				else
				{
					tmp[i++] = arr[begin2++];
				}
			}
			//还剩一个区间没有尾插完
			while (begin1 <= end1)
			{
				tmp[i++] = arr[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[i++] = arr[begin2++];
			}
			//将tmp数组中的数据拷贝回原数组
			memcpy(arr + j, tmp + j, sizeof(int) *(end2-j+1));//end2-j-1千万不可以写成2*gap,因为当end2被修正时没救不等于2*gap了
		}
		gap *= 2;;
	}
	free(tmp);
	tmp = NULL;
}

八、计数排序

1、计数排序的思想

计数排序适用于排序数组极差小的数据。此时range忽略,时间复杂度O(N)的话,也是一个非常强大的排序。

1、找出数组中的最大值和最小值,求出range=max-min+1

2、开辟range个空间并对这块区域初始化为0

3、通过相对映射对每个数出现的频次计数(同时数据已经被排序)

4、根据频次覆盖写入数据至原数组

5、free临时空间

【算法】常用排序算法文章来源地址https://www.toymoban.com/news/detail-434471.html

2、计数排序代码

void CountSort(int* arr, int size)//计数排序,时间O(N+range),空间O(range)
{
	int min = arr[0], max = arr[0];
	//遍历找出最大、最小
	for (int i = 0; i < size; ++i)
	{
		if (arr[i] < min)
			min = arr[i];
		if (arr[i] > max)
			max = arr[i];
	}
	//malloc一个相对映射数组
	int range = max - min + 1;//malloc数组的元素个数
	int* Count = (int*)malloc(sizeof(int) * range);
	if (Count == NULL)
	{
		perror("malloc fail:");
		return;
	}
	memset(Count,0, sizeof(int) * range);
	//相对映射计数
	for (int i = 0; i < size; ++i)
	{
		++Count[arr[i] - min];
	}
	//将映射数据覆盖至原数组
	int j = 0;
	for (int i = 0; i < range; ++i)
	{
		while (Count[i]--)
		{
			arr[j++] = i + min;
		}
	}
	//释放malloc的空间
	free(Count);
}

到了这里,关于【算法】常用排序算法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 安可目录入围产品名单(安可目录入围产品名单 服务器)

     2022-12-15  看点  20 推广 2021信创产品名录有: 1、中孚信息(300659): 公司是专注于信息安全领域的高新技术企业,主营业务为信息安全产品研发,生产销售及信息安全服务。公司主要产品及服务包含信息安全保密产品,商用密码产品,信息安全服务。 2、中科曙光(60

    2024年02月04日
    浏览(67)
  • 阿里云产品试用系列-云服务器 ECS

    阿里云为个人开发者或者企业用户提供云产品的免费试用,本文主要描述ECS云服务器试用体验。 如上所示,在阿里云官方网站中,可使用云服务器ECS构建应用服务。 如上所示,在阿里云控制台中,可以显示成功定制免费使用阿里云ECS云服务器。 如上所示,使用阿里云提供登

    2024年02月08日
    浏览(55)
  • 建站为什么需要服务器?(Web服务器与计算机对比)

    ​ 在部署网站时,底层基础设施在确保最佳性能、可靠性和可扩展性方面发挥着至关重要的作用。虽然大多数人都熟悉个人计算机 (PC) 作为日常工作和个人任务的设备,但 PC 和 Web 服务器之间存在显著差异。在这篇文章中,我们将讨论这些差异是什么,并解释为什么服务器对

    2024年01月20日
    浏览(69)
  • 用服务器搭建网站需要做什么

    网站建设是一个广义的术语,涵盖了许多不同的技能和学科中所使用的生产和维护的网站。不同领域的网页设计,网页图形设计,界面设计,创作,其中包括标准化的代码和专有软件,用户体验设计和搜索引擎优化。许多人常常会分为若干个工作小组,负责网站不同方面的设

    2024年02月13日
    浏览(49)
  • 搭建web服务器需要哪些步骤?

       首先跟大家简单普及一下什么是web服务器? Web服务器也称为WWW(WORLD WIDE WEB)服务器 , 一般指网站服务器,是指驻留于因特网上某种类型计算机的程序 。 WEB服务器主要功能是提供网上信息浏览服务 , 可以处理浏览器等Web客户端的请求并返回相应响应,也可以放置网站文件

    2024年02月06日
    浏览(37)
  • 搭建gitlab服务器需要哪些端口号

    GitLab是一个开源的版本控制系统,类似于GitHub,但可以在私有服务器上搭建。搭建GitLab服务器的过程中需要配置一些端口号,以便GitLab的各种服务能够正常运行。本文将向您介绍搭建GitLab服务器所需要的端口号。 HTTP/S端口:80/443 GitLab通过HTTP/S协议进行通信,因此需要开放H

    2024年02月07日
    浏览(40)
  • 高防服务器与云防产品都适用哪些情况

    高防服务器与云防护产品(如高防IP,高防CDN)都可以对DDOS、CC等攻击进行防护,在现如今的互联网市场上,不法分子经常会通过DDOS、CC等攻击服务器,干扰业务正常运行,以此来获得利益。 高防服务器是以机房防火墙设备,以对应的流量进行硬抗。通过DDOS硬件防火墙对异常

    2024年02月10日
    浏览(41)
  • 美国大带宽服务器租用需要考虑的因素

    很多用户会选择租用服务器,那么美国大带宽服务器租用时应该考虑哪些因素呢?小编为您整理发布美国大带宽服务器租用考虑因素。 在美国租用大带宽服务器时,您可以考虑以下几个因素: 1. **性能配置**:选择服务器时,应确保其具有高性能的配置,如100% Intel内核和固态

    2024年01月24日
    浏览(44)
  • 阿里云服务器需要安装杀毒软件吗?

      阿里云服务器需要安装杀毒软件吗?   阿里云服务器本身自带5G的防御,能够有效防御病毒的。 目前的云服务器机房都有专业的人员定制对设备进行检测,因此在硬件的防护方面是有一定的保证的。但是在其他方面就不一定了,因为病毒的传播方式有很多,除了黑客入侵等

    2024年02月11日
    浏览(46)
  • 电子商务类网站需要什么配置的服务器?

    随着电子商务的迅猛发展,越来越多的企业和创业者选择在互联网上开设自己的电商网站。为了确保电商网站能够高效运行,给用户提供良好的体验,选择合适的服务器配置至关重要。今天飞飞将和你分享电子商务类网站所需的服务器配置,希望可以帮助到您~ 电商网站需要

    2024年02月12日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包