09-排序1 排序（C）

news2024/11/13 8:12:59

这一节，测试各类排序算法的运行速度（没有基数排序（桶）

其实在实际学习中，还是有意义的

给定 n 个（长整型范围内的）整数，要求输出从小到大排序后的结果。

本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下：

  • 数据1：只有1个元素；
  • 数据2：11个不相同的整数，测试基本正确性；
  • 数据3：10^{3}个随机整数；
  • 数据4：10^{4}个随机整数；
  • 数据5：10^{5}个随机整数；
  • 数据6：10^{5}个顺序整数；
  • 数据7：10^{5}个逆序整数；
  • 数据8：10^{5}个基本有序的整数；
  • 数据9：10^{5}个随机正整数，每个数字不超过1000。

    输入格式:

    输入第一行给出正整数 n（≤105），随后一行给出 n 个（长整型范围内的）整数，其间以空格分隔。

    输出格式:

    在一行中输出从小到大排序后的结果，数字间以 1 个空格分隔，行末不得有多余空格。

    输入样例:

    11
4 981 10 -17 0 -20 29 50 8 43 -5

    输出样例:

    -20 -17 -5 0 4 8 10 29 43 50 981

 

 //冒泡排序

//冒泡排序
void Bubble_Sort(int *a, int Num)
{
	int Temp, i, j;
	int flag;
	for(i = 0; i < Num; i++){
		flag = 0;
		for(j = 0; j < Num - 1; j++){
			if(a[j] > a[j + 1]){
				Temp = a[j];
				a[j] = a[j+1];
				a[j+1] = Temp;
				flag = 1;
			}
		}
		if(!flag){
			break;
		}
	}	
}
测试点提示内存(KB)用时(ms)结果得分
03522

答案正确

1 / 1
13322

答案正确

10 / 10
23563

答案正确

2 / 2
3276192

答案正确

2 / 2
46883000

运行超时

0 / 2
5120017

答案正确

2 / 2
66643000

运行超时

0 / 2
71296432

答案正确

2 / 2
86683000

运行超时

0 / 2

插入排序

void Insert_Sort(int *a, int Num)
{
	int i, j;
	int Temp;
	for(i = 1; i < Num; i++){
		Temp = a[i];
		for(j = i; j > 0 && a[j-1] > Temp; j--){
			a[j] = a[j-1];
		}
		a[j] = Temp;
	}
}
测试点提示内存(KB)用时(ms)结果得分
03601

答案正确

1 / 1
11761

答案正确

10 / 10
23562

答案正确

2 / 2
342416

答案正确

2 / 2
411441254

答案正确

2 / 2
5120017

答案正确

2 / 2
611762493

答案正确

2 / 2
7120829

答案正确

2 / 2
810481260

答案正确

2 / 2

 希尔排序_普通版

void Shell_Sort(int *a, int Num)
{
	int D, P, i;
	int Temp;
	for(D = Num / 2; D > 0; D /= 2){
		for(P = D; P < Num; P++){
			Temp = a[P];
			for(i = P; i >= D && a[i - D] > Temp; i -= D){
				a[i] = a[i - D];
			}
			a[i] = Temp;
		}
	}
}
测试点提示内存(KB)用时(ms)结果得分
01762

答案正确

1 / 1
13082

答案正确

10 / 10
23362

答案正确

2 / 2
34124

答案正确

2 / 2
4113230

答案正确

2 / 2
5114421

答案正确

2 / 2
6133222

答案正确

2 / 2
7120422

答案正确

2 / 2
8107627

答案正确

2 / 2

  希尔排序_Hibbard版,就是将增量换成，由2^i 到 2^i-1;达到相邻元素互质，保证有效间隔。

Tworst= O( N^3/2) , Tavg = O ( N^5/4);

void Shell_Sort_Hibbard(int *a, int Num)
{
	int H, D, P, i;
	int Temp;
	int Hibbard[] = {131071, 65535, 32767, 16383, 8191, 4095, 2047, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1};
	for(H = 0; Hibbard[H] >= Num; H++);
	
	for(D = Hibbard[H]; D > 0; D = Hibbard[++H]){
		for(P = D; P < Num; P++){
			Temp = a[P];
			for(i = P; i >= D && a[i - D] > Temp; i -= D){
				a[i] = a[i - D];
			}
			a[i] = Temp;
		}
	}
}

