幾種排序和二分查找算法

插入排序

  /**
   * 插入排序
   *
   * @param arr array
   */
  static void insertSort(int[] arr) {
    for (int i = 1; i < arr.length; ++i) {
      for (int j = i; j > 0 && arr[j] < arr[j - 1]; --j) {
        arr[j] ^= arr[j - 1];
        arr[j - 1] ^= arr[j];
        arr[j] ^= arr[j - 1];
      }
    }
  }

冒泡排序

  /**
   * 冒泡排序
   *
   * @param arr array
   */
  static void mSort(int[] arr) {
    if (arr == null || arr.length <= 1) return;
    for (int i = 0; i < arr.length; ++i) {
      for (int j = 0; j < arr.length - i - 1; ++j) {
        if (arr[j] > arr[j + 1]) {
          arr[j] ^= arr[j + 1];
          arr[j + 1] ^= arr[j];
          arr[j] ^= arr[j + 1];
        }
      }
    }
  }

歸併排序

/**
   * 歸併排序
   *
   * @param arr array [2,4,5,3,6]
   * @param start 0
   * @param end array.length - 1
   */
  static void mergeSort(int[] arr, int start, int end) {
    if (start >= end) return;
    int mid = start + (end - start) / 2;
    mergeSort(arr, start, mid);
    mergeSort(arr, mid + 1, end);
    merge(arr, start, mid, end);
  }

  static void merge(int[] arr, int start, int mid, int end) {
    int i = start, j = mid + 1, aux[] = new int[end - start + 1];
    for (int k = start; k <= end; k++) aux[k - start] = arr[k];
    for (int k = start; k <= end; k++) {
      if (i > mid) arr[k] = aux[j++ - start];
      else if (j > end) arr[k] = aux[i++ - start];
      else if (aux[i - start] > aux[j - start]) arr[k] = aux[j++ - start];
      else arr[k] = aux[i++ - start];
    }
  }

快速排序

  /**
   * 快速排序
   *
   * @param arr array [1,2,4,3]
   * @param begin 0
   * @param end array.length - 1
   */
  static void qSort(int[] arr, int begin, int end) {
    if (arr == null || begin > end) return;
    int l = begin, h = end, key = arr[begin];
    while (l != h) {
      while (l < h && key <= arr[h]) --h;
      while (l < h && key >= arr[l]) ++l;
      if (l < h) {
        arr[l] ^= arr[h];
        arr[h] ^= arr[l];
        arr[l] ^= arr[h];
      }
    }
    arr[begin] = arr[l];
    arr[l] = key;
    qSort(arr, begin, l - 1);
    qSort(arr, l + 1, end);
  }

二分查找

  /**
   * 二分查找
   *
   * @param arr array
   * @param tar 目標
   * @return -1 未找到
   */
  static int bSearch(int[] arr, int tar) {
    if (arr == null || arr.length == 0) return -1;
    int l = 0, h = arr.length - 1;
    while (l <= h) {
      int m = l + (h - l) >> 1;
      if (arr[m] > tar) h = m - 1;
      if (arr[m] < tar) l = m + 1;
      if (arr[m] == tar) return m;
    }
    return -1;
  }