排序算法(C语言实现)

冒泡排序

 

void  BubbleSort(Element Array[], ArraySize Count) // 一趟后,把最小的数放到最前面
... {    
    ArraySize i,j;
    Element temp;
    for (i = 0; i < Count - 1; i++)
        for(j = Count - 1; j > i; j--)//从后往前找最小的数
            if(Array[j] < Array[j-1])
            ...{
                temp = Array[j];
                Array[j] = Array[j-1];
                Array[j-1] = temp;
            }
}

void  BubbleSort2(Element Array[], ArraySize Count)     //  Improve performance
... {    
    ArraySize i,j;
    Element temp;
    int  flag;
    for (i = 0; i < Count - 1; i++)
    ...{
        flag = 0;
        for(j = Count - 1; j > i; j--)
            if(Array[j] < Array[j-1])
            ...{
                temp = Array[j];
                Array[j] = Array[j-1];
                Array[j-1] = temp;
                flag = 1;
            }
        if (flag == 0) break;
    }
}

 

插入排序

 

void  InsertSort(Element d[], ArraySize n)
... {
    ArraySize i,j;
    Element t;
    for(i=1; i<n; i++)
    ...{
        t = d[i];
        if(d[i] < d[i-1])
        ...{
            for(j=i-1; j>=0 && t<d[j]; j--)
                d[j+1] = d[j];
            d[j+1] = t;
        }
    }
}

 

快速排序

 

void  QuickSort(Element Array[], ArraySize Count)
... {    
    QuickSortRange(Array,0,Count - 1);
}

ArraySize Partition(Element Array[], ArraySize Low, ArraySize High)
... {
    Element v,temp;
    ArraySize vPos;
    vPos = Low;
    v = Array[vPos];
    Low++;
    
    while(1)
    ...{
        while((High > Low) && (Array[High] > v)) High--;
        while((Low < High) && (Array[Low] <= v)) Low++;
        if(Low >= High) break;
        temp = Array[Low];
        Array[Low] = Array[High];
        Array[High] = temp;
        Low++;
        High--;
    }
    if(Array[Low] > v) Low--;
    if(vPos != Low)
    ...{
        temp = Array[Low];
        Array[Low] = Array[vPos];
        Array[vPos] = temp;
    }
    return Low;
}

void  QuickSortRange(Element Array[], ArraySize Low, ArraySize High)
... {
    ArraySize Middle;
    if(Low < High)
    ...{
        Middle = Partition(Array, Low, High);
        QuickSortRange(Array,Low,Middle - 1);
        QuickSortRange(Array,Middle + 1,High);
    }
}

 

选择排序

 

void  SelectSort(Element d[], ArraySize n)
... {
    int i, j, k, t;

    for(i = 0; i<n-1; i++)
    ...{
        k = i;
        for(j=i+1;j<n;j++)
        ...{
            if(d[j]<d[k])
                k = j;
        }
        if(k!=i)
        ...{
            t = d[i];
            d[i] = d[k];
            d[k] = t;
        }
    }
}

 

堆排序

 

void  BuildStock(Element Array[], ArraySize Count)
... {
    long Num = Count/2, temp, i;

    if(2*Num == Count)
    ...{
        if(Array[Num-1]<Array[Count-1])
        ...{
            temp = Array[Num-1];
            Array[Num-1] = Array[Count-1];
            Array[Count-1] = temp;
        }
    }
    else
    ...{
        if(Array[Num-1]<Array[Count-2] || Array[Num-1]<Array[Count-1])
        ...{
            if(Array[Count-2]>Array[Count-1])
            ...{
                temp = Array[Count-2];
                Array[Count-2] = Array[Num-1];
                Array[Num-1] = temp;
            }
            else
            ...{
                temp = Array[Count-1];
                Array[Count-1] = Array[Num-1];
                Array[Num-1] = temp;
            }
        }
    }


    for(i=Num-1; i>0; i--)
    ...{
        if(Array[i-1]<Array[i*2-1] || Array[i-1]<Array[i*2])
        ...{
            if(Array[i*2-1]>Array[i*2])
            ...{
                temp = Array[i*2-1];
                Array[i*2-1] = Array[i-1];
                Array[i-1] = temp;
                SubStockSort(Array, i*2, Count);
            }
            else
            ...{
                temp = Array[i*2];
                Array[i*2] = Array[i-1];
                Array[i-1] = temp;
                SubStockSort(Array, i*2+1, Count);
            }
        }
    }
}

