PTA 5-12 排序 (25分)

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

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

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

  输入格式:

  输入第一行给出正整数NN（\le 10^5≤10​5​​），随后一行给出NN个（长整型范围内的）整数，其间以空格分隔。

  输出格式:

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

  输入样例:

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

  输出样例:

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

• 下面试验了各种排序算法的的表现

• 算法/时间复杂度	10^3的随机整数	10^4个随机整数	10^5个随机整数	10^5个顺序整数	10^5个逆序整数	10^5个基本有序的整数	10^5个随机正整数，每个数不超过1000
  冒泡排序	4ms	228ms	>10s	88ms	>10s	650ms	>10s
  插入排序	3ms	35ms	4784ms	82ms	9206ms	115ms	4499ms
  选择排序	5ms	332ms	>10s	>10s	>10s	>10s	>10s
  归并排序（递归版本）	4ms	12ms	131ms	82ms	127ms	83ms	75ms
  堆排序	3ms	10ms	103ms	89ms	102ms	126ms	94ms
  希尔排序	3ms	25ms	128ms	119ms	125ms	117ms	116ms
  归并排序（循环版本）	3ms	24ms	125ms	78ms	99ms	77ms	93ms
  快速排序（pivot取中位数）	3ms	10ms	122ms	76ms	112ms	76ms	69ms

/* 冒泡排序
 * 1.最好情况 已经有序了O(n)
 * 2.最坏情况 逆序 O(n^2)
 * 3.平均情况 O(n^2)
 */
void bubble_sort(int a[],int n) {
    for (int i = n - ; i > ; i--) {
        int flag = ;
        for (int j = ; j < i; j++) {
            if (a[j] > a[j + ]) {
                int temp = a[j];
                a[j] = a[j + ];
                a[j + ] = temp;
                flag = ;
            }
        }
        if (flag == )
            break;
    }
}

/*
 * 插入排序（对于基本有序的数组排序有较好的表现）
 * 1.最好情况  有序  O(n)
 * 2.最坏情况  逆序  o(n^2)
 * 3.平均情况 O(n^2)
 */
void insertion_sort(int a[],int n) {
    int i, j;
    for (i = ; i < n; i++) {
        int temp = a[i]; /* 当前要插入的数 */
        for (j = i - ; j >= ; j--) {
            if (temp >= a[j])
                break;
            a[j + ] = a[j];
        }
        a[j + ] = temp;
    }
}

/*
 * 希尔排序（不稳定）
 * 1.时间复杂度跟取得序列有关系
 * 2.取 n/2,n/2^2,...,1序列时 最坏情况下时间复杂度为O(n^2)
 * 3.sedgewick序列时 最坏： O(n^3/2) 平均：O(n^5/4)
 */
void shell_sort(int a[],int n) {
    int i, j;
    int sedgewick[] = { ,,,,,,, };
    for (i = ; sedgewick[i] >= n; i++);
    for(int d=sedgewick[i];d>;d=sedgewick[++i])
        for (int p = d; p < n; p++) {
            int temp = a[p];
            for (j = p; j >= d&&a[j - d] > temp; j -= d)
                a[j] = a[j - d];
            a[j] = temp;
        }
}

/*
 * 选择排序（不稳定 应该是最差的排序算法了吧）
 * 最好 最坏  平均 时间复杂度都是O(n^2)
 */
void  selection_sort(int a[],int n) {
    for (int i = ; i < n-; i++) {
        int min = i;
        for (int j = i + ; j < n; j++) {
            if (a[j] < a[min]) {
                min = j;
            }
        }
        if (min != i) {
            int temp = a[min];
            a[min] = a[i];
            a[i] = temp;
        }
    }
}

/*
 * 归并排序（递归版本） 在外排序中使用较多
 * 1.时间复杂度 最好  最坏 平均 都是O(n*log n).
 * 2.空间复杂度 是 O(n).
 */
void merge1(int a[],int temp[],int left,int right,int rightEnd) {
    int l = left;
    int leftEnd = right -;
    int r = right;
    int index = rightEnd - left + ;
    int x = left;
    while (l <= leftEnd && r <= rightEnd) {
        if (a[l] <= a[r]) {
            temp[x++] = a[l++];
        }
        else
            temp[x++] = a[r++];
    }
    while (l <= leftEnd)
        temp[x++] = a[l++];
    while (r <= rightEnd)
        temp[x++] = a[r++];
    for (int i=rightEnd; index > ; index--,i--)
        a[i] = temp[i];
}

