7-12 排序 GO语言 + C语言

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

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

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

输入格式:

输入第一行给出正整数N（≤10^5），随后一行给出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

  用go语言写的话,官方库占用的时间和空间比较多,所以数据可能没有C语言好看,特别是排序题,内存和时间都是超C十倍,然后我一一开始排查为什么耗时耗内存的时候怀疑是切片的底层实现问题,就把切片换成了数组,结果没变化,又怀疑是int默认64位,改成了32还是没有变化,所以只能是fmt的读取和输出了,C语言不愧是始祖语言👍

代码示例(GO语言):

package main

import (
	"fmt"
)

//N 是输入个数
var N int32

func main() {
	fmt.Scanln(&N)
	// var A []int32
	var A [100001]int32
	var i int32
	// var n int32
	for i = 0; i < N; i++ {
		// fmt.Scanf("%d", &n)
		// A = append(A, n)
		fmt.Scanf("%d", &A[i])
	}
	// ShellSort(A)
	QuickSort(&A, 0, N-1)
	// for i, x := range A {
	// 	if i == 0 {
	// 		fmt.Printf("%d", x)
	// 	} else {
	// 		fmt.Printf(" %d", x)
	// 	}
	// }
	for i = 0; i < N; i++ {
		if i == 0 {
			fmt.Printf("%d", A[i])
		} else {
			fmt.Printf(" %d", A[i])
		}
	}

}

//ShellSort 希尔排序
func ShellSort(A *[100001]int32) {
	var i, j, D, temp, Si int32
	Sedgewick := []int32{146305, 64769, 36289, 16001, 8929, 3905, 2161, 929, 505, 209, 109, 41, 19, 5, 1, 0}
	for Si = 0; Si >= N; Si++ {
	}
	for ; Sedgewick[Si] > 0; Si++ {
		D = Sedgewick[Si]
		for i = D; i < N; i++ {
			temp = A[i]
			for j = i; j >= D && A[j-D] > temp; j -= D {
				A[j] = A[j-D]
			}
			A[j] = temp
		}
	}
}

//Swap 交换函数
func Swap(a *int32, b *int32) {
	c := *a
	*a = *b
	*b = c
}

//Median3 取pivot值
func Median3(A *[100001]int32, Left int32, Right int32) int32 {
	Middle := (Left + Right) >> 1
	if A[Left] > A[Middle] {
		Swap(&A[Left], &A[Middle])
	}
	if A[Left] > A[Right] {
		Swap(&A[Left], &A[Right])
	}
	if A[Middle] > A[Right] {
		Swap(&A[Middle], &A[Right])
	}
	Swap(&A[Middle], &A[Right-1])
	return A[Right-1]
}

//QuickSort 快速排序
func QuickSort(A *[100001]int32, Left int32, Right int32) {

	if Right-Left > 4 {
		pivot := Median3(A, Left, Right)
		i := Left
		j := Right - 1
		for {
			i++
			j--
			for A[i] < pivot {
				i++
			}
			for A[j] > pivot {
				j--
			}
			if i < j {
				Swap(&i, &j)
			} else {
				break
			}
		}
		Swap(&A[i], &A[Right-1])
		QuickSort(A, Left, i-1)
		QuickSort(A, i+1, Right)
	} else {
		ShellSort(A)
	}

}

代码示例(C语言):

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

typedef long ElementType;

void Bubble_Sort(ElementType A[], int N);
void Insertion_Sort(ElementType A[], int N);
void Shell_Sort(ElementType A[], int N);
void Heap_Sort(ElementType A[],int N);
void Merge_pass( ElementType A[], ElementType TmpA[], int N, int length ); 
void Merge_Sort( ElementType A[], int N );
void Quick_Sort(ElementType A[], int N);

int main()
{
	int N,i,range = 1000;
//	clock_t begin, end;//测试运行时间 
//	double cost;
	ElementType *arr;
	scanf("%d",&N);
	arr = (ElementType*)malloc(sizeof(ElementType) * N);
//	srand((int)time(0));
//	begin = clock();
	for(i = 0; i < N; i++){
		scanf("%ld",&arr[i]);
//		arr[i] = rand()%range;
	} 
//	Bubble_Sort(arr,N);
//	Insertion_Sort(arr,N); 
//	Shell_Sort(arr,N);
//	Heap_Sort(arr,N);
//	Merge_Sort(arr,N); 
	Quick_Sort(arr,N);
//	end = clock();
//	cost = (double)(end - begin);
//	printf("time cost is: %lf ms", cost);

	for(i = 0; i < N; i++){
		if(!i)
			printf("%ld",arr[i]);
		else
			printf(" %ld",arr[i]);
	}
	
}

//冒泡排序,O(n^2),优点:可以在链表中实现而且稳定,缺点就是慢 
void Bubble_Sort(ElementType A[], int N)
{
	int i,j;
	ElementType temp;
	for(i = 0; i < N - 1; i++){
		for(j = 0; j < N-i-1; j++){
			if(A[j] > A[j+1]){
				temp = A[j];
				A[j] = A[j+1];
				A[j+1] = temp; 
			}
		}
	}
}

