八大排序Java代码

可以参考http://blog.youkuaiyun.com/yuxin6866/article/details/52771739

package edu.ee.scut.innerSort;

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

public class Sort {
    public static void main(String[] args){
        int a[] = {3,1,5,7,2,4,9,6,10,8};          
        System.out.println("初始值：");    
        System.out.println(Arrays.toString(a));    
        //insertSort(a);    
        //shellSort(a);
        //selectSort(a);
        //bubbleSort(a);
        //quickSort(a, 0, 9);
        //mergeSort(a, 0, 9);
        System.out.println("排序后：");    
        System.out.println(Arrays.toString(a));

//        int b[] = {0,3,1,5,7,2,4,9,6,10,8};
//        System.out.println("初始值：");    
//        System.out.println(Arrays.toString(b));
//        heapSort(b);
//        System.out.println("排序后：");    
//        System.out.println(Arrays.toString(b));

        int c[] = {323, 3232, 43242, 34, 4343, 434, 8787, 6455, 7567, 0};
        System.out.println("初始值：");    
        System.out.println(Arrays.toString(c));
        radixSort(c);
        System.out.println("排序后：");    
        System.out.println(Arrays.toString(c));
    }

    private static void radixSort(int[] c) {
        int max = c[0];
        for(int i = 1; i < c.length; i++){
            if(c[i] > max){
                max = c[i];
            }
        }
        int times = 0;
        while(max > 0){
            max /= 10;
            times++;
        }
        ArrayList<ArrayList<Integer>> queue = new ArrayList<>();
        for(int i = 0; i < 10; i++){
            ArrayList<Integer> que = new ArrayList<>();
            queue.add(que);
        }
        for(int i = 0; i < times; i++){
            for(int a : c){
                int x = a%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);
                queue.get(x).add(a);
            }
            int count = 0;
            for(int j = 0; j < 10; j++){
                while(queue.get(j).size() > 0){
                    c[count++] = queue.get(j).get(0);
                    queue.get(j).remove(0);
                }
            }
        }   
    }

    private static void heapSort(int[] a) {
        int N = a.length-1;
        for(int i = N/2; i > 0; i--){
            sink(a, i, N);
        }
        while(N > 1){
            swap(a, 1, N);
            N--;
            sink(a, 1, N);
        }
    }

    private static void sink(int[] a, int i, int N) {
        while(2*i <= N){
            int j = 2*i;
            if(j < N && a[j] < a[j+1]){
                j++;
            }
            if(a[i] < a[j]){
                swap(a, i, j);
                i = j;
            }else{
                break;
            }
        }

    }

    private static void mergeSort(int[] a, int low, int high) {
        if(low >=high){
            return;
        }
        int middle = (low+high)/2;
        mergeSort(a, low, middle);
        mergeSort(a, middle+1, high);
        merge(a, low, middle, high);
    }

    private static void merge(int[] a, int low, int middle, int high) {
        int i = low-low;
        int j = middle+1-low;
        int[] b = new int[high-low+1];
        for(int k = low; k <= high; k++){
            b[k-low] = a[k];
        }
        for(int k = low; k <= high; k++){
            if(i > middle-low){
                a[k] = b[j];
                j++;
            }else if(j > high-low){
                a[k] = b[i];
                i++;
            }else if(b[i] <= b[j]){
                a[k] = b[i];
                i++;
            }else{
                a[k] = b[j];
                j++;
            }
        }

    }

    private static void quickSort(int[] a, int low, int high) {
        if(low < high){
            int middle = partition(a, low, high);
            quickSort(a, low, middle-1);
            quickSort(a, middle+1, high);
        }
    }

    private static int partition(int[] a, int low, int high) {
        int sorted = a[low];
        int i = low+1;
        int j = high;
        while(true){
            while(i <=high && a[i] <= sorted){
                i++;
            }
            while(j >=low+1 && a[j] >= sorted){
                j--;
            }
            if(j <= i){
                break;
            }
            swap(a, i, j);
        }
        swap(a, low, j);
        return j;
    }

    private static void bubbleSort(int[] a) {
        for(int i = 0; i < a.length-1; i++){
            for(int j = a.length-1; j > i; j--){
                if(a[j] < a[j-1]){
                    swap(a, j, j-1);
                }
            }
        }
    }

    private static void selectSort(int[] a) {
        for(int i = 0; i < a.length-1; i++){
            int min = i;
            for(int j = i+1; j < a.length; j++){
                if(a[j] < a[min]){
                    min = j;
                }
            }
            swap(a, i, min);
        }

    }

    private static void shellSort(int[] a) {
        int interval = a.length/2;
        while(interval >= 1){
            for(int i = interval; i < a.length; i++){
                for(int j = i; j >= interval; j = j-interval){
                    if(a[j] < a[j-interval]){
                        swap(a, j-interval, j);
                    }else{
                        break;
                    }
                }
            }
            interval /= 2;
        }
    }

    private static void insertSort(int[] a) {
        for(int i = 1; i < a.length; i++){
            for(int j = i; j > 0; j--){
                if(a[j] < a[j-1]){
                    swap(a, j-1, j);
                }else{
                    break;
                }
            }
        }   
    }

    private static void swap(int[] a, int i, int j) {
        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp; 
    }
}