void mSort1(int a[],int temp[],int left,int right) {
    if (left < right) {
        int mid = (left + right) / ;
        mSort1(a, temp, left, mid);
        mSort1(a, temp, mid + , right);
        merge1(a, temp, left, mid + , right);
    }

}
void merge_sort1(int a[],int n) {
    int* temp = (int*)malloc(sizeof(int)*n);
    if (temp != NULL ) {
        mSort1(a, temp, , n-);
        free(temp);
    }
    else {
        cout << "内存不足" << endl;
    }
}

/*
 * 归并排序循环版本
 * 1. 时间复杂度  最好 最坏 平均 都为O(n * log n)
 * 2. 空间复杂度O(n)
*/
void merge2(int a[], int temp[], int left, int right, int rightEnd) {
    int l = left;
    int leftEnd = right - ;
    int r = right;
    int index = rightEnd - left + ;
    int x = left;
    while (l <= leftEnd && r <= rightEnd) {
        if (a[l] <= a[r]) {
            temp[x++] = a[l++];
        }
        else
            temp[x++] = a[r++];
    }
    while (l <= leftEnd)
        temp[x++] = a[l++];
    while (r <= rightEnd)
        temp[x++] = a[r++];
}

void mergePass(int a[],int temp[],int n,int length) {
    int i;
    for (i = ; i +  * length <= n; i +=  * length) {
        merge2(a, temp, i, i + length, i +  * length - );
    }
    if (i + length < n) {
        merge2(a, temp, i, i + length, n - );
    }
    else
        for (int j = i; j < n; j++)
            temp[j] = a[j];
}
void merge_sort2(int a[],int n) {
    int* temp = (int*)malloc(n * sizeof(int));
    if (temp != NULL) {
        int length = ;
        while (length < n) {
            mergePass(a, temp, n, length);
            length *= ;
            mergePass(temp, a, n, length);
            length *= ;
        }
        free(temp);
    }
    else {
        cout << "内存不足" << endl;
    }
}

/*
 * 堆排序（不稳定）
 * 最好 最坏 平均 时间复杂度 O(n*log n).
 */
void adjust(int a[],int i, int n) {
    int parent, child;
    int temp = a[i];
    for (parent = i; parent *  < n - ; parent = child) {
        child = parent *  + ; /* 先指向左孩子 */
        if (child != n -  && a[child+] > a[child]) {
            child++; /* 右孩子较大则指向右孩子 */
        }
        if (temp >= a[child])
            break;
        else
            a[parent] = a[child];
    }
    a[parent] = temp;
}
void heap_sort(int a[], int n) {
    for (int i = (n-) / ; i >= ; i--)
        adjust(a,i,n);  /* 构建最大堆 */
    for (int i = n - ; i > ; i--) {
        int temp = a[i];
        a[i] = a[];
        a[] = temp;
        adjust(a, , i);
    }
}

/*
 * 快速排序 （不稳定）
 * 1.最坏情况和主元的选取有一定的关系 如果选首位为主元O(n^2)
 * 2.最好 平均 O(n * log n)
 * 3.当待排元素较少时  快排效率会急速下降  此时可采用插入排序
 */
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}
int median3(int a[],int left,int right) {
    int center = (left + right) / ;
    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-]); /* 将基准放在数组右端 */
    return a[right-];
}
void qSort(int a[],int left,int right) {
    int cutoff = ;
    int low, high, pivot;
    if (right - left >= cutoff) {
        pivot = median3(a, left, right);
        low = left;
        high = right - ;
        while () {
            while (a[++low] < pivot);
            while (a[--high] > pivot);
            if (low < high)
                swap(&a[low], &a[high]);
            else
                break;
        }
        swap(&a[low], &a[right - ]);
        qSort(a, left, low - );
        qSort(a, low + , right);
    }
    else
        insertion_sort(a+left,right-left+);
}

void quick_sort(int a[],int n) {
    qSort(a,,n-);
}

算法/时间复杂度	10^3的随机整数	10^4个随机整数	10^5个随机整数	10^5个顺序整数	10^5个逆序整数	10^5个基本有序的整数	10^5个随机正整数，每个数不超过1000
冒泡排序	4ms	228ms	>10s	88ms	>10s	650ms	>10s
插入排序	3ms	35ms	4784ms	82ms	9206ms	115ms	4499ms
选择排序	5ms	332ms	>10s	>10s	>10s	>10s	>10s
归并排序（递归版本）	4ms	12ms	131ms	82ms	127ms	83ms	75ms
堆排序	3ms	10ms	103ms	89ms	102ms	126ms	94ms
希尔排序	3ms	25ms	128ms	119ms	125ms	117ms	116ms
归并排序（循环版本）	3ms	24ms	125ms	78ms	99ms	77ms	93ms
快速排序（pivot取中位数）	3ms	10ms	122ms	76ms	112ms	76ms	69ms
基数排序