C語言學習記錄LeetCode——去掉最低工資和最高工資後的平均工資（排序）

題目：

給你一個整數陣列salary，陣列裡每個數都是 唯一 的，其中salary[i]是第i個員工的工資。

請你返回去掉最低工資和最高工資以後，剩下員工工資的平均值。

提示：

• 3 <= salary.length <= 100
• 10^3 <= salary[i] <= 10^6
• salary[i]是唯一的。
• 與真實值誤差在10^-5以內的結果都將視為正確答案

方法一：
  先寫find_max_salary函式找到陣列中的最大數，然後寫find_min_salary函式找到陣列中的最小數，再寫sum_salary函式計算出陣列中數字的總和。最後在average函式中首先求出陣列總和，然後用總和減去所找到的陣列中的最大值和最小值，最後再除以減去最大最小值後的陣列長度。

int find_max_salary(int *salary, int salarySize)
{
    int max = 0;
    int i = 0;
    while (i < salarySize){
        if (max < salary[i])
            max = salary[i];
        i++;
    }
    return max;
}
int find_min_salary(int *salary, int salarySize)
{
    int min = 1000000；
    int i = 0;
    while (i < salarySize){
        if (min > salary[i])
            min = salary[i];
        i++;
    }
    return min;
}
double sum_salary(int *salary, int salarySize)
{
    int sum = 0;
    int i = 0;
    while (i <= salarySize){
        sum += salary[i];
        i++;
    }
    return sum;
}
double average(int* salary, int salarySize){
    int max = find_max_salary(salary, salarySize);
    int min = find_min_salary(salary, salarySize);
    double salary_sum = sum_salary(salary, salarySize);

    int people_num = salarySize - 2;
    return (salary_sum - max - min) / people_num
}


作者：aaa-206
連結：https://leetcode-cn.com/problems/average-salary-excluding-the-minimum-and-maximum-salary/solution/123456-by-aaa-206/
來源：力扣（LeetCode）

方法二:
  首先將陣列中第0位賦給max，min，sum通過一個for迴圈，在for迴圈中i表示陣列下標。在陣列中邊查詢極值，邊計算和。

double average(int* salary, int salarySize){
    int i, max, min;
    double sum = 0;
    sum = max = min = salary[0];

    for(i=1; i<salarySize; i++)
    {
        if (salary[i] > max)
        {
            max = salary[i];
        }
        if (salary[i] < min)
        {
            min = salary[i];
        }
        sum += salary[i];
    }
    sum = sum - max - min;
    return sum / (salarySize - 2);
}

作者：xiaowenzi
連結：https://leetcode-cn.com/problems/average-salary-excluding-the-minimum-and-maximum-salary/solution/bu-yong-liang-ci-xun-huan-bian-cha-zhao-ji-zhi-bia/
來源：力扣（LeetCode）

方法三:
  所使用思想與前面的方法一致，也是給一個最小值（最大值），找到極值後計算和

#define INT_MAX 2147483647
#define INT_MIN -2147483648

double average(int* salary, int salarySize){
    int sum = 0, max = INT_MIN, min = INT_MAX;
    for (int i = 0; i < salarySize; ++i) {
        sum += salary[i];
        if (min > salary[i]) min = salary[i];
        if (max < salary[i]) max = salary[i];
    }
    return (double)(sum - min - max) / (salarySize - 2);
}

作者：chen-xiang-yin
連結：https://leetcode-cn.com/problems/average-salary-excluding-the-minimum-and-maximum-salary/solution/c-yu-yan-4-ms-55-mb-by-chen-xiang-yin-4/
來源：力扣（LeetCode）

方法四：
  使用qsort函式進行排序。

int cmp(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

double average(int* salary, int salarySize){
    double sum = 0;
    qsort(salary, salarySize, sizeof(int), cmp);
    if (salarySize == 3) {
        return salary[1];
    }

    for (int i = 1; i < salarySize - 1; ++i) {
        sum += salary[i];
    }

    return sum / (salarySize - 2);
}

作者：Dint
連結：https://leetcode-cn.com/problems/average-salary-excluding-the-minimum-and-maximum-salary/solution/1491-qu-diao-zui-di-gong-zi-he-zui-gao-gong-zi-h-2/
來源：力扣（LeetCode）

根據此處所描述，關於qsort()函式原理如下：
  函式原理：

void qsort(
    void *base,
    size_t nmemb,
    size_t size,
    int (*compar)(const void *, const void *)
    );

  函式功能：qsort()函式的功能是對陣列進行排序，陣列中有nmemb個元素，每個元素的大小為size。

引數base      - base指向陣列起始地址，通常該位置傳入的是一個陣列名
引數nmemb     -nmemb表示該陣列的元素個數
引數size      -size表示該陣列中每個元素的大小（位元組數）
引數(compar)(const void,const void*)-此為只想比較函式的函式指標，決定了排序的順序。

函式返回值：無

注意：如果兩個元素的值是相同的，那麼他們的前後順序是不確定的。也就是說qsort()是一個不穩定的排序演算法。

  在sqort()排序中使用到的compar引數是一個指向比較兩個元素的函式。比較函式的原理如下。注意兩個形參必須是const void*型，同時在呼叫compar函式（compar實質為函式指標，這裡稱它所指向的函式也為compar）時，傳入的實參也必須轉換成const void*型。
  在compar函式內部將const void*型轉換成實際型別，如下所示：

int compar(const void *p1, const void *p2);

如果compar返回值小於0（<0），那麼p1所指向元素會被排在p2所指向元素的前面。
如果compar返回值等於0（=0），那麼p1所指向元素與p2所指向元素的順序不確定。
如果compar返回值大於0（>0），那麼p1所指向元素會被排在p2所指向元素的後面。
因此，如果想讓qsort()進行從小到大（升序）排序，那麼一個通用的compar函式可以寫成這樣：

int comparMyType (const viod * a, const void * b)
{
    if (*(MyType*)a <  *(MyType*)b) return -1;
    if (*(MyType*)a <= *(MyType*)b) return  0;
    if (*(MyType*)a >  *(MyType*)b) return  1;
}
注意：你要將MyType轉換成實際陣列元素的型別。

一個使用qsort()函式的小例子：

#include<stdio.h>   //printf的庫函式
#include<stdlib.h>  //qsort的庫函式
 int values[] = {40, 10, 100, 90, 20, 25};
 int compare(comst void * a, const void * b)
 {
     return (*(int*)a - *(int*)b);
 }
 int main()
 {
    int n;
    qsort(values, 6, sizeof(int), compare);
    for (n=0; n<6; n++)
        printf("%d", values[n]);
    return 0;
 }

此處可以分析以下compar函式。如果a小於b，則返回值為負數(<0)，即a會排在b的前面。同理，若a大於b，則a會排在b的後面。所以，這裡的qsort()為從小到大即升序排序。因此，執行結果為：10 20 25 40 90 100