void  SubStockSort(Element Array[], ArraySize i, ArraySize Count)
... {
    long temp;
    if(2*i<Count)
    ...{
        if(Array[i-1]<((Array[i*2-1]>Array[i*2])?Array[i*2-1]:Array[i*2]))
            if(Array[i*2-1]>Array[i*2])
            ...{
                temp = Array[i*2-1];
                Array[2*i-1] = Array[i-1];
                Array[i-1] = temp;
                SubStockSort(Array, 2*i, Count);
            }
            else
            ...{
                temp = Array[i*2];
                Array[2*i] = Array[i-1];
                Array[i-1] = temp;
                SubStockSort(Array, 2*i+1, Count);
            }
    }
    else if(2*i==Count && Array[i-1]<Array[2*i-1])
    ...{
        temp = Array[i*2-1];
        Array[2*i-1] = Array[i-1];
        Array[i-1] = temp;
        SubStockSort(Array, 2*i, Count);
    }
}

void  StockSort(Element Array[], ArraySize Count)
... {
    long i, temp;

    BuildStock(Array, Count);
    temp = Array[Count-1];
    Array[Count-1] = Array[0];
    Array[0] = temp;

    for(i=Count-1; i>1; i--)
    ...{
        SubStockSort(Array, 1, i);
        temp = Array[i-1];
        Array[i-1] = Array[0];
        Array[0] = temp;
    }
}

 

希尔排序

 

void  ShellSort(Element d[], ArraySize n)
... {

    int *dt, k, i, t, dk, j;
    k = n;
    dt = (int *) malloc(sizeof(int)*(n/2));
    i = 0;
    do
    ...{
        k = k/2;
        dt[i++] = k;
    }while(k>0);
    i = 0;
    while(dk=dt[i]>0)
    ...{
        for(k=dt[i]; k<n; ++k)
        ...{
            if(d[k]<d[k-dk])
            ...{
                t = d[k];
                for(j=k-dk; j>=0&&t<d[j]; j-=dk)
                    d[j+dk] = d[j];
                d[j+dk] = t;
            }
        }
        ++i;
    }
}

 

基数排序

 

#define  BASE2_RADIX        2
#define  DigitAtPos2(Number,Index)    ((Number & (1 << Index)) >> Index)

#define  BASE8_RADIX        8
#define  DigitAtPos8(Number,Index)    ((Number & (7 << (3 * Index))) >> (3 * Index))


// 以2为基
void  RadixSort2(Element Array[], ArraySize Count)
... {    
    Element *pArrayList[BASE2_RADIX];
    ArraySize ArrayListIndex[BASE2_RADIX];
    ArraySize i,j;
    int iList,jList;
    int iLoop,LoopMax;
    
    for(iList = 0;iList < BASE2_RADIX; iList++)
    ...{
        pArrayList[iList] = (Element*) malloc(Count * sizeof(Element));
        if(pArrayList[iList] == NULL)
        ...{
            printf("RadixSort分配内存出错! ");
            for(jList = 0;jList < iList; jList++)
                free(pArrayList[jList]);
            return ;
        }        
    }
    
    LoopMax = (int) (log(Count) / log(BASE2_RADIX)) + 1;
    
    for(iLoop = 0;iLoop < LoopMax; iLoop++)
    ...{
        for(i = 0;i < BASE2_RADIX; i++)
            ArrayListIndex[i] = 0;
        
        //Distribute
        for(i = 0;i < Count; i++)
        ...{
            iList = DigitAtPos2(Array[i],iLoop);
            pArrayList[iList][ArrayListIndex[iList]++] = Array[i];
        }
        //Collect
        j = 0;
        for(iList = 0;iList < BASE2_RADIX; iList++)
            for(i = 0;i < ArrayListIndex[iList]; i++)
                Array[j++] = pArrayList[iList][i];
    }

    for(i = 0;i < BASE2_RADIX; i++)
        free(pArrayList[i]);
}

// 以8为基
void  RadixSort8(Element Array[], ArraySize Count)
... {    
    Element *pArrayList[BASE8_RADIX];
    ArraySize ArrayListIndex[BASE8_RADIX];
    ArraySize i,j;
    int iList,jList;
    int iLoop,LoopMax;
    
    for(iList = 0;iList < BASE8_RADIX; iList++)
    ...{
        pArrayList[iList] = (Element*) malloc(Count * sizeof(Element));
        if(pArrayList[iList] == NULL)
        ...{
            printf("RadixSort分配内存出错! ");
            for(jList = 0;jList < iList; jList++)
                free(pArrayList[jList]);
            return ;
        }        
    }
    
    LoopMax = (int) (log(Count) / log(BASE8_RADIX)) + 1;
    
    for(iLoop = 0;iLoop < LoopMax; iLoop++)
    ...{
        for(i = 0;i < BASE8_RADIX; i++)
            ArrayListIndex[i] = 0;
        
        //Distribute
        for(i = 0;i < Count; i++)
        ...{
            iList = DigitAtPos8(Array[i],iLoop);
            pArrayList[iList][ArrayListIndex[iList]++] = Array[i];
        }
        //Collect
        j = 0;
        for(iList = 0;iList < BASE8_RADIX; iList++)
            for(i = 0;i < ArrayListIndex[iList]; i++)
                Array[j++] = pArrayList[iList][i];
    }

    for(i = 0;i < BASE8_RADIX; i++)
        free(pArrayList[i]);
}

 