/*
num1[0] == 0
num1[1] == 1
num1[2] == 3
num1[3] == 7
num1[4] == 15
num1[5] == 31
num1[6] == 63
num1[7] == 127
num1[8] == 255
num1[9] == 511
num1[10] == 1023
num1[11] == 2047
num1[12] == 4095
num1[13] == 8191
num1[14] == 16383
num1[15] == 32767
num1[16] == 65535
num1[17] == 131071
num1[18] == 262143
num1[19] == 524287

*/
测试点提示内存(KB)用时(ms)结果得分
01721

答案正确

1 / 1
13161

答案正确

10 / 10
21802

答案正确

2 / 2
34404

答案正确

2 / 2
4115230

答案正确

2 / 2
5120020

答案正确

2 / 2
6118020

答案正确

2 / 2
7114820

答案正确

2 / 2
8104827

答案正确

2 / 2

   希尔排序_Sedgewick版,这个增量很厉害，9 * 4^i - 9 * 2^i + 1,或 4^i -3 *2^i +1;

Tavg = O ( N^7/6 )，Tworst = O ( N^4/3)

void Shell_Sort_Sedgewick(int *a, int Num)
{
	int Si, D, P, i;
	int Temp;
	int Sedgewick[] = {146305, 64769, 36289, 16001, 8929, 3905, 2161, 929, 505, 209, 109, 41, 19, 5, 1, 0};
	for(Si = 0; Sedgewick[Si] >= Num; Si++);
	
	for(D = Sedgewick[Si]; D > 0; D = Sedgewick[++Si]){
		for(P = D; P < Num; P++){
			Temp = a[P];
			for(i = P; i >= D && a[i - D] > Temp; i -= D){
				a[i] = a[i - D];
			}
			a[i] = Temp;
		}
	}
}

//有同学问，这一序列如何来的，其实是综合两个函数
// 具体的数学逻辑我也不懂
#include <stdio.h>
#include <math.h>

int main()
{
	int i;
	double num1;
	double num2;
	for(i = 0; i < 10; i++){
		num1 = 9.0 * pow(4, i) - 9.0 * pow(2, i) + 1;
		printf("num1[%d] == %.lf\n", i, num1);
	}
	for(i = 0; i < 10; i++){
		num2 = pow(4, i) - 3.0 * pow(2, i) + 1;
		printf("num2[%d] == %.lf\n", i, num2);
	}	
    return 0;
}
/* 这是运行结果：
num1[0] == 1
num1[1] == 19
num1[2] == 109
num1[3] == 505
num1[4] == 2161
num1[5] == 8929
num1[6] == 36289
num1[7] == 146305
num1[8] == 587521
num1[9] == 2354689
num2[0] == -1
num2[1] == -1
num2[2] == 5
num2[3] == 41
num2[4] == 209
num2[5] == 929
num2[6] == 3905
num2[7] == 16001
num2[8] == 64769
num2[9] == 260609
很明显，Sedgewick函数便是如此构成的，
*/
测试点提示内存(KB)用时(ms)结果得分
01722

答案正确

1 / 1
13041

答案正确

10 / 10
23602

答案正确

2 / 2
34324

答案正确

2 / 2
4119628

答案正确

2 / 2
5124020

答案正确

2 / 2
6114820

答案正确

2 / 2
7120020

答案正确

2 / 2
8107225

答案正确

2 / 2

#include<stdio.h>
#include<stdlib.h>

void Bubble_Sort(int *a, int Num); //冒泡排序
void Insert_Sort(int *a, int Num); //插入排序
void Shell_Sort(int *a, int Num); //希尔排序
void Shell_Sort_Hibbard(int *a, int Num); //希尔排序
void Shell_Sort_Sedgewick(int *a, int Num); //希尔排序
//void Selection_Sort(int *a, int Num);// 选择排序
//void Heap_Sort(); //堆排序
//void Merge_Sort(); //归并排序
//void Quick_Sort(); //快速排序
//void Table_Sort(); //表排序
//void Radix_Sort(); //基数排序, 桶排序

int main()
{
	int Num, i;
	int *a;
	scanf("%d", &Num);
	a = (int *)malloc(sizeof(int) * Num);
	for(i = 0; i < Num; i++){
		scanf("%d", &a[i]);
	}
//	Bubble_Sort(a, Num);
//	Insert_Sort(a, Num);
//	Shell_Sort(a, Num);
//	Shell_Sort_Hibbard(a, Num);
//	Shell_Sort_Sedgewick(a, Num);
	Selection_Sort(a, Num);
	for(i = 0; i < Num - 1; i++){
		printf("%d ", a[i]);
	}
	printf("%d\n", a[i]);
	return 0;
}

