java实现冒泡排序和快速排序

用java实现了冒泡排序和快速排序，冒泡还是比较简单的，但快速排序采坑了，网上有很多代码是有问题的，最后通过分析和实践，终于弄明白了，分享出来以供大家一起学习~~

快速排序写了2种实现方法，原理都是一样的，快排的平均时间复杂度是O(N*logN)

实现思路：（基于递归实现）
1.选一个值作为中轴（理想情况选中值最好，但一般使用数组的第一个值）。
2.基于中轴，将数组分为两部分，较小的分在左边，较大的分在右边。
3.对两个子数组分别重复上述过程进行排序。

import java.util.ArrayList;
import java.util.Arrays;

/**
 * Created by admin on 2017/12/8.
 */
public class SortArray {
    public static void main(String[] args) {
        final int[] arr1 = {3, 12, 3, 15, 2, 89, 45};
        final int[] arr2 = {3, 12, 3, 15, 2, 89, 45};
        final int[] arr3 = {3, 12, 3, 15, 2, 89, 45};
        //调用冒泡
        int[] sortResult1 = sort1(arr1);
        //调用快速
        int start = 0;
        int end = arr2.length-1;
        int[] sortResult2 = quickSort(arr2,start,end);
        int[] sortResult3 = quickSort2(arr3, start, end);

        System.out.println(Arrays.toString(sortResult1));
        System.out.println(Arrays.toString(sortResult2));
        System.out.println(Arrays.toString(sortResult3));
    }

    //冒泡排序 从大到小
    public static int[] sort1(int[] arr){
        for (int i = arr.length-1; i > 0; i--){
            for (int j=0; j<i; j++){
                if (arr[j]<arr[j+1]){
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }

    //快速排序方法一
    private static int[] quickSort(int[] arr, int low, int high){
        if (low < high){
            int index = partitions(arr, low, high);
            quickSort(arr, low, index-1); //递归排序左子数组
            quickSort(arr, index+1, high); //递归排序右子数组
        }
        return arr;
    }
    public static int partitions(int[] arr, int low, int high){
        //arr2 = {3, 12, 3, 15, 2, 89, 45}
        int index = arr[low]; //中轴
        while (low < high){
            while (low < high && arr[high] >= index)
                high--; //arr[high]一直大于index，那么就一直减小high
            arr[low] = arr[high];  //直到遇到比index小的值 交换到左端

            while (low < high && arr[low] <= index)
                low++;  //arr[low]一直小于index，那么就一直增大low
            arr[high] = arr[low];  //直到遇到比index大的值 交换到右端
        }
        arr[low] = index;
        //返回的是中轴的位置
        return low;
    }

    //快速排序方法二
    public static int[] quickSort2(int[] arr,int l,int r){
        if(l>=r)
            return arr;
        int i = l; int j = r; int key = arr[l];//选择第一个数为key
        while(i<j){
            while(i<j && arr[j]>=key)//从右向左找第一个小于key的值
                j--;
            if(i<j){
                arr[i] = arr[j];
                i++;
            }
            while(i<j && arr[i]<key)//从左向右找第一个大于key的值
                i++;
            if(i<j){
                arr[j] = arr[i];
                j--;
            }
        }
        arr[i] = key;
        quickSort2(arr, l, i-1);//递归调用
        quickSort2(arr, i+1, r);//递归调用
        return arr;
    }
}