快速排序、归并排序、选择排序和插入排序的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;
        }
    }