void Bubble_Sort(int *a, int Num)
{
	int Temp, i, j;
	int flag;
	for(i = 0; i < Num; i++){
		flag = 0;
		for(j = 0; j < Num - 1; j++){
			if(a[j] > a[j + 1]){
				Temp = a[j];
				a[j] = a[j+1];
				a[j+1] = Temp;
				flag = 1;
			}
		}
		if(!flag){
			break;
		}
	}	
}
void Insert_Sort(int *a, int Num)
{
	int i, j;
	int Temp;
	for(i = 1; i < Num; i++){
		Temp = a[i];
		for(j = i; j > 0 && a[j-1] > Temp; j--){
			a[j] = a[j-1];
		}
		a[j] = Temp;
	}
}

void Shell_Sort(int *a, int Num)
{
	int D, P, i;
	int Temp;
	for(D = Num / 2; D > 0; D /= 2){
		for(P = D; P < Num; P++){
			Temp = a[P];
			for(i = P; i >= D && a[i - D] > Temp; i -= D){
				a[i] = a[i - D];
			}
			a[i] = Temp;
		}
	}
}
void Shell_Sort_Hibbard(int *a, int Num)
{
	int H, D, P, i;
	int Temp;
	int Hibbard[] = {131071, 65535, 32767, 16383, 8191, 4095, 2047, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1};
	for(H = 0; Hibbard[H] >= Num; H++);
	
	for(D = Hibbard[H]; D > 0; D = Hibbard[++H]){
		for(P = D; P < Num; P++){
			Temp = a[P];
			for(i = P; i >= D && a[i - D] > Temp; i -= D){
				a[i] = a[i - D];
			}
			a[i] = Temp;
		}
	}
}

void Shell_Sort_Sedgewick(int *a, int Num)
{
	int Si, D, P, i;
	int Temp;
	int Sedgewick[] = {146305, 64769, 36289, 16001, 8929, 3905, 2161, 929, 505, 209, 109, 41, 19, 5, 1, 0};
	for(Si = 0; Sedgewick[Si] >= Num; Si++);
	
	for(D = Sedgewick[Si]; D > 0; D = Sedgewick[++Si]){
		for(P = D; P < Num; P++){
			Temp = a[P];
			for(i = P; i >= D && a[i - D] > Temp; i -= D){
				a[i] = a[i - D];
			}
			a[i] = Temp;
		}
	}
}
void Selection_Sort(int *a, int Num)
{
	int i,k, Min;
	int Temp, MinValue;
	for(k = 0; k < Num; k++){
		MinValue = 21000000;
		for(i = k; i < Num; i++){
			if(a[i] < MinValue){
				MinValue = a[i];
				Min = i;
			}
		}
		Temp = a[k];
		a[k] = a[Min];
		a[Min] = Temp;
	}
}
选择排序，依旧稳定发挥 
void Selection_Sort(int *a, int Num)
{
	int i,k, Min;
	int Temp, MinValue;
	for(k = 0; k < Num; k++){
		MinValue = 21000000;
		for(i = k; i < Num; i++){
			if(a[i] < MinValue){
				MinValue = a[i];
				Min = i;
			}
		}
		Temp = a[k];
		a[k] = a[Min];
		a[Min] = Temp;
	}
}
测试点提示内存(KB)用时(ms)结果得分
03041

答案正确

1 / 1
13041

答案正确

10 / 10
23082

答案正确

2 / 2
332055

答案正确

2 / 2
46323000

运行超时

0 / 2
56083000

运行超时

0 / 2
65603000

运行超时

0 / 2
76963000

运行超时

0 / 2
85523000

运行超时

0 / 2

 堆排序_简单版

测试点提示内存(KB)用时(ms)结果得分
0只有一个元素1803000

运行超时

0 / 1
11721

答案正确

10 / 10
23562

答案正确

2 / 2
34324

答案正确

2 / 2
4118027

答案正确

2 / 2
5126423

答案正确

2 / 2
6120423

答案正确

2 / 2
7122022

答案正确

2 / 2
8102026

答案正确

2 / 2
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>


typedef struct Heap *MinHeap;
struct Heap{
	int *data;
	int Size;
};
void Selection_Sort(int *a, int Num);// 选择排序
void Heap_Sort_Easy(int *a, int Num); //堆排序
void Swap(int *a, int *b);
MinHeap Creat_Heap(int *a, int N);
MinHeap Init_Heap(int N);
void Insert_Heap(MinHeap H, int data);
int Delete_Heap(MinHeap H);
bool IsEmpty(MinHeap H);

