7-12 排序 (25分)

最新推荐文章于 2023-08-29 09:35:32 发布

原创最新推荐文章于 2023-08-29 09:35:32 发布 · 805 阅读

3 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#算法 #快速排序 #排序算法

数据结构与算法专栏收录该内容

31 篇文章

订阅专栏

该博客探讨了不同排序算法在处理各种数据集时的性能，包括单个元素、不相同整数、随机整数、有序及逆序整数等。提供了堆排序、简单插入排序、希尔排序、简单选择排序、冒泡排序以及快速排序和归并排序的实现，并给出了相应的测试结果。主要关注算法的时间复杂度和效率。

给定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（≤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

堆排序实现代码

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

void Swap(int *x, int *y){
    int temp;
    temp = *x;
    *x = *y;
    *y = temp;
}

void PercDown(int a[], int p, int N){
    int parent,child;
    int x;
    x = a[p];
    for(parent = p; (parent*2+1)<N; parent = child){
        child = parent*2+1;
        if((child!=N-1)&&(a[child]<a[child+1])){
            child++;
        }
        if(x>=a[child]) break;
        else    a[parent] = a[child];
    }
    a[parent] = x;
}

void HeapSort(int a[], int N){
    int i;
    for(i = N/2;i>=0;i--){
        PercDown(a, i, N);
    }
    for(i = N-1;i>0;i--){
        Swap(&a[0], &a[i]);
        PercDown(a, 0, i);
    }
}

int main(void){
    int i,N;
    scanf("%d",&N);
    int a[N];
    for(i=0;i<N;i++){
        scanf("%d",&a[i]);
    }
    HeapSort(a, N);
    printf("%d",a[0]);
    for(i=1;i<N;i++){
        printf(" %d",a[i]);
    }
    return 0;
}

测试结果：
在这里插入图片描述
简单插入排序实现

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

void InsertionSort(int a[], int N){
    int p, i;
    int temp;
    for(p = 1; p<N; p++){
        temp = a[p];
        for(i = p;i>0&&a[i-1]>temp;i--){
            a[i] = a[i-1];
        }
        a[i] = temp;
    }
}
int main(void){
    int i,N;
    scanf("%d",&N);
    int a[N];
    for(i=0;i<N;i++){
        scanf("%d",&a[i]);
    }
    InsertionSort(a, N);
    printf("%d",a[0]);
    for(i=1;i<N;i++){
        printf(" %d",a[i]);
    }
    return 0;
}

测试结果：
在这里插入图片描述

希尔排序实现

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

void ShellSort(int a[], int N){
    int si, d, p, i;
    int temp;
    int sedgewick[] = {929, 505, 209, 109, 41, 19, 5, 1, 0};    //选定的增量序列
    
    for(si = 0;sedgewick[si]>=N;si++)                           //确保增量不大于待排序列长度
        ;
    for(d = sedgewick[si]; d>0; 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;
        }
    }
}

int main(void){
    int i,N;
    scanf("%d",&N);
    int a[N];
    for(i=0;i<N;i++){
        scanf("%d",&a[i]);
    }
    ShellSort(a, N);
    printf("%d",a[0]);
    for(i=1;i<N;i++){
        printf(" %d",a[i]);
    }
    return 0;
}

测试结果：
在这里插入图片描述
简单选择排序（耗时巨长）

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

void Swap(int *x, int *y){
    int temp;
    temp = *x;
    *x = *y;
    *y = temp;
}

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

int main(void){
    int i,N;
    scanf("%d",&N);
    int a[N];
    for(i=0;i<N;i++){
        scanf("%d",&a[i]);
    }
    SimpleSelectionSort(a, N);
    printf("%d",a[0]);
    for(i=1;i<N;i++){
        printf(" %d",a[i]);
    }
    return 0;
}

测试结果：
在这里插入图片描述
冒泡排序（有两个点运行超时）

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
void Swap(int *x, int *y){
    int temp;
    temp = *x;
    *x = *y;
    *y = temp;
}

void BubbleSort(int a[], int N){
    int p,i;
    bool flag;
    for(p = N-1; p>=0; p--){
        flag = false;
        for(i = 0;i<p;i++){
            if(a[i]>a[i+1]){
                Swap(&a[i],&a[i+1]);
                flag = true;
            }
        }
        if(flag == false)   break;
    }
}

int main(void){
    int i,N;
    scanf("%d",&N);
    int a[N];
    for(i=0;i<N;i++){
        scanf("%d",&a[i]);
    }
    BubbleSort(a, N);
    printf("%d",a[0]);
    for(i=1;i<N;i++){
        printf(" %d",a[i]);
    }
    return 0;
}

测试结果：
在这里插入图片描述
快速排序

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
void Swap(int *x, int *y){
    int temp;
    temp = *x;
    *x = *y;
    *y = temp;
}
int Judge(int a[], int left, int right){
    int temp;
    temp = a[left];
    while(left<right){
        while(left<right&&a[right]>=temp)
            right--;
        Swap(&a[left], &a[right]);
        while(left<right&&a[left]<=temp)
            left++;
        Swap( &a[left], &a[right]);
    }
    return left;
}

void Qsort(int a[], int left, int right){
    int pivot;
    if(left<right){
        pivot = Judge(a, left, right);
        Qsort(a,left,pivot-1);
        Qsort(a,pivot+1,right);
    }
}

void QuickSort(int a[], int N){
    Qsort(a, 0, N-1);
}

int main(void){
    int i,N;
    scanf("%d",&N);
    int a[N];
    for(i=0;i<N;i++){
        scanf("%d",&a[i]);
    }
    QuickSort(a, N);
    printf("%d",a[0]);
    for(i=1;i<N;i++){
        printf(" %d",a[i]);
    }
    return 0;
}

测试结果
在这里插入图片描述

归并排序算法：

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
void Swap(int *x, int *y){
    int temp;
    temp = *x;
    *x = *y;
    *y = temp;
}
void Merge(int a[], int tmp[], int L, int R, int RightEnd){
    int LeftEnd, NumElements, index;
    int i;
    LeftEnd = R-1;
    index = L;
    NumElements = RightEnd-L+1;
    while(L<=LeftEnd&&R<=RightEnd){
        if(a[L]<=a[R])
            tmp[index++] = a[L++];
        else
            tmp[index++] = a[R++];
    }
    while(L<=LeftEnd)
        tmp[index++] = a[L++];
    while(R<=RightEnd)
        tmp[index++] = a[R++];
    for(i=0; i<NumElements; i++,RightEnd--)
        a[RightEnd] = tmp[RightEnd];
}

void Msort(int a[], int tmp[], int L, int rightend){
    int center;
    if(L<rightend){
        center = (L+rightend)/2;
        Msort(a, tmp, L, center);               //递归解决左边
        Msort(a, tmp, center+1, rightend);      //递归解决右边
        Merge(a, tmp, L, center+1, rightend);   //合并两段
    }
}

void MergeSort (int a[], int N){
    int *tmp;
    tmp = (int *)malloc(N*sizeof(int ));
    
    Msort(a, tmp, 0, N-1);
}

int main(void){
    int i,N;
    scanf("%d",&N);
    int a[N];
    for(i=0;i<N;i++){
        scanf("%d",&a[i]);
    }
    MergeSort(a, N);
    printf("%d",a[0]);
    for(i=1;i<N;i++){
        printf(" %d",a[i]);
    }
    return 0;
}

运行结果
在这里插入图片描述