O - 青年歌手大奖赛_评委会打分 HDU - 2014+不同排序的分析

O - 青年歌手大奖赛_评委会打分  HDU - 2014 

青年歌手大奖赛中，评委会给参赛选手打分。选手得分规则为去掉一个最高分和一个最低分，然后计算平均得分，请编程输出某选手的得分。 

Input

输入数据有多组，每组占一行，每行的第一个数是n(2<n<=100)，表示评委的人数，然后是n个评委的打分。

Output

对于每组输入数据，输出选手的得分，结果保留2位小数，每组输出占一行。

Sample Input

3 99 98 97
4 100 99 98 97

Sample Output

98.00
98.50

代码示例：

#include<stdio.h>
#define N 100
int main(){
    int n;
    while(~scanf("%d",&n)){
        int temp,sum,i,j,a[N]={0};
        for(i=0;i<n;i++)
            scanf("%d",&a[i]);
        for(j=0;j<n-1;j++)   //冒泡排序
            for(i=0;i<n-1-j;i++)
                if(a[i]>a[i+1]){
                    temp=a[i];
                    a[i]=a[i+1];
                    a[i+1]=temp;
                }
        for(sum=0,i=1;i<n-1;i++)
            sum=sum+a[i];
        printf("%.2f\n",(float)sum/(n-2));
    }
}

关于排序的问题

在介绍排序问题前，先引入时间复杂度（算法复杂度的一种）的概念。

在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为O(1),另外，在时间频度不相同时，时间复杂度有可能相同，如T(n)=n^2+3n+4与T(n)=4n^2+2n+1它们的频度不同，但时间复杂度相同，都为O(n^2)。

博主由于能力有限，目前只能简单的介绍以下几种方法

1. 冒泡排序：
2. 选择排序
3. 插入排序
4. 快速排序

1.冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。

冒泡排序是一种较为简单的排序，平均时间复杂度为  。

2.选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

时间复杂度同冒泡排序。

代码示例：

void swap(int*a,int*b){
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}
void sort(int a[], int n){
    int i, j, min, temp;
    for (i = 0; i < n - 1; i++){
        min = i;
        for (j = i + 1; j < n; j++)
        if (a[j] < a[min]) min = j;
        swap(a[i], a[min], temp);
    }
}

3.插入排序

有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。

步骤如下：

1. 从第一个元素开始，该元素可以认为已经被排序。 
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描。
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置。
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置。
5. 将新元素插入到该位置后。
6. 重复步骤2~5。

在最坏的情况下，冒泡排序需要次交换，而插入排序只要最多交换。冒泡排序的实现通常会对已经排序好的数列拙劣地执行（），而插入排序在这个例子只需要个运算。平时基于课本中使用冒泡排序作为案例的原因，大多数人很少使用插入排序。

代码示例：

void sort(int a[],int first,int last){ //在数组a中对first到last元素进行排列。
    int i,j,temp;
    for(i=first+1;i<last;i++){
        temp=a[i];
        j=i-1;
        //与已排序的数逐一比较，大于temp时，该数移后
        while(j>=0&&a[j]>temp){
            a[j+1]=a[j];
            j--;
        }
        //存在大于temp的数
        if(j!=i-1) a[j+1]=temp;
    }
}

代码优化：

void sort(int *a,int n){
    int i,j,temp;
    for(i=1;i<n;i++){
        temp=*(a+i);
        for(j=i;j>0&&*(a+j-1)>temp;j--)
            *(a+j)=*(a+j-1);
        *(a+j)=temp;
    }
}

4.快速排序法

快速排序（Quicksort）是对冒泡排序的一种改进。

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

一趟快速排序的算法是：

1. 设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2. 以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3. 从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
4. 从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
5. 重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

排序演示

示例

假设用户输入了如下数组：

下标	0	1	2	3	4	5
数据	6	2	7	3	8	9

创建变量i=0（指向第一个数据）, j=5(指向最后一个数据), k=6(赋值为第一个数据的值)。

我们要把所有比k小的数移动到k的左面，所以我们可以开始寻找比6小的数，从j开始，从右往左找，不断递减变量j的值，我们找到第一个下标3的数据比6小，于是把数据3移到下标0的位置，把下标0的数据6移到下标3，完成第一次比较：

下标	0	1	2	3	4	5
数据	3	2	7	6	8	9

i=0 j=3 k=6

接着，开始第二次比较，这次要变成找比k大的了，而且要从前往后找了。递加变量i，发现下标2的数据是第一个比k大的，于是用下标2的数据7和j指向的下标3的数据的6做交换，数据状态变成下表：

下标	0	1	2	3	4	5
数据	3	2	6	7	8	9

i=2 j=3 k=6

称上面两次比较为一个循环。

接着，再递减变量j，不断重复进行上面的循环比较。

在本例中，我们进行一次循环，就发现i和j“碰头”了：他们都指向了下标2。于是，第一遍比较结束。得到结果如下，凡是k(=6)左边的数都比它小，凡是k右边的数都比它大：

下标	0	1	2	3	4	5
数据	3	2	6	7	8	9

如果i和j没有碰头的话，就递加i找大的，还没有，就再递减j找小的，如此反复，不断循环。注意判断和寻找是同时进行的。

然后，对k两边的数据，再分组分别进行上述的过程，直到不能再分组为止。

注意：第一遍快速排序不会直接得到最终结果，只会把比k大和比k小的数分到k的两边。为了得到最后结果，需要再次对下标2两边的数组分别执行此步骤，然后再分解数组，直到数组不能再分解为止（只有一个数据），才能得到正确结果。

代码示例：

void sort(int *a, int left, int right){
    if(left >= right)
        return 
    int i = left, j = right, key = a[left];
    while(i < j)           {
        while(i < j && key <= a[j])  j--;
        a[i] = a[j];
        while(i < j && key >= a[i])  i++;
        a[j] = a[i];
    a[i] = key;
    sort(a, left, i - 1);
    sort(a, i + 1, right);
}
                     

快速排序时间复杂度为O（n×log2n)