int main()
{
	int Num, i;
	int *a;
	scanf("%d", &Num);
	a = (int *)malloc(sizeof(int) * Num);
	for(i = 0; i < Num; i++){
		scanf("%d", &a[i]);
	}
//	Selection_Sort(a, Num);
	Heap_Sort_Easy(a, Num);
	for(i = 0; i < Num - 1; i++){
		printf("%d ", a[i]);
	}
	printf("%d\n", a[i]);
	free(a);
	return 0;
}

void Selection_Sort(int *a, int Num)
{
	int i,k, Min;
	int Temp, MinValue;
	for(k = 0; k < Num; k++){
		MinValue = 21000000;
		for(i = k; i < Num; i++){
			if(a[i] < MinValue){
				MinValue = a[i];
				Min = i;
			}
		}
		Swap(&a[k], &a[Min]);
	}
}
void Heap_Sort_Easy(int *a, int Num)
{
	MinHeap H;
//	if(Num == 1){
//		return ;
//	}
	H = Creat_Heap(a, Num);
	for(int i = 0; i < Num; i++){
		a[i] = Delete_Heap(H);
	}
	free(H ->data);
	free(H);
}
void Swap(int *a, int *b)
{
	int Temp;
	Temp = *a;
	*a = *b;
	*b = Temp;
}
MinHeap Creat_Heap(int *a, int N)
{
	MinHeap H;
	H = Init_Heap(N);
	for(int i = 0; i < N; i++){
		Insert_Heap(H, a[i]);
	}
	return H;
}
MinHeap Init_Heap(int N)
{
	MinHeap H;
	H = (MinHeap)malloc(sizeof(struct Heap));
	H ->data = (int*)malloc(sizeof(int) * (N + 1));
	H ->data[0] = -2100000;
	H ->Size = 0;
	return H;
}
void Insert_Heap(MinHeap H, int data)
{
	int i;
	i = ++H ->Size;
	for(; data < H ->data[i/2]; i /=2){
		H ->data[i] = H ->data[i/2];
	}
	H ->data[i] = data;
}
int Delete_Heap(MinHeap H)
{
	int Parent, Child, i;
	int Min, Temp;
	if(IsEmpty(H)){
		printf("Is error!\n");
		return H ->data[0];
	}
	Min = H ->data[1];
	Temp = H ->data[H ->Size --];
	for(Parent = 1; Parent * 2 <= H ->Size; Parent = Child){
		Child = Parent * 2;
		if(H ->data[Child] > H ->data[Child + 1]){
			Child++;
		}
		if(Temp <= H ->data[Child]){
			break;
		}else{
			H ->data[Parent] = H ->data[Child];
		}
	}
	H ->data[Parent] = Temp;
	return Min;
}
bool IsEmpty(MinHeap H)
{
	return (H ->Size == 0);
}

  堆排序_进阶版

测试点提示内存(KB)用时(ms)结果得分
01682

答案正确

1 / 1
13041

答案正确

10 / 10
23682

答案正确

2 / 2
34324

答案正确

2 / 2
4118828

答案正确

2 / 2
5127223

答案正确

2 / 2
6127623

答案正确

2 / 2
7115222

答案正确

2 / 2
894426

答案正确

2 / 2
#include<stdio.h>
#include<stdlib.h>

void Heap_Sort_Good(int *a, int Num); //堆排序
void Swap(int *a, int *b);
void PercDown(int *a, int index, int Num);

int main()
{
	int Num, i;
	int *a;
	scanf("%d", &Num);
	a = (int *)malloc(sizeof(int) * Num);
	for(i = 0; i < Num; i++){
		scanf("%d", &a[i]);
	}
	Heap_Sort_Good(a, Num);
	for(i = 0; i < Num - 1; i++){
		printf("%d ", a[i]);
	}
	printf("%d\n", a[i]);
	return 0;
}

void Heap_Sort_Good(int *a, int Num)
{
	int i, j;
	for(i = Num / 2 - 1; i >= 0;i--){
		PercDown(a, i, Num);
	}
	for(i = Num - 1; i > 0; i--){
		Swap(&a[0], &a[i]);
		PercDown(a, 0, i);
	}
}
void PercDown(int *a, int index, int Num)
{
	int Parent, Child;
	int Value;
	Value = a[index];
	for(Parent = index; (Parent * 2 + 1) < Num; Parent = Child){
		Child  = Parent * 2 + 1;
		if((Child != Num - 1) && a[Child] < a[Child + 1]){
			Child++;
		}
		if(Value >= a[Child]){
			break;
		}else{
			a[Parent] = a[Child];
		}
	}
	a[Parent] = Value;
}

