pta 6-11 求自定類型元素序列的中位數

問題描述

本題要求實現一個函數，求N個集合元素A[]的中位數，即序列中第⌊N/2+1⌋大的元素。其中集合元素的類型爲自定義的ElementType。

其中給定集合元素存放在數組A[]中，正整數N是數組元素個數。該函數須返回N個A[]元素的中位數，其值也必須是ElementType類型。

---

分析

//先排序，再找第中間大的數。
//還有就是找到數組中第k大的數，一個叫做快速選擇算法，根據快速排序修改而來；另一個是優先隊列，優先隊列和堆排序的思想類似。

---

1.冒泡

  ElementType Median( 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;
           }
        }
    }
    return A[N/2];
}  

2.哈希

    ElementType Median( ElementType A[], int N ){
    //這不算希爾排序 超時 效率還不如冒泡
    int d, i , j, k;
    ElementType temp;
    for(d = N/2; d >= 1; d/=2){
        for(i=0;i < d; i++){
            for(j=i;j<N-d;j+=d){
                for(k=j;k<N;k+=d){
                    if(A[j]>A[k]){
                        temp = A[j];
                         A[j] = A[k];
                        A[k] = temp;
                    }  
                } 
            }
        }
    }
    return A[N/2];
}

ElementType Median( ElementType A[], int N ){
    //先排序，希爾排序
    int d, i , j, k;
    ElementType temp;
    for(d = N/2; d >= 1; d/=2){
        for(i=d;i < N; i++){
            for(j=i-d;j>=0&&A[j]>A[j+d];j-=d){
                   temp = A[j];
                   A[j] = A[j+d];
                   A[j+d] = temp;  
            }
        }
    }
    return A[N/2];
}

void shellSort(ElementType A[], int N){
  int i, j, h;
  ElementType tem;
  for(h = N/2; h > 0; h /= 2){
    for(i = h; i < N; i++){
       tem = A[i]; 
       for(j = i; j >= h; j -= h)  //這裏避免明顯地使用交換
          if(tem < A[j-h]) A[j] = A[j-h];    
          else break;
       A[j] = tem;
    }
  }
}
ElementType Median( ElementType A[], int N ){
    shellSort(A,N);
    return A[N/2];
}

3.堆排序

/**
*  堆排序也是可以的。
*  在標註點，可以寫成 i > N/2-1。來減進一步減少時間
*/
#define LeftChild(i)(2*(i)+1) 
//爲什麼是2*i+1? 不是2*i？
//因爲數組下標從0開始存。如果從1開始存當然是2*i。

void preDown(ElementType A[],int i, int N){
    int child;
    ElementType tem;
    for(tem = A[i]; LeftChild(i)<N; i = child){
       child = LeftChild(i);   //找到左孩子節點
       if(child != N-1 && A[child + 1]>A[child]) child++;  //如果存在右孩子，且右孩子大，就指向右孩子
       if(tem < A[child])  A[i] = A[child];  //如果節點值小於孩子值，就更新節點值。
       else break;  //如果節點值不小於，就退出。
    }
    A[i] = tem; //如果節點值沒變，那i就沒變;如果節點值變了，那i就是child。
}

void swap(ElementType *a, ElementType *b){
    ElementType temp;  
    temp = *a;  
    *a = *b;  
    *b = temp;
}

void heapSort(ElementType A[], int N){
   int i;
   for(i = N/2; i >= 0; i --) preDown(A,i,N);  //建大根堆
   for(i = N-1; i > 0; i --){       //####標註點
      swap(&A[0],&A[i]);  //將最大的數和最後一個數交換位置
      preDown(A,0,i);   //將剩餘的數繼續建大根堆
   }
   // 循環完成後，即遞增排序。
}

ElementType Median( ElementType A[], int N ){
    //先排序
    heapSort(A,N);
    return A[N/2];
}