几种常用的排序算法

冒泡排序

冒泡排序是一种稳定的排序算法。算法的稳定性是指两个相同的数据在经历过排序后数据的位置没有发生变化。

	int n = array.length;
    // 这里设个标志位，当没有位置交换时，代表已经排好序，可以退出循环
    boolean flag = false;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n - i - 1; j++) {
        if (array[j] > array[j + 1]) {
          int temp = array[j + 1];
          array[j + 1] = array[j];
          array[j] = temp;
          flag = true;
        }
      }
      if (!flag) break;
    }

插入排序

	int n = array.length;
    for (int i = 1; i < n; i++) {
      int value = array[i];
      int j = i - 1;
      for (; j >= 0; j--) {
        if (array[j] > value) {
          array[j + 1] = array[j];
        } else {
          break;
        }
      }
      array[j + 1] = value;
    }

选择排序

	int n = array.length;
    for (int i = 0; i < n - 1; i++) {
      int index = i;
      for (int j = i; j < n - 1; j++) {
        if (array[j] < array[index]) {
          index = j;
        }
      }
      int temp = array[index];
      array[index] = array[i];
      array[i] = temp;
    }
    
    

快速排序

public void quickSort(int[] array) {
    int n = array.length;
    quickSortArray(array, 0, n - 1);
  }

  private void quickSortArray(int[] array, int low, int high) {
    if (low >= high) return;
    int index = findMidIndex(array, low, high);
    quickSortArray(array, low, index - 1);
    quickSortArray(array, index + 1, high);
  }

  private int findMidIndex(int[] array, int low, int high) {
    int temp = array[high];
    int m = low;
    for (int i = low; i < high; i++) {
      if (array[i] > temp) {
        int n = temp;
        temp = array[i];
        array[i] = temp;
        m++;
      }
    }

    int k = temp;
    array[m] = temp;
    array[high] = k;
    return m;
  }