常用排序算法归纳总结

1 直插排序

#include <stdio.h>

void insertSort(int array[], int arraySize) {
  int i, j, tmp;

  for (i = 1; i < arraySize; i++) {
    tmp = array[i]; //临时保存
    j = i - 1;
    while (j >= 0 && tmp < array[j]) { //和前一个取比较  循环找到该放的位置
      array[j + 1] = array[j];
      j--;
    }
    array[j + 1] = tmp; //插入指定的位置
  }
  return;
}

int main() {
  int a[10] = {0};

  for (int i = 0; i < 10; i++) {
    scanf("%d", &a[i]);
  }

  insertSort(a, 10);

  for (int i = 0; i < 10; i++) {
    printf("%d  ", a[i]);
  }
}

2 冒泡排序

#include <stdio.h>

void bubbleSort(int array[], int len) {
  int tmp;
  for (int i = 0; i < len; i++) {
    for (int j = 1; j < len - i - 1; j++) {

      if (array[j] > array[j + 1]) {
        /*交换位置*/
        tmp = array[j];
        array[j] = array[j + 1];
        array[j + 1] = tmp;
      }
    }
  }
}

int main() {

  int a[10] = {0};

  for (int i = 0; i < 10; i++) {

    scanf("%d", &a[i]);
  }

  bubbleSort(a, 10);

  for (int i = 0; i < 10; i++) {

    printf("%d  ", a[i]);
  }
}

快速排序

#include <stdio.h>
void swap(int *a, int *b) {
  int tmp;
  tmp = *a;
  *a = *b;
  *b = tmp;
}
void quicksortArray(int array[], int s, int t) {
  int low, high;
  if (s < t) {
    low = s;
    high = t + 1;
    while (1) {
      do
        low++;
      while (array[low] >= array[s] && low != t);
      do
        high--;
      while (array[high] <= array[s] && high != s);
      if (low < high) {
        swap(&array[low], &array[high]);
      } else
        break;
    }
    swap(&array[s], &array[high]);
    quicksortArray(array, s, high - 1);
    quicksortArray(array, high + 1, t);
  }

  return;
}

void quicksort(int array[], int arraySize) {
  quicksortArray(array, 0, arraySize - 1);
}

int main() {
  int a[10] = {3, 9, 2, 1, 6, 8, 10, 7};
  /*
    for (int i = 0; i < 10; i++) {
      scanf("%d", &a[i]);
    }
  */
  quicksort(a, sizeof(a) / sizeof(a[0]));

  for (int i = 0; i < 10; i++) {
    printf("%d  ", a[i]);
  }
}

希尔排序

#include <stdio.h>

void shellsort(int array[], int arraySize) {
  int i, j, flag, tmp, gap = arraySize;

  while (gap > 1) {
    gap = gap / 2;
    do {
      flag = 0;
      for (int i = 0; i < arraySize - gap; i++) {
        j = i + gap;
        if (array[i] > array[j]) {
          tmp = array[j];
          array[j] = array[i];
          array[i] = tmp;
          flag = 1;
        }
      }

    } while (flag != 0);
  }

  return;
}

int main() {
  int a[10] = {1, 2, 6, 8, 9, 5, 6, 10, 15, 20};
  /*
    for (int i = 0; i < 10; i++) {
      scanf("%d", &a[i]);
    }
  */
  shellsort(a, 10);

  for (int i = 0; i < 10; i++) {
    printf("%d  ", a[i]);
  }
}

简单选择排序

#include <stdio.h>

void selectSort(int array[], int arraySize) {
  int i, j, tmp;

  for (i = 0; i < arraySize - 1; i++) {
    int min = i;
    /*未排序的子序列中寻找最小的元素位置*/
    for (j = i + 1; j < arraySize; j++) {
      if (array[j] > array[min]) {
        min = j;
      }
    }
    /*最小的元素不是未排序子序列的第一个元素，那就交换*/
    if (min != i) {
      tmp = array[min];
      array[min] = array[i];
      array[i] = tmp;
    }
  }
  return;
}

int main() {
  int a[10] = {8, 1, 5, 6, 7, 8, 9, 3, 2, 5};
  /*
    for (int i = 0; i < 10; i++) {
      scanf("%d", &a[i]);
    }
  */
  selectSort(a, 10);

  for (int i = 0; i < 10; i++) {
    printf("%d  ", a[i]);
  }
}

库函数qsort排序

#include <stdio.h>
#include <stdlib.h>

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

int main() {
  int a[10] = {1, 2, 6, 8, 9, 5, 6, 10, 15, 20};
  /*
for (int i = 0; i < 10; i++) {
  scanf("%d", &a[i]);
}
*/
  qsort(a, sizeof(a) / sizeof(a[0]), sizeof(a[0]), compfun);

  for (int i = 0; i < 10; i++) {
    printf("%d  ", a[i]);
  }
}

总结：直插和冒泡的排序速度比较慢，但如果数据最开始是基本有序的，反而效果不错。
元素个数越少，则使用冒泡，直插效果，后者简单选择 比较好。
元素个数比较多，则需要使用希尔，快速排序比较合适。
从稳定性来说，直插，冒泡是稳定性排序算法。
简单选择，希尔，快速，是不稳定排序。