归并排序

 

void  Merge(Element Array[], ArraySize s, ArraySize m, ArraySize n)
... {    
    //将分别有序的Array[s... m]和Array[m+1... n]归并为有序的Array[s... n]
    long i, j, k, b_s = s;
    Element *temp;
    temp = (Element*) malloc((n-s+1) * sizeof(Element));
    for(i=m+1, k=0; s<=m && i<=n; k++)
    ...{
        if(Array[s]<Array[i])
        ...{
            temp[k] = Array[s];
            s++;
        }
        else
        ...{
            temp[k] = Array[i];
            i++;
        }
    }

    for(j=s; j<=m; j++, k++)
        temp[k] = Array[j];
    for(j=i; j<=n; j++, k++)
        temp[k] = Array[j];

    for(i=b_s, j=0; i<=n; i++, j++)
        Array[i] = temp[j];

    if(temp)
        free(temp);
}

void  MergeSort(Element Array[], ArraySize Count)
... {
    long t = 1, s, i;
    long c = Count - 1;
    while(t < Count)
    ...{
        s = t;
        t = 2*s;
        i = 0;
        while(i+t <= Count)
        ...{
            Merge(Array, i, i+s-1, i+t-1);
            i = i+t;
        }
        if(i+s < Count)
            Merge(Array, i, i+s-1, c);
    }
}

 

Flash排序

 

const   int  THRESHOLD  =   75 ;
const  CLASS_SIZE  =   75 ;      /**/ /* minimum value for m */

void  Flash(Element a[], ArraySize n, int  m, int   * ctr)
... {

  /**//* declare variables */

  int *l,nmin,nmax,i,j,nmove,nx;

  long c1,c2,flash,hold,k;

  /**//* allocate space for the l vector */

  l=(int*)calloc(m,sizeof(int));

  /**//***** CLASS FORMATION ****/

  nmin=nmax=0;

  for (i=0 ; i < n ; i++)

     if (a[i] < a[nmin]) nmin = i;

     else if (a[i] > a[nmax]) nmax = i;

  if ( (a[nmax]==a[nmin]) && (ctr==0) )

  ...{

     printf("All the numbers are identical, the list is sorted ");

     return;

  }

  c1=(long)(m-1.0)/(a[nmax]-a[nmin]) ;

  c2=a[nmin];

  l[0]=-1; /**//* since the base of the "a" (data) array is 0 */

  for (k=1; k < m ; k++) l[k]=0;

  for (i=0; i < n ; i++)

  ...{

    k=(long)floor(c1*(a[i]-c2) );//下整

    l[k]+=1;

   }

   for (k=1; k < m ; k++) l[k]+=l[k-1];


   hold=a[nmax];

   a[nmax]=a[0];

   a[0]=hold; 

  /**//**** PERMUTATION *****/
   nmove=0;

   j=0;

   k=m-1;

   while ( nmove <  n )

   ...{

      while  ( j  >  l[k] )

      ...{

    j++;

    k=(long)floor(c1*(a[j]-c2) ) ;

      }

      flash=a[ j ] ;
      while ( j <= l[k] )

      ...{

    k=(long)floor(c1*(flash-c2));

    hold=a[ l[k] ];

    a[ l[k] ] = flash;

    l[k]--;

    flash=hold;

    nmove++;

      }

   }

 /**//**** Choice of RECURSION or STRAIGHT INSERTION *****/
  for (k=0;k<(m-1);k++)

   if ( (nx = l[k+1]-l[k]) > THRESHOLD )  /**//* then use recursion */

   ...{

      Flash(&a[l[k]+1],nx,CLASS_SIZE,ctr);

      (*ctr)++;

   }

   else  /**//* use insertion sort */

      for (i=l[k+1]-1; i > l[k] ; i--)

      if (a[i] > a[i+1])

      ...{

         hold=a[i];

         j=i;

         while  (hold  >  a[j+1] )  a[j++]=a[j+1] ;

         a[j]=hold;

      }

  free(l);   /**//* need to free the memory we grabbed for the l vector */
}

void  FlashSort(Element d[], ArraySize n)
... {
    int m=n, ctr;
    Flash(d, n, m, &ctr);
}