void Swap(int *a, int *b)
{
	int Temp;
	Temp = *a;
	*a = *b;
	*b = Temp;
}

 归并排序递归版

测试点提示内存(KB)用时(ms)结果得分
03642

答案正确

1 / 1
13362

答案正确

10 / 10
23682

答案正确

2 / 2
34645

答案正确

2 / 2
4117628

答案正确

2 / 2
5129221

答案正确

2 / 2
6118424

答案正确

2 / 2
7126421

答案正确

2 / 2
8106425

答案正确

2 / 2
#include<stdio.h>
#include<stdlib.h>

//归并排序
void Merge_Sort(int *a, int Num);
void Msort(int *a, int *t, int LeftStart, int RightEnd);
void Merge(int *a, int *t, int LeftStart, int RightStart, int RightEnd);

int main()
{
	int Num, i;
	int *a;
	scanf("%d", &Num);
	a = (int *)malloc(sizeof(int) * Num);
	for(i = 0; i < Num; i++){
		scanf("%d", &a[i]);
	}
	Merge_Sort(a, Num);
	for(i = 0; i < Num - 1; i++){
		printf("%d ", a[i]);
	}
	printf("%d\n", a[i]);
	return 0;
}

void Merge_Sort(int *a, int Num)
{
	int *t;
	t = (int *)malloc(sizeof(int) * Num);
	if(t != NULL){
		Msort(a, t, 0, Num - 1);
		free(t);
	}
}
void Msort(int *a, int *t, int LeftStart, int RightEnd)
{
	int center;
	if(LeftStart < RightEnd){
		center = ((LeftStart + RightEnd) / 2);
		Msort(a, t, LeftStart, center);
		Msort(a, t, center + 1, RightEnd);
		Merge(a, t, LeftStart, center + 1, RightEnd);
		
	}
}
void Merge(int *a, int *t, int LeftStart, int RightStart, int RightEnd)
{
	int LeftEnd, Nums;
	int Temp;
	LeftEnd = RightStart - 1;
	Temp = LeftStart;
	Nums = RightEnd - LeftStart + 1;
	while((LeftStart <= LeftEnd) && (RightStart <= RightEnd)){
		if(a[LeftStart] <= a[RightStart]){
			t[Temp++] = a[LeftStart++];
		}else{
			t[Temp++] = a[RightStart++];
		}
	}
	while(LeftStart <= LeftEnd){
		t[Temp++] = a[LeftStart++];
	}
	while(RightStart <= RightEnd){
		t[Temp++] = a[RightStart++];
	}
	for(int i = 0; i < Nums; i++, RightEnd--){
		a[RightEnd] = t[RightEnd];
	}
}

  归并排序-非递归版

测试点提示内存(KB)用时(ms)结果得分
01762

答案正确

1 / 1
11802

答案正确

10 / 10
23562

答案正确

2 / 2
34325

答案正确

2 / 2
4130026

答案正确

2 / 2
5129620

答案正确

2 / 2
6114820

答案正确

2 / 2
7113619

答案正确

2 / 2
8106424

答案正确

2 / 2
#include<stdio.h>
#include<stdlib.h>

//归并排序
void Merge_Sort(int *a, int Num);
void Msort(int *a, int *t, int Num, int Length);
void Merge(int *a, int *t, int LeftStart, int RightStart, int RightEnd);

int main()
{
	int Num, i;
	int *a;
	scanf("%d", &Num);
	a = (int *)malloc(sizeof(int) * Num);
	for(i = 0; i < Num; i++){
		scanf("%d", &a[i]);
	}
	Merge_Sort(a, Num);
	for(i = 0; i < Num - 1; i++){
		printf("%d ", a[i]);
	}
	printf("%d\n", a[i]);
	return 0;
}

void Merge_Sort(int *a, int Num)
{
	int *t;
	int Length = 1;
	t = (int *)malloc(sizeof(int) * Num);
	if(t != NULL){
		while(Length < Num){
			Msort(a, t, Num, Length);
			Length *= 2;
			Msort(t, a, Num, Length);
			Length *= 2;
		}
		free(t);
	}
}
void Msort(int *a, int *t, int Num, int Length)
{
	int i, j;
	for(i = 0; i <= (Num - 2 * Length); i += 2 * Length){
		Merge(a, t, i, i + Length, (i + 2 * Length) - 1);
	}
	if(i + Length < Num){
		Merge(a, t, i, i + Length, Num - 1);
	}else{
		for(j = i; j < Num; j++){
			t[j] = a[j];
		}
	}
}
void Merge(int *a, int *t, int LeftStart, int RightStart, int RightEnd)
{
	int LeftEnd, Nums;
	int Temp;
	LeftEnd = RightStart - 1;
	Temp = LeftStart;
	Nums = RightEnd - LeftStart + 1;
	while((LeftStart <= LeftEnd) && (RightStart <= RightEnd)){
		if(a[LeftStart] <= a[RightStart]){
			t[Temp++] = a[LeftStart++];
		}else{
			t[Temp++] = a[RightStart++];
		}
	}
	while(LeftStart <= LeftEnd){
		t[Temp++] = a[LeftStart++];
	}
	while(RightStart <= RightEnd){
		t[Temp++] = a[RightStart++];
	}
}

 快速排序_自定义版

