Java实现常见的排序算法

前言

算法对于工程师来说，是很重要的知识，能直接体现一个人的逻辑思维能力。鉴于此，我实现了常用的几种排序算法，用来加深记忆。

排序算法

冒泡排序

/**
  * 冒泡排序：升序
  *
  * @param array
  * @return
  */
 public static int[] bubbleSortAsc(int[] array) {
     if (array.length == 0) {
         return array;
     }
     for (int i = 0; i < array.length; i++) {
         for (int j = 0; j < array.length - 1 - i; j++) {
             if (array[j] > array[j + 1]) {
                 int temp = array[j];
                 array[j] = array[j + 1];
                 array[j + 1] = temp;
             }
         }
     }
     return array;
 }

选择排序

/**
  * 选择排序：升序
  *
  * @param array
  * @return
  */
 public static int[] selectionSortAsc(int[] array) {
     if (array.length == 0) {
         return array;
     }
     for (int i = 0; i < array.length; i++) {
         int minIndex = i;
         for (int j = i; j < array.length; j++) {
             if (array[j] < array[minIndex]) {
                 minIndex = j;
             }
         }
         int temp = array[minIndex];
         array[minIndex] = array[i];
         array[i] = temp;
     }
     return array;
 }

插入排序

/**
  * 插入排序：升序
  *
  * @param array
  * @return
  */
 public static int[] insertSortAsc(int[] array) {
     if (array.length == 0) {
         return array;
     }
     for (int i = 1; i < array.length; i++) {
         int cur = array[i];
         int index = i - 1;
         while (index >= 0 && array[index] > cur) {
             int temp = array[index];
             array[index] = cur;
             array[index + 1] = temp;
             index--;
         }
     }
     return array;
 }

归并排序

 /**
   * 归并排序：升序
   *
   * @param array
   * @return
   */
  public static int[] mergeSortAsc(int[] array) {
      if (array.length < 2) {
          return array;
      }
      int mid = array.length / 2;
      int[] left = mergeSortAsc(Arrays.copyOfRange(array, 0, mid));
      int[] right = mergeSortAsc(Arrays.copyOfRange(array, mid, array.length));
      for (int i = 0, leftIndex = 0, rightIndex = 0; i < array.length; i++) {
          if (leftIndex >= left.length) {
              array[i] = right[rightIndex++];
          } else if (rightIndex >= right.length) {
              array[i] = left[leftIndex++];
          } else if (left[leftIndex] >= right[rightIndex]) {
              array[i] = right[rightIndex++];
          } else {
              array[i] = left[leftIndex++];
          }
      }
      return array;
  }

快速排序

/**
  * 快速排序：升序
  *
  * @param array
  * @param start
  * @param end
  * @return 分区指示器位置
  */
 public static int[] quickSortAsc(int[] array, int start, int end) {
     if (array.length < 1 || start < 0 || end >= array.length || start > end) {
         return null;
     }
     int zoneIndex = partition(array, start, end);
     if (zoneIndex > start) {
         quickSortAsc(array, start, zoneIndex - 1);
     }
     if (zoneIndex < end) {
         quickSortAsc(array, zoneIndex + 1, end);
     }
     return array;
 }

 private static int partition(int[] array, int start, int end) {
     int pivot = (int) (start + Math.random() * (end - start + 1));
     int zoneIndex = start - 1;
     swap(array, pivot, end);
     for (int i = start; i <= end; i++) {
         if (array[i] <= array[end]) {
             zoneIndex++;
             if (i > zoneIndex) {
                 swap(array, i, zoneIndex);
             }
         }
     }
     return zoneIndex;
 }

 private static void swap(int[] array, int i, int j) {
     int temp = array[i];
     array[i] = array[j];
     array[j] = temp;
 }

结束语

学无止境，诸君共勉