JAVA排序匯總（List、數組排序、幾種常用排序算法）

List排序

1、使用Collections的sort(List<T> list)方法對List集合進行從小到大排序

    /**
     * 使用Collections的sort(List<T> list)方法對List集合進行從小到大排序
     */
    @Test
    public void listDefaultSort() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(3);
        list.add(2);
        
        System.out.println(list);
        System.out.println("------------------");
        
        Collections.sort(list); // 按從小到大排序，只能對基本數據類型的包裝對象
        
        System.out.println(list);
    }

執行結果：

[1, 3, 2]
------------------
[1, 2, 3]

2、使用Collections的sort(List<T> list, Comparator<? super T> c)方法對List集合進行自定義排序

    /**
     * 使用Collections的sort(List<T> list, Comparator<? super T> c)方法對List集合進行自定義排序
     */
    @Test
    public void listCustomSort() {
        List<Person> list = new ArrayList<Person>();
        
        Person p1 = new Person("1", "p1" , 12);
        Person p2 = new Person("2", "p2" , 9);
        Person p3 = new Person("3", "p3" , 13);
        Person p4 = new Person("4", "p4" , 9);
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        
        System.out.println(list);
        System.out.println("------------------");
        
        Collections.sort(list, new Comparator<Person>() {
            // 按年齡從大到小排序
            @Override
            public int compare(Person p1, Person p2) {
                return p1.getAge() == p2.getAge() ? 0 : (p1.getAge() < p2.getAge() ? 1 : -1);
            }
            
        });
        
        System.out.println(list);
    }

class Person {
    private String id;
    
    private String name;
    
    private int age;

    public Person(String id, String name, int age) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "\n Person [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
}

執行結果：

[
 Person [id=1, name=p1, age=12], 
 Person [id=2, name=p2, age=9], 
 Person [id=3, name=p3, age=13], 
 Person [id=4, name=p4, age=9]]
------------------
[
 Person [id=3, name=p3, age=13], 
 Person [id=1, name=p1, age=12], 
 Person [id=2, name=p2, age=9], 
 Person [id=4, name=p4, age=9]]

 

數組排序

1、使用Arrays.sort(int[] a)方法對數組按從小到大排序

    /**
     * 使用Arrays.sort(int[] a)方法對數組按從小到大排序
     */
    @Test
    public void arrayDefaultSort() {
        int[] array = {3, 4, 6, 1, 8, 2, 1, 5, 9, 0};
        for (int i : array) {
            System.out.print(i);
            System.out.print(" ");
        }
        System.out.println("");
        System.out.println("---------------------");
        
        Arrays.sort(array); // 按從小到大排序，只能對基本數據類型以及其封裝對象
        
        for (int i : array) {
            System.out.print(i);
            System.out.print(" ");
        }
    }

執行結果：

3 4 6 1 8 2 1 5 9 0 
---------------------
0 1 1 2 3 4 5 6 8 9 

2、使用Arrays.sort(int[] a, int fromIndex, int toIndex)部分從小到大排序

    /**
     * 使用Arrays.sort(int[] a, int fromIndex, int toIndex)部分從小到大排序
     * fromIndex 要排序的第一位索引（包括，從這開始）
     * toIndex 要排序的最后一個索引（不包括在內，在這結束）
     */
    @Test
    public void arrayPartSort() {
        Integer[] array = {3, 4, 6, 1, 8, 2, 1, 5, 9, 0};
        for (int i : array) {
            System.out.print(i);
            System.out.print(" ");
        }
        System.out.println("");
        System.out.println("---------------------");
        
        Arrays.sort(array, 3, 6); // 對下標為3至6（不包括6）按從小到大排序，只能對基本數據類型以及其封裝對象
        
        for (int i : array) {
            System.out.print(i);
            System.out.print(" ");
        }
    }

執行結果：

3 4 6 1 8 2 1 5 9 0 
---------------------
3 4 6 1 2 8 1 5 9 0 

3、使用Arrays.sort(T[] a, Comparator<? super T> c)自定義排序

    /**
     * 使用Arrays.sort(T[] a, Comparator<? super T> c)自定義排序
     */
    @Test
    public void arrayCustomSort() {
        Integer[] array = {3, 4, 6, 1, 8, 2, 1, 5, 9, 0};
        for (Integer i : array) {
            System.out.print(i);
            System.out.print(" ");
        }
        System.out.println("");
        System.out.println("---------------------");
        
        Arrays.sort(array, new Comparator<Integer>() {
            // 從大到小排序
            @Override
            public int compare(Integer i1, Integer i2) {
                return i1 == i2 ? 0 : (i1 < i2 ? 1 : -1);
            }
            
        });
        
        for (int i : array) {
            System.out.print(i);
            System.out.print(" ");
        }
    }

執行結果：

3 4 6 1 8 2 1 5 9 0 
---------------------
9 8 6 5 4 3 2 1 1 0 

 

常見排序算法

1、冒泡排序

    /**
     * 冒泡排序（按從小到大排序）
     * 最佳情況：T(n) = O(n)   最差情況：T(n) = O(n2)   平均情況：T(n) = O(n2)
     */
    @Test
    public void bubbleSort() {
        int[] array = { 3, 4, 6, 1, 8, 2, 1, 5, 9, 0 };
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] < array[j]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }
        for (int i : array) {
            System.out.print(i);
            System.out.print(" ");
        }
    }

2、選擇排序

    /**
     * 選擇排序（按從小到大排序）
     * 最佳情況：T(n) = O(n2) 最差情況：T(n) = O(n2) 平均情況：T(n) = O(n2)
     */
    @Test
    public void selectionSort() {
        int[] array = { 3, 4, 6, 1, 8, 2, 1, 5, 9, 0 };
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i; j < array.length; j++) {
                if (array[j] < array[minIndex])
                    minIndex = j;
            }
            int temp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = temp;
        }
        for (int i : array) {
            System.out.print(i);
            System.out.print(" ");
        }
    }

