排序算法 C语言实现 总结

个人在学习算法时总结的部分代码

头文件Sort.h

#ifndef _SORT_H_
#define _SORT_H_

#include <stdio.h>
#include "time.h"
#include "stdlib.h"
#include "ASSERT.h"
#include "arithmetic.h"

typedef   int     TYPE;

    void insertionSort(int arr[],TYPE n);
    void insertionSort2(int arr[],TYPE l,TYPE r);
    void selectionSort(int arr[],TYPE n);
    void mergeSort(int arr[],TYPE n);
    void mergeSortBU(int arr[],TYPE n);
    void quickSort(int arr[],TYPE n);
    void quickSort2(int arr[],TYPE n);
    void quickSort3ways(int arr[],TYPE n);

#endif

C文件 Sort.c

#include "Sort.h"
/*********************************************
*函数名：插入排序算法（在近乎顺序数组速度极快）
*********************************************/
void insertionSort(int arr[],TYPE n){
    TYPE i,j;

  for(i = 1; i<n ;i++){
    //寻找元素arr[i]合适的插入位置

    for(j = i; j>0 && arr[j-1] > arr[i];j--){    //判断是否比前一个元素大，是则向后移动
      arr[j] = arr[j-1];
    }
    arr[j] = arr[i];
  }
}

void insertionSort2(int arr[],TYPE l,TYPE r){
    TYPE i,j;

  for(i = l; i<=r ;i++){
    //寻找元素arr[i]合适的插入位置
    int e = arr[i];
    for(j = i; j>0 && arr[j-1] > e;j--){    //判断是否比前一个元素大，是则向后移动
      arr[j] = arr[j-1];
    }
    arr[j] = e;
  }
}


/*********************************************
*函数名：选择排序算法
*********************************************/
void selectionSort(int arr[],TYPE n){
    TYPE i,j,minIndex;
    //TYPE tmp;
  for(i = 1; i<n ;i++){
        minIndex = i;
    for(j = i+1; j<n && arr[j] < arr[minIndex];j++){    //找到当前最小值并储存索引
        minIndex = j;

//              tmp = arr[i];                                   //将i的元素和minIndex的元素值交换
//              arr[i] = arr[minIndex];
//              arr[minIndex] = tmp;
      swap(&arr[i],&arr[minIndex]);
    }
  }
}


/*********************************************
*函数名：归并排序（多使用存储空间）
*********************************************/
//将arr[l..mid]和arr[mid+1..r]两个部分进行归并
void __merge(int arr[],TYPE l,TYPE mid,TYPE r){
  int aux[r-l+1];
  TYPE i,j,k;
  for(k = l; k<=r; k++){
    aux[k-l] = arr[k];
  }
  i = l;j = mid + 1;
  for(k = l;k <= r;k++){
    //判断数组索引的合法性
    if(i > mid){
      arr[k] = aux[j-l];
      j++;
    }
    else if(j > r){
      arr[k] = aux[i-l];
      i++;
    }
    else if(aux[i-l] < aux[j-l]){
      arr[k] = aux[i-l];
      i++;
    }
    else{
      arr[k] = aux[j-l];
      j++;
    }
  }
}
//递归使用归并排序，对arr[l..r]的范围进行排序
void __mergeSort(int arr[],TYPE l,TYPE r){
  TYPE mid;
  if(l >= r){
    return ;
  }
//  //代码的优化，当数量很少时采用插入排序算法优化时间
//  if(r-l <=15){
//    insertionSort2(arr,l,r);
//    return;
//  }
  mid = (l+r)/2;
  __mergeSort(arr,l,mid);
  __mergeSort(arr,mid+1,r);
  if(arr[mid] > arr[mid+1]){
    __merge(arr,l,mid,r);
  }

}
//自顶向下的递归算法
void mergeSort(int arr[],TYPE n){
    __mergeSort(arr,0,n-1);
}
//自底向上的递归算法
void mergeSortBU(int arr[],TYPE n){
  TYPE size,i;
  for(size = 1;size <= n ;size += size){
    for(i = 0;i + size < n;i += size + size){
      //对arr[i..i+size-1]和arr[i+size..i+2*size-1]进行递归
      __merge(arr,i,i+size-1,min(i+size+size-1,n-1));
    }
  }
}
/*********************************************
*函数名：快速排序
*********************************************/
//对arr[l..r]部分进行partition操作
//返回p,使得arr[l..p-1]<arr[p];arr[p+1..r]>arr[p]
TYPE __partition(int arr[],TYPE l,TYPE r){
  TYPE i,j=l;
  //TYPE tmp;

  //使用前需要更新种子，否则产生的是伪随机数
//  tmp = arr[rand()%(r-l+1)+l];
//  arr[rand()%(r-l+1)+l] = arr[l];
//  arr[l] = tmp;
  swap(&arr[l],&arr[rand()%(r-l+1)+l]);

  int v = arr[l];

  //arr[l+1..j] < v ; arr[j+1..i] >v
  for(i = l+1; i<=r ;i++){
    if(arr[i] < v){
//      tmp = arr[i];
//      arr[i] = arr[j+1];
//      arr[j+1] = tmp;
      swap(&arr[i],&arr[j+1]);
      j++;
    }
  }

//  tmp = arr[l];
//  arr[l] = arr[j];
//  arr[j] = tmp;
  swap(&arr[l],&arr[j]);

  return j;
}
//对arr[l..r]部分进行快速排序
void __quickSort(int arr[],TYPE l,TYPE r){
  if(l >= r) return;
//  //代码的优化，当数量很少时采用插入排序算法优化时间
//  if(r-l <=15){
//    insertionSort2(arr,l,r);
//    return;
//  }
  TYPE p;
  p = __partition(arr,l,r);
  __quickSort(arr,l,p-1);
  __quickSort(arr,p+1,r);
}
void quickSort(int arr[],TYPE n){
  //srand(time(0));   //有的编译器报错，与上面的配合可以提高效率
  __quickSort(arr,0,n-1);
}