测试点提示内存(KB)用时(ms)结果得分
03602

答案正确

1 / 1
13562

答案正确

10 / 10
22722

答案正确

2 / 2
33445

答案正确

2 / 2
4114431

答案正确

2 / 2
5120818

答案正确

2 / 2
6129219

答案正确

2 / 2
7120419

答案正确

2 / 2
894428

答案正确

2 / 2
#include<stdio.h>
#include<stdlib.h>

//归并排序

void Swap(int *a, int *b);
int Median3(int *a, int Left, int Right);
void Qsort(int *a, int Left, int Right);
void Quick_Sort(int *a, int Num);
void Insert_Sort(int *a, int Num);

int main()
{
	int Num, i;
	int *a;
	scanf("%d", &Num);
	a = (int *)malloc(sizeof(int) * Num);
	for(i = 0; i < Num; i++){
		scanf("%d", &a[i]);
	}
	Quick_Sort(a, Num);
	for(i = 0; i < Num - 1; i++){
		printf("%d ", a[i]);
	}
	printf("%d\n", a[i]);
	return 0;
}
int Median3(int *a, int Left, int Right)
{
	int Center = (Left + Right)/2;
	if(a[Left] > a[Center]){
		Swap(&a[Left], &a[Center]);
	}
	if(a[Left] > a[Right]){
		Swap(&a[Left], &a[Right]);
	}
	if(a[Center] > a[Right]){
		Swap(&a[Center], &a[Right]);
	}
	Swap(&a[Center], &a[Right - 1]);
	return a[Right - 1];
}
void Qsort(int *a, int Left, int Right)
{
	int Pivot, Cutoff, i, j; 
	Cutoff = 1000;
	if(Cutoff < Right - Left){
		Pivot = Median3(a, Left, Right);
		i = Left; j = Right-1;
		while(1){
			while(a[++i] < Pivot);
			while(a[--j] > Pivot);
			if(i < j){
				Swap(&a[i], &a[j]);
			}else{
				break;
			}
		}
		Swap(&a[i], &a[Right - 1]);
		Qsort(a, Left, i - 1);
		Qsort(a, i + 1, Right);
	}
	else{
		Insert_Sort(a + Left, Right - Left + 1);
	}
}
void Quick_Sort(int *a, int Num)
{
	Qsort(a, 0, Num - 1);
}
void Swap(int *a, int *b)
{
	int Temp;
	Temp = *a;
	*a = *b;
	*b = Temp;
}
void Insert_Sort(int *a, int Num)
{
	int i, j;
	int Temp;
	for(i = 1; i < Num; i++){
		Temp = a[i];
		for(j = i; j > 0 && a[j-1] > Temp; j--){
			a[j] = a[j-1];
		}
		a[j] = Temp;
	}
}

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

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

相关文章

Unity Addressables 使用说明（三）构建内容（Build Content）

Unity Addressables 使用说明（三）构建内容（Build Content）

Build Content 【概述】Build Content 内容构建会处理 Addressables 组&#xff0c;生成内容目录&#xff08;content catalog&#xff09;、运行时设置以及包含你的资源的 AssetBundles。Addressables 使用这些文件在运行时加载内容。 你可以配置 Addressables 系统将 Addr…
阅读更多...
重磅！OpenAI正式发布博士水平的推理模型o1！附详细说明

重磅！OpenAI正式发布博士水平的推理模型o1！附详细说明

大家好&#xff0c;我是木易&#xff0c;一个持续关注AI领域的互联网技术产品经理&#xff0c;国内Top2本科&#xff0c;美国Top10 CS研究生&#xff0c;MBA。我坚信AI是普通人变强的“外挂”&#xff0c;所以创建了“AI信息Gap”这个公众号&#xff0c;专注于分享AI全维度知识…
阅读更多...
【android10】【binder】【2.servicemanager启动——全源码分析】

