写一下冒泡排序

public class Sort1207 {

    public static void main(String[] args) {
        int[] nums = {5, 8, 6, 3, 9, 2, 1, 7};
        bubbleSort(nums);
        System.out.println(Arrays.toString(nums));
    }


    /**
     * 冒泡排序
     * 首先从最左边的元素开始，与右边紧挨着的元素进行比较，如果是从小到大排序的话，
     * 那么当元素比右边的元素小时，不做处理，游标向右移一位，
     * 如果元素比游标的元素大，那么就与右边的元素交换，也就是大的向后移，
     * 以此类推，大的元素依次向右移动
     * 当完成一轮移动后，整个数组最大的元素已经是在数组的最右边了，
     * 那么我们继续下一轮的移动，也就是冒泡，但是下一轮不需要移动最右边的元素了，所以我们在里层循环用了-i的操作
     * (优化之处是安排了一个sortFlag，如果发现有一轮冒泡中一次都不用交换元素，那么证明整个数组已经是有序的了，
     * 直接跳出循环，完成数组的排序)
     * @param data
     */
    public static void bubbleSort(int[] data){
        //冒泡的轮次,总共是有data.length - 1轮冒泡
        for(int i=0;i<data.length-1;i++){
            boolean sortFlag = false;
            //每轮冒泡的对比交换操作，每次产出一个元素放在右侧(冒泡)
            for(int j=0;j<data.length-1-i;j++){

                if(data[j]>data[j+1]){
                    data[j] = data[j] + data[j+1];
                    data[j+1] = data[j] - data[j+1];
                    data[j] = data[j] - data[j+1];
                    sortFlag =true;
                }

            }
            if(!sortFlag){
                break;
            }
        }
    }

}

 /**
     * 快速排序（双边循环法）
     * @param nums
     * @param start
     * @param end
     */
    public static void quickSortTest(int[] nums,int start ,int end){
        if(start >= end){
            return ;
        }

        int provite =  provite(nums,start,end);
        quickSortTest(nums,start,provite-1);
        quickSortTest(nums,provite+1,end);

    }

    private static int provite(int[] nums, int start, int end) {
        int left = start;
        int provite =  nums[start];
        while(start!=end){
            while(start<end && nums[end]>provite){
                end--;
            }
            while(start<end && nums[start]<=provite){
                start++;
            }

            if(start<end){
                int tmp =  nums[start];
                nums[start] = nums[end];
                nums[end] = tmp;
            }

        }
        int tmp = nums[left];
        nums[left] = nums[start];
        nums[start] =  tmp;

        return start;
    }

//快速排序(单边循环法)
    private static void quickSort2Test(int[] arr, int start, int end) {
        if(start >= end){
            return ;
        }

        int pivot = pivot(arr,start,end);
        quickSort2Test(arr,start,pivot-1);
        quickSort2Test(arr,pivot+1,end);
    }

    private static int pivot(int[] arr, int start, int end) {
        int pivod =  arr[start];
        int mark = start;
        for(int i=start+1;i<=end;i++){
            if(arr[i]<pivod){
                mark++;
                int tmp = arr[i];
                arr[i] = arr[mark];
                arr[mark] = tmp;
            }
        }
        arr[start] = arr[mark];
        arr[mark] = pivod;
        return mark;
    }

//计数排序    
private static int[] countSort(int[] arr,int offset){
        int[] tempArr =  new int[arr.length];
        for(int i = 0;i<arr.length;i++){
            int index = arr[i]-offset;
            tempArr[index]++;
        }
        int[] res =  new int[arr.length];
        for(int i=0,k=0;i<tempArr.length;i++){
            for(int j=0;j<tempArr[i];j++){
                res[k++] = offset+i;
            }
        }
        return res;
    }

    /**
     * 桶排序
     * @param arr
     * @return
     */
    private static double[] bucketSort(double[] arr){
        ArrayList<LinkedList<Double>> buckets =new ArrayList<>(arr.length);
        for (int i = 0; i < arr.length; i++) {
            buckets.add(new LinkedList<Double>());
        }
        double max = arr[0];
        double min = arr[0];
        for(int i = 0;i<arr.length;i++){
            if(max<arr[i]){
                max =  arr[i];
            }
            if(min > arr[i]){
                min =  arr[i];
            }
        }
        double d =  max -  min;
        for(int i=0;i<arr.length;i++){
            double item = arr[i];
            int bucketNum =  (int)((item - min)/d*(arr.length-1));
            buckets.get(bucketNum).add(item);
        }
        for(int i=0;i<buckets.size();i++){
            Collections.sort(buckets.get(i));
        }
        double [] res = new double[arr.length];
        int index =0;
        for(int i=0;i<buckets.size();i++){
            LinkedList<Double> itemList=  buckets.get(i);
            for(Double item:itemList){
                res[index++] = item;
            }
        }
        return res;
    }