/*********************************************
*函数名：快速排序2
*********************************************/
//对arr[l..r]部分进行partition操作
//返回p,使得arr[l..p-1]<arr[p];arr[p+1..r]>arr[p]
TYPE __partition2(int arr[],TYPE l,TYPE r){
  TYPE i,j;
  //TYPE tmp;

  //使用前需要更新种子，否则产生的是伪随机数
//  tmp = arr[rand()%(r-l+1)+l];
//  arr[rand()%(r-l+1)+l] = arr[l];
//  arr[l] = tmp;
  swap(&arr[l],&arr[rand()%(r-l+1)+l]);

  int v = arr[l];

  //arr[l+1..i] <= v; arr[j..r] >= v
  i = l+1; j=r;
  while(1){
    while(i <=r && arr[i] < v) i++;
    while(j >= l+1 && arr[j] > v) j--;
    if(i > j) break;

//    tmp = arr[i];
//    arr[i] = arr[j];
//    arr[j] = tmp;
    swap(&arr[i],&arr[j]);

    i++;
    j--;
  }
//  tmp = arr[l];
//  arr[l] = arr[j];
//  arr[j] = tmp;
  swap(&arr[l],&arr[j]);

  return j;
}
//对arr[l..r]部分进行快速排序
void __quickSort2(int arr[],TYPE l,TYPE r){
  if(l >= r) return;
//  //代码的优化，当数量很少时采用插入排序算法优化时间
//  if(r-l <=15){
//    insertionSort2(arr,l,r);
//    return;
//  }
  TYPE p;
  p = __partition2(arr,l,r);
  __quickSort2(arr,l,p-1);
  __quickSort2(arr,p+1,r);
}
void quickSort2(int arr[],TYPE n){
  //srand(time(0));   //有的编译器报错，与上面的配合可以提高效率
  __quickSort2(arr,0,n-1);
}

/*********************************************
*函数名：三路快速排序算法
*********************************************/
//三路快速排序处理arr[l..r]
//将arr[l..r]分为 <v ; ==v ; >v 三部分
//之后递归对<v ; >v两个部分继续进行三路快速排序
void __quickSort3ways(int arr[],TYPE l,TYPE r){
  if(l >= r) return;
//  //代码的优化，当数量很少时采用插入排序算法优化时间
//  if(r-l <=15){
//    insertionSort2(arr,l,r);
//    return;
//  }

  //partition
  swap(&arr[l],&arr[rand()%(r-l+1)+l]);
  int v = arr[l];

  TYPE lt = l; //arr[l+1..lt] < v
  TYPE gt = r + 1; //arr[gt..r] > v
  TYPE i = l+1;    //arr[lt+1..i) == v
  while(i < gt){
    if(arr[i] < v){
      swap(&arr[i],&arr[lt + 1]);
      lt++;
      i++;
    }
    else if(arr[i] > v){
      swap(&arr[i],&arr[gt - 1]);
      gt--;
    }
    else{
      i++;
    }
  }
  swap(&arr[l],&arr[lt]);

  __quickSort3ways(arr,l,lt-1);
  __quickSort3ways(arr,gt,r);




}
void quickSort3ways(int arr[],TYPE n){
  //srand(time(0));   //有的编译器报错，与上面的配合可以提高效率
  __quickSort3ways(arr,0,n-1);
}