【android10】【binder】【2.servicemanager启动——全源码分析】

系列文章目录 可跳转到下面链接查看下表所有内容https://blog.csdn.net/handsomethefirst/article/details/138226266?spm1001.2014.3001.5501文章浏览阅读2次。系列文章大全https://blog.csdn.net/handsomethefirst/article/details/138226266?spm1001.2014.3001.5501 目录 …
阅读更多...
登山第九梯：稀疏点云实例分割——又快又准

登山第九梯：稀疏点云实例分割——又快又准

文章&#xff1a;Fast Range Image-Based Segmentation of Sparse 3D Laser Scans for Online Operation 代码&#xff1a;https://github.com/PRBonn/depth_clustering 1&#xff09;摘要 从 3D 距离数据中分割对象是移动机器人领域的一个重要主题。在动态环境中导航的机器人需…
阅读更多...
C51单片机-单按键输入识别，键盘消抖

C51单片机-单按键输入识别，键盘消抖

【实验目的】 独立按键的识别方法、键盘消抖等。 【实验现象】 每按一次独立键盘的S2键&#xff0c;与P1口相连的八个发光二极管中点亮的一个往下移动一位。 【实验说明】 关于按键去抖动的解释&#xff0c;我们在手动按键的时候&#xff0c;由于机械抖动或是其它一些非人为的因…
阅读更多...
NR PDSCH/PUSCH支持的maxMIMO layers

NR PDSCH/PUSCH支持的maxMIMO layers

这里不考虑UE支持的具体MIMO能力&#xff0c;仅仅讨论协议上定的maxMIMO layers。 PDSCH 根据上面38.331中的结构&#xff0c;PDSCH max MIMO layers 为8 layers&#xff0c;进行8 layers传输时 要enable two codewords&#xff0c;因为 one codeword只能支持4 layers传输&…
阅读更多...
【信创】Linux系统如何配置USB存储禁用及例外 _ 统信 _ 麒麟 _ 方德

【信创】Linux系统如何配置USB存储禁用及例外 _ 统信 _ 麒麟 _ 方德

原文链接&#xff1a;【信创】Linux系统如何配置USB存储禁用及例外 | 统信 | 麒麟 | 方德 Hello&#xff0c;大家好啊&#xff01;今天给大家带来一篇关于如何在Linux系统中配置USB存储禁用及例外的文章。禁用USB存储可以有效防止未经授权的人员从系统中复制数据或注入恶意软件…
阅读更多...
CSS——盒子模型

CSS——盒子模型

首先CSS将所有的元素都看成一个盒子 盒子的组成&#xff1a; content —— 内容区域padding —— 内边距&#xff08;边框与内容间的距离&#xff09;border —— 边框线margin —— 外边距&#xff08;盒子盒子间的距离&#xff09; 这里着重说一下margin: 水平方向&#xff…
阅读更多...
Kafka 基础与架构理解

Kafka 基础与架构理解

目录 前言 Kafka 基础概念 消息队列简介&#xff1a;Kafka 与传统消息队列&#xff08;如 RabbitMQ、ActiveMQ&#xff09;的对比 Kafka 的组件 Kafka 的工作原理&#xff1a;消息的生产、分发、消费流程 Kafka 系统架构 Kafka 的分布式架构设计 Leader-Follower 机制与…
阅读更多...
新品|瑞芯微RK3588工控机IPC8801适用AI算力、边缘计算、工业视觉

新品|瑞芯微RK3588工控机IPC8801适用AI算力、边缘计算、工业视觉

深圳触觉智能重磅推出旗舰级工控机IPC8801&#xff0c;搭载瑞芯微RK3588 ⼋核处理器&#xff1b;全铝紧凑机身、支持无风扇被动散热低噪音&#xff0c;确保设备在恶劣工业环境下稳定运行。 作为AI算力、边缘计算及工业视觉领域的高性能工控机&#xff0c;在国产化智能硬件与系统…
阅读更多...
Axure PR 9 标签 设计交互

Axure PR 9 标签 设计交互

大家好&#xff0c;我是大明同学。 这期内容&#xff0c;我们将深入探讨Axure中可编辑标签元件设计与交互技巧。 可移除标签元件 创建可移除标签所需的元件 1.打开一个新的 RP 文件并在画布上打开 Page 1。 2.在元件库中拖出一个文本框元件。 3.选中文本框元件&#xff0c…
阅读更多...
视频服务器：GB28181网络视频协议

视频服务器：GB28181网络视频协议

