常用排序算法

冒泡排序

public class Dubble {

    public static void main(String[] args) {
        int [] array = new int[]{3,5,6,3,5,2,123,1,34,1};
        array = bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }

    private static int[] bubbleSort(int[] array) {
        if(array.length==0){
            return array;
        }
        int lastExchangeIndex = 0;
        int sortedIndex = array.length -1;
        for (int i = 0; i < array.length-1; i++) {
            boolean flag = true;
            for (int j = 0; j < sortedIndex; j++) {
                if(array[j+1]<array[j]){

                    int temp = array[j+1];
                    array[j+1]= array[j];
                    array[j] = temp;
                    flag =false;
                    lastExchangeIndex = j;
                }
            }
            sortedIndex = lastExchangeIndex;
            if(flag){
                break;
            }
        }
        return array;

    }
}

选择排序

public class SelectionSort {
    public static void main(String[] args) {
        int [] array = new int[]{3,5,6,3,5,2,123,1,34,1};
        array = selectionSort(array);
        System.out.println(Arrays.toString(array));
    }

    private static int[] selectionSort(int[] array) {
        for (int i = 0; i < array.length-1; i++) {
            int min =i;
            for (int j = i+1; j < array.length; j++) {
                if(array[j]<array[min]){
                    min = j;
                }
            }
            int temp = array[i];
            array[i] = array[min];
            array[min] = temp;
        }
        return array;
    }
 }

插入排序

public class InsertionSort {
    public static void main(String[] args) {
        int [] array = new int[]{3,5,6,3,5,2,123,1,34,1};
        array = insertionSort(array);
        System.out.println(Arrays.toString(array));
    }

    private static int[] insertionSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int temp = array[i];
            int sortedIndex = i -1;
            while(sortedIndex>= 0 && array[sortedIndex]>temp){
                array[sortedIndex+1] = array[sortedIndex];
                sortedIndex--;
            }
            array[sortedIndex+1] = temp;
        }
        return array;
    }
}

快速排序

public class QuickSort {

    public static void main(String[] args) {
        int [] array = new int[]{23,3,89,5,6,3,5,2,123,1,34,};
        quickSort(array,0,array.length-1);
        System.out.println(Arrays.toString(array));
    }

    private static void quickSort(int[] array, int start, int end) {
        if(start>=end){
            return ;
        }
        int pivotIndex = danbianpivot(array,start,end);
        quickSort(array,start,pivotIndex-1);
        quickSort(array,pivotIndex+1,end);
    }

    /**
     * 双边
     * @param array
     * @param start
     * @param end
     * @return
     */
    private static int pivot(int[] array, int start, int end) {
        if(start >= end){
            return start;
        }
        int left = start;
        int right = end;
        int pivot = array[start];
        while(left < right){
            while(left < right && array[right]>=pivot){
                right--;
            }
            while(left < right && array[left]<=pivot){
                left++;
            }
            if(left<right){
                int temp = array[left];
                array[left]= array[right];
                array[right] = temp;
            }
        }
        array[start] = array[left];
        array[left] = pivot;
        return left;
    }

    /**
     * 单边
     * @param array
     * @param start
     * @param end
     * @return
     */
    private static int danbianpivot(int[] array, int start, int end) {
       int pivot = array[start];
       int mark = start;
        for (int i = start+1; i <=end; i++) {
           if(array[i]<pivot){
               mark++;
               int temp = array[mark];
               array[mark] = array[i];
               array[i] = temp;
           }
        }
        array[start] = array[mark];
        array[mark] = pivot;
        return mark;
    }