快速排序、歸併排序、選擇排序和插入排序的Java實現

• 快速排序

    快速排序使用分治法（Divide and conquer）策略來把一個串行（list）分爲兩個子串行（sub-lists）。

快速排序又是一種分而治之思想在排序算法上的典型應用。本質上來看，快速排序應該算是在冒泡排序基礎上的遞歸分治法。

在平均狀況下，排序 n 個項目要 Ο(nlogn) 次比較。在最壞狀況下則需要 Ο(n2) 次比較，但這種狀況並不常見。事實上，快速排序通常明顯比其他 Ο(nlogn) 算法更快，因爲它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。

實現快速排序的主要邏輯：

1、確定值比較的起始以及基準值

2、左區間快排

3、右區間快排

4、遞歸至排序完成

Java實現：

public static void quickSortFromSmallToLarge(int[] arr, int low, int high){
      int left,right,pivot,temp;
      if(low>high){
         return;
      }
      left=low;
      right=high;
      pivot = arr[low];

      while (left<right) {
         //左遞減
         while (pivot<=arr[right]&&left<right) {
            right--;
         }
         //右遞增
         while (pivot>=arr[left]&&left<right) {
            left++;
         }
         if (left<right) {
            temp = arr[right];
            arr[right] = arr[left];
            arr[left] = temp;
         }
      }
      arr[low] = arr[left];
      arr[left] = pivot;
      quickSortFromSmallToLarge(arr, low, right-1);
      quickSortFromSmallToLarge(arr, right+1, high);
   }

• 歸併排序

    歸併排序（Merge sort）是建立在歸併操作上的一種有效的排序算法。該算法是採用分治法（Divide and Conquer）的一個非常典型的應用。

作爲一種典型的分而治之思想的算法應用，歸併排序的實現由兩種方法：

自上而下的遞歸（所有遞歸的方法都可以用迭代重寫，所以就有了第 2 種方法）；
自下而上的迭代

public static int[] mergeSortFromSmallToLarge(int[] array) {
        int[] arr = Arrays.copyOf(array, array.length);

        if (arr.length < 2) {
            return arr;
        }
        int middle = (int) Math.floor(arr.length / 2);

        int[] left = Arrays.copyOfRange(arr, 0, middle);
        int[] right = Arrays.copyOfRange(arr, middle, arr.length);

        return merge(mergeSortFromSmallToLarge(left), mergeSortFromSmallToLarge(right));
    }

    public static int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        int i = 0;
        while (left.length > 0 && right.length > 0) {
            if (left[0] <= right[0]) {
                result[i++] = left[0];
                left = Arrays.copyOfRange(left, 1, left.length);
            } else {
                result[i++] = right[0];
                right = Arrays.copyOfRange(right, 1, right.length);
            }
        }

        while (left.length > 0) {
            result[i++] = left[0];
            left = Arrays.copyOfRange(left, 1, left.length);
        }

        while (right.length > 0) {
            result[i++] = right[0];
            right = Arrays.copyOfRange(right, 1, right.length);
        }

        return result;
    }

• 選擇排序

    選擇排序是一種簡單直觀的排序算法，無論什麼數據進去都是 O(n²) 的時間複雜度。所以用到它的時候，數據規模越小越好。唯一的好處可能就是不佔用額外的內存空間了吧。

1. 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

2. 再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。

3. 重複第二步，直到所有元素均排序完畢。

Java實現如下：

    public static void  selecrSortFromSmallToLarge(int [] array,int index){
       if (index>=array.length){
           return;
       }
        int small=array[index];
       for (int i=index;i<array.length;i++){
           if (array[i]<small){
               int temp=array[i];
               array[i]=small;
               small=temp;
           }
       }
       array[index]=small;
       index++;
       selecrSortFromSmallToLarge(array,index);
    }

• 插入排序

插入排序是一種最簡單直觀的排序算法，它的工作原理是通過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。

1. 將第一待排序序列第一個元素看做一個有序序列，把第二個元素到最後一個元素當成是未排序序列。

2. 從頭到尾依次掃描未排序序列，將掃描到的每個元素插入有序序列的適當位置。（如果待插入的元素與有序序列中的某個元素相等，則將待插入元素插入到相等元素的後面。）

java實現：

   public static  void insertSortFromSmallToLarge(int[] array){
        for(int i = 1;i < array.length;i++) {
            int temp = array[i];
            int index = i-1;
            while(index >= 0 && array[index] > temp) {
                array[index + 1] = array[index];
                index--;
            }
            array[index+1] = temp;

        }
    }

    public static void insertSortFromlargeToSmall(int[] array){

        for (int i=1;i<array.length;i++){
            int index=i-1;
            int temp=array[i];
            while (index>=0&&temp>array[index]){
                array[index+1]=array[index];
                index--;
            }
            array[index+1]=temp;
        }
    }