一、前言 某项目中需要集成视频管理平台&#xff0c;实现分布在各省公司的摄像及接入&#xff0c;对视频进行统一管理。本项目中视频管理平台采用GB/T28181实现的监控设备接入管理平台&#xff0c;支持在开放互联网和局域网对监控设备进行远程接入、远程管理、远程调阅、录像回…
阅读更多...
【文件包含】——日志文件注入

【文件包含】——日志文件注入

改变的确很难&#xff0c;但结果值得冒险 本文主要根据做题内容的总结&#xff0c;如有错误之处&#xff0c;还请各位师傅指正 一.伪协议的失效 当我们做到关于文件包含的题目时&#xff0c;常用思路其实就是使用伪协议&#xff08;php:filter,data,inpput等等&#xff09;执行…
阅读更多...
【NOI-题解】1407. 图像相似度1330. 求最大梯形的面积1384. 靶心数1398. 奇偶统计

【NOI-题解】1407. 图像相似度1330. 求最大梯形的面积1384. 靶心数1398. 奇偶统计

文章目录 一、前言二、问题问题&#xff1a;1407. 图像相似度问题&#xff1a;1330. 求最大梯形的面积问题&#xff1a;1384. 靶心数问题&#xff1a;1398. 奇偶统计 三、感谢 一、前言 欢迎关注本专栏《C从零基础到信奥赛入门级&#xff08;CSP-J&#xff09;》 本章节主要对…
阅读更多...
优秀的安防视频监控平台应该具备怎样的视频编解码能力？

优秀的安防视频监控平台应该具备怎样的视频编解码能力？

随着安防技术的飞速发展&#xff0c;监控平台作为保障公共安全、维护社会秩序的重要工具&#xff0c;其性能与效率日益成为行业关注的焦点。其中&#xff0c;监控平台的视频编码能力在视频监控系统中扮演着至关重要的角色&#xff0c;视频编码技术作为监控系统的核心组成部分&a…
阅读更多...
200美元/月的ChatGPT Pro版上线？OpenAI草莓模型曝两周内发布，但模型表现要打个问号？

200美元/月的ChatGPT Pro版上线？OpenAI草莓模型曝两周内发布，但模型表现要打个问号？

夕小瑶科技说 原创 作者 | 海野 现在看到“草莓”两个字&#xff0c;我已经条件反射了&#xff0c;已经不再是之前单纯的香香甜甜的草莓了。 一早醒来&#xff0c;又发生了两件“大事”&#xff1a; 一个是OpenAI的草莓&#xff08;strawberry&#xff09;被曝要提前了&#xf…
阅读更多...
Xorbits Inference（Xinference）：一款性能强大且功能全面的大模型部署与分布式推理框架

Xorbits Inference（Xinference）：一款性能强大且功能全面的大模型部署与分布式推理框架

大模型部署与分布式推理框架Xinference Xinference的基本使用概述安装启动服务模型部署模型参数配置说明 API接口概述对话接口模型列表嵌入模型Rerank模型使用Xinference SDK使用OpenAI SDK 命令行工具概述启动模型引擎参数其他操作 集成LoRA启动时集成LoRA应用时集成LoRA 部署…
阅读更多...
Stable Diffusion绘画 | ControlNet应用-Tile(分块)—tile_resample(分块-重采样)

Stable Diffusion绘画 | ControlNet应用-Tile(分块)—tile_resample(分块-重采样)

要想使用 SD 生成高品质图片&#xff0c;放大增加分辨率是必不可少的环节。 tile_resample(分块-重采样) 主要是将图片切分成很多个分块&#xff0c;并识别每个分块的信息&#xff0c;最终通过特定算法把分块的信息重组起来。 能有效避免直接对一整张图片统一处理&#xff0c…
阅读更多...
TensorFlow深度学习框架改进K-means聚类、SOM自组织映射算法及上海招生政策影响分析研究...

TensorFlow深度学习框架改进K-means聚类、SOM自组织映射算法及上海招生政策影响分析研究...

全文链接&#xff1a;https://tecdat.cn/?p37652 分析师&#xff1a;Chen Zhang 在教育政策研究领域&#xff0c;准确评估政策对不同区域和学生群体的影响至关重要。2021 年上海市出台的《上海市初中学业水平考试实施办法》对招生政策进行了调整&#xff0c;其中名额分配综合…
阅读更多...
LSS可视化分析

LSS可视化分析

1 完整 2 去掉plt.imshow(img_show) 3 去掉plt.axis(‘off’) 4 去掉plt.annotate(cams_text[img_id].replace(‘_’, ’ ), (0.01, 0.92), xycoords=‘axes fraction’)
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023