3、插入排序

    /**
     * 插入排序（按從小到大排序）
     * 最佳情況：T(n) = O(n) 最壞情況：T(n) = O(n2) 平均情況：T(n) = O(n2)
     */
    @Test
    public void insertionSort() {
        int[] array = { 3, 4, 6, 1, 8, 2, 1, 5, 9, 0 };
        int current;
        for (int i = 0; i < array.length - 1; i++) {
            current = array[i + 1];
            int preIndex = i;
            while (preIndex >= 0 && current < array[preIndex]) {
                array[preIndex + 1] = array[preIndex];
                preIndex--;
            }
            array[preIndex + 1] = current;
        }
        for (int i : array) {
            System.out.print(i);
            System.out.print(" ");
        }
    }

4、希爾排序 

    /**
     * 從大到小
     * @param array
     */
    public static void shellSort1(int[] array) {
        int number = array.length/2;
        int i,j,temp;
        while (number >= 1){
            for (i = number; i < array.length; i++) {
                temp = array[i];
                j = i - number;
                while (j >= 0 && array[j] < temp) {
                    array[j + number] = array[j];
                    j = j - number;
                }
                array[j + number] = temp;
            }
            number = number/2;
        }
    }

5、歸並排序 

    /**
     * 從小到大排序
     * @param arr
     */
    public static void sort(int []array){
        int []temp = new int[array.length];//在排序前，先建好一個長度等於原數組長度的臨時數組，避免遞歸中頻繁開辟空間
        sort(array,0,array.length-1,temp);
    }
    private static void sort(int[] array,int left,int right,int []temp){
        if(left<right){
            int mid = (left+right)/2;
            sort(array,left,mid,temp);// 左邊歸並排序，使得左子序列有序
            sort(array,mid+1,right,temp);// 右邊歸並排序，使得右子序列有序
            merge(array,left,mid,right,temp);// 將兩個有序子數組合並操作
        }
    }
    private static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i = left;// 左序列指針
        int j = mid + 1;// 右序列指針
        int t = 0;// 臨時數組指針
        while (i <= mid && j <= right){
            if(arr[i] <= arr[j]){
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }
        while(i <= mid){// 將左邊剩余元素填充進temp中
            temp[t++] = arr[i++];
        }
        while(j <= right){// 將右序列剩余元素填充進temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        // 將temp中的元素全部拷貝到原數組中
        while(left <= right){
            arr[left++] = temp[t++];
        }
    }

 6、快速排序 

    public static void main(String[] args) {
        int[] array = new int[]{2,3,5,6,9,1,0,3,4,6};
        quickSort(array);
        for (int i=0;i<array.length;i++) {
            System.out.print(array[i] + " ");
        }
    }

    /**
     * 快速排序，使得整數數組 arr 有序
     */
    public static void quickSort(int[] array) {
        if (array == null || array.length < 2) {
            return;
        }
        quickSort(array, 0, array.length - 1);
    }

    /**
     * 快速排序，使得整數數組 arr 的 [L, R] 部分有序
     */
    public static void quickSort(int[] arr, int L, int R) {
        if(L < R) {
            // 把數組中隨機的一個元素與最后一個元素交換，這樣以最后一個元素作為基准值實際上就是以數組中隨機的一個元素作為基准值
            swap(arr, new Random().nextInt(R - L + 1) + L, R);
            int[] p = partition(arr, L, R);
            quickSort(arr, L, p[0] - 1);
            quickSort(arr, p[1] + 1, R);
        }
    }

    /**
     * 分區的過程，整數數組 arr 的[L, R]部分上，使得：
     *   大於 arr[R] 的元素位於[L, R]部分的右邊，但這部分數據不一定有序
     *   小於 arr[R] 的元素位於[L, R]部分的左邊，但這部分數據不一定有序
     *   等於 arr[R] 的元素位於[L, R]部分的中間
     * 返回等於部分的第一個元素的下標和最后一個下標組成的整數數組
     */
    public static int[] partition(int[] arr, int L, int R) {

        int basic = arr[R];
        int less = L - 1;
        int more = R + 1;
        while(L < more) {
            if(arr[L] < basic) {
                swap(arr, ++less, L++);
            } else if (arr[L] > basic) {
                swap(arr, --more, L);
            } else {
                L++;
            }
        }

        return new int[] { less + 1, more - 1 };

    }

    /*
     * 交換數組 arr 中下標為 i 和下標為 j 位置的元素
     */
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

7、堆排序

 

8、計數排序

 

9、桶排序

 

10、基數排序

 

遞歸

1、遞歸算法計算n!

    /**
     * 遞歸算法
     */
    @Test
    public void recursion() {
        System.out.println(factorial(2));
    }

    /**
     * 遞歸算法計算階乘n!
     * 
     * @param n
     * @return
     */
    public static Integer factorial(Integer n) {
        if (n < 0)
            return 0;
        if (n == 1)
            return 1;
        return n * factorial(n - 1);
    }

 2、遞歸計算1*2+2*3+3*4+...+n*(n+1)

    /**
     * 遞歸算法
     */
    @Test
    public void recursion() {
        System.out.println(productSum(4));
    }

    /**
     * 遞歸算法計算1*2+2*3+3*4+...+n*(n+1)
     * @param n
     * @return
     */
    public static Integer productSum(Integer n) {
        if (n <= 0)
            return 0;
        if (n == 1)
            return 2;
        int result = productSum(n - 1) + n * (n + 1);
        return result;
    }