//插入排序,O(n^2),稳定 
void Insertion_Sort(ElementType A[], int N)
{
	int P,i;
	ElementType temp;
	for(P = 1; P < N; P++){
		temp = A[P];//保存要比较的元素 
		for(i = P; i > 0 && A[i-1] > temp; i--){//当temp是比前一个元素小的时候,前面的元素往后移位 
			A[i] = A[i-1]; 
		}
		A[i] = temp;
	} 
}

//希尔排序, 
void Shell_Sort(ElementType A[], int N)
{
	int P,D,i,Si;
	ElementType temp;
	int Sedgewick[] = {146305,64769,36289,16001,8929,3905,2161,929, 505, 209, 109, 41, 19, 5, 1, 0};
	//插入排序的改版 
	for ( Si=0; Sedgewick[Si] >= N; Si++ ); /* 初始的增量Sedgewick[Si]不能超过待排序列长度 */
	for(; Sedgewick[Si] > 0; Si++){
		D = Sedgewick[Si];//这里不能写到上面初始化哦 
		for(P = D; P < N; P++){
			temp = A[P];
			for(i = P;i >= D && A[i-D] > temp; i -= D){
				A[i] = A[i-D];
			}
			A[i] = temp;
		}
	}
}

void PercDown( ElementType A[], int p, int N )
{
	int Parent,Child;
	ElementType temp = A[p];
	for(Parent = p; (Parent * 2 + 1) < N; Parent = Child){
		Child = Parent * 2 + 1;
		if(Child + 1 != N && A[Child + 1] > A[Child]){
			Child++;
		}
		if(temp >= A[Child])
			break;
		else
			A[Parent] = A[Child];
	}
	A[Parent] = temp;
}

void Swap(ElementType *a,ElementType *b){
	ElementType c;
	c = *a;
	*a = *b;
	*b = c;
}

//堆排序,挺快 
void Heap_Sort(ElementType A[],int N)
{
	int i;
	for(i = N / 2 - 1; i >= 0; i--){
		PercDown(A,i,N);
	}
	for(i = N - 1; i > 0; i--){
		Swap(&A[0],&A[i]);
		PercDown(A,0,i);
	} 
 } 
 
/* L = 左边起始位置, R = 右边起始位置, RightEnd = 右边终点位置*/
void Merge( ElementType A[], ElementType TmpA[], int L, int R, int RightEnd )
{ /* 将有序的A[L]~A[R-1]和A[R]~A[RightEnd]归并成一个有序序列 */
     int LeftEnd, NumElements, Tmp;
     int i;
      
     LeftEnd = R - 1; /* 左边终点位置 */
     Tmp = L;         /* 有序序列的起始位置 */
     NumElements = RightEnd - L + 1;
      
     while( L <= LeftEnd && R <= RightEnd ) {
         if ( A[L] <= A[R] )
             TmpA[Tmp++] = A[L++]; /* 将左边元素复制到TmpA */
         else
             TmpA[Tmp++] = A[R++]; /* 将右边元素复制到TmpA */
     }
 
     while( L <= LeftEnd )
         TmpA[Tmp++] = A[L++]; /* 直接复制左边剩下的 */
     while( R <= RightEnd )
         TmpA[Tmp++] = A[R++]; /* 直接复制右边剩下的 */
          
     for( i = 0; i < NumElements; i++, RightEnd -- )
         A[RightEnd] = TmpA[RightEnd]; /* 将有序的TmpA[]复制回A[] */
}

//归并排序,速度快空间开销大
void Merge_Sort( ElementType A[], int N )
{ 
     int length; 
     ElementType *TmpA;
      
     length = 1; /* 初始化子序列长度*/
     TmpA = (ElementType*)malloc( N * sizeof( ElementType ) );
     if ( TmpA != NULL ) {
          while( length < N ) {
              Merge_pass( A, TmpA, N, length );
              length *= 2;
              Merge_pass( TmpA, A, N, length );
              length *= 2;
          }
          free( TmpA );
     }
     else printf( "空间不足" );
}

 
void Merge_pass( ElementType A[], ElementType TmpA[], int N, int length )
{ /* 两两归并相邻有序子列 */
     int i, j;
       
     for ( i=0; i <= N-2*length; i += 2*length )
         Merge( A, TmpA, i, i+length, i+2*length-1 );
     if ( i+length < N ) /* 归并最后2个子列*/
         Merge( A, TmpA, i, i+length, N-1);
     else /* 最后只剩1个子列*/
         for ( j = i; j < N; j++ ) TmpA[j] = A[j];
}


int Median3(ElementType A[], int Left, int Right){
	int M;
	M = (Left + Right) / 2;
	if(A[Left] > A[M])
		Swap(&A[Left],&A[M]);
	if(A[Left] > A[Right])
		Swap(&A[Left],&A[Right]);
	if(A[M] > A[Right])
		Swap(&A[M],&A[Right]);
	Swap(&A[M],&A[Right-1]);
	return A[Right-1];
}

void QuickSort(ElementType A[], int Left, int Right){
	int pivot,i,j;
	if ( 100 <= 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]);	
		QuickSort(A,Left,i-1);
		QuickSort(A,i+1,Right);
	}else{
		Shell_Sort(A+Left,Right-Left+1); 
	} 
}

void Quick_Sort(ElementType A[], int N){
	QuickSort(A,0,N-1);
}