基本的排序算法

1. 冒泡排序

 public static int[] SmallBubbleSort(int[] array){
        for(int i = 1; i < array.length; i++){
            for(int index = array.length - 1; index >= i; index --){
                if(array[index] < array[index - 1]){
                    int temp = array[index];
                    array[index] = array[index -1];
                    array[index - 1] = temp;
                }
            }
        }
        return array;
    }

    public static int[] BigBubbleSort(int[] array){
        for(int i = 1; i < array.length; i ++){
            for(int j = array.length - 1; j >= i; j--){
                if(array[j] > array[j - 1]){
                    int temp = array[j];
                    array[j] = array[j - 1];
                    array[j-1] = temp;
                }
            }
        }
        return array;
    }

冒泡， 有大泡小泡，时间复杂度为o(n*n)

2. 选择排序

// 选择排序
    public static int[] SelectSort(int[] array){
        for(int i = 0; i < array.length; i++){
            int MinIndex = i;
            for(int j = i + 1; j < array.length; j++){
                if(array[MinIndex] > array[j]){
                    MinIndex = j;
                }
            }
            int temp = array[MinIndex];
            array[MinIndex] = array[i];
            array[i] = temp;
        }
        return array;
    }

3. 插入排序

     // 插入
    public static int[] InsertSort(int[] array){
        for(int i = 1; i < array.length; i ++){
            for(int j = i - 1 ; j >=0; j--){
                if(array[j] > array[j+1]){
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        return array;
    }

4. 希尔排序：分组，每组插入排序

public static int[] ShellSort(int[] array){
        int stepCount = array.length;
        while (stepCount > 1){
            stepCount = stepCount/2 + 1;
            for(int i = 0; i < stepCount; i++){
                for(int j = 0; j < array.length; j= j+stepCount){
                    for (int k = j - stepCount; k > 0; k = k - stepCount){
                        if(array[k] < array[j]){
                            int temp = array[k];
                            array[k] = array[j];
                            array[j] = temp;
                        }
                    }
                }
            }
        }
        return array;
    }

5. 快速排序

 // 快排序, java 数组是应用传递， 不需要返回值
    public static void QuickSort(int[] array, int start, int end) throws Exception{
        int startHis = start;
        int endHis = end;
        if(start >= end) return;
        int baseItem = array[start];

        while (start < end){
            while (start < end && array[end] >= baseItem ){
                end = end - 1;
            }
            array[start] = array[end];

            while (start < end && array[start] <= baseItem){
                start = start + 1;
            }
            array[end] = array[start];
        }
        array[start] = baseItem;

        QuickSort(array, startHis, start - 1);
        QuickSort(array, start + 1, endHis);
    }

6. 归并， 分治

// 归并
    public static void MergeSort(int[] array, int start, int end) throws Exception{
        if(start == end) return;
        int midIndex = (start + end)/2;
        MergeSort(array, start, midIndex);
        MergeSort(array, midIndex + 1, end);
        for(int i = midIndex + 1; i <= end; i ++){
            for(int j = i-1; j >= 0; j --){
                if(array[j + 1] < array[j]){
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }
    }

7. 堆排序

 // 堆排序
    public static void MakeHeap(int[] array, int root, int length){
        if(root >= array.length) return;
        MakeHeap(array, 2*root + 1, length);
        MakeHeap(array, 2*root + 2, length);
        if(2*root + 1 < length && array[2*root + 1]  < array[root]){
            int temp = array[2*root + 1];
            array[2*root + 1] = array[root];
            array[root] = temp;
        }
        if(2*root + 2 < length && array[2*root + 2]  < array[root]){
            int temp = array[2*root + 2];
            array[2*root + 2] = array[root];
            array[root] = temp;
        }
    }
    
    public static void HeapSort(int[] array){
        for(int i = 0; i < array.length; i ++){
            MakeHeap(array, 0, array.length - i);
            int temp = array[array.length - i -1];
            array[array.length - i -1] = array[0];
            array[0] = temp;
        }
    }

8. 筒排序

public static ArrayList<ArrayList<Integer>> BucketSort(int[] array, int size){
        // 计算步长
        int max = array[0];
        int min = array[0];
        for(int i = 0; i < array.length; i ++){
            if(array[i] > max) max = array[i];
            if(array[i] < min) min = array[i];
        }
        int bucketCount = (int)Math.ceil((max - min)/(double)size);
        // 初始化
        ArrayList<ArrayList<Integer>> bucket = new ArrayList<>();
        for(int i = 0; i < size; i ++){
            bucket.add(new ArrayList<Integer>());
        }
        // 每通内排序
        for(int i = 0; i < array.length; i ++){
            int buckerIndex = (array[i] - min)/bucketCount;
            if(buckerIndex == size) buckerIndex = buckerIndex - 1;
            ArrayList<Integer> oneBucket = bucket.get(buckerIndex);
            if(oneBucket.size() == 0 || oneBucket.get(oneBucket.size() - 1) <= array[i]) {
                oneBucket.add(array[i]);
            }else {
                oneBucket.add(array[i]);
                for(int j = oneBucket.size(); j > 1; j--){
                    if(oneBucket.get(j-1) < oneBucket.get(j-2)){
                        int temp = oneBucket.get(j -1);
                        oneBucket.set(j-1, oneBucket.get(j-2));
                        oneBucket.set(j-2, temp);
                    }
                }
            }
        }
        return bucket;
    }

9. 基数排序（类比桶排）

 // 基数排序
    public static void BaseSort(int[] array) throws Exception{
        int max = array[0];
        int min = array[0];
        for(int i = 0; i < array.length; i ++){
            if(array[i] < min) min = array[i];
            if(array[i] > max) max = array[i];
        }
        for(int i = 0; i < array.length; i ++){
            array[i] = array[i] - min;
        }
        // int min2 = min - min;
        int max2 = max - min;
        int length = String.valueOf(max2).length();

        for(int i = 0; i < length; i++){
            // 初始化桶
            ArrayList<ArrayList<Integer>> bucket = new ArrayList<>();
            for(int j = 0; j < 10; j ++){
                bucket.add(new ArrayList<Integer>());
            }
            // 排序
            for(int k = 0; k < array.length; k ++){
                int bucketIndex = GetDigital(array[k], i);
                // if(bucketIndex == 10) bucketIndex = bucketIndex - 1;
                ArrayList<Integer> oneBucket = bucket.get(bucketIndex);
                if(oneBucket.size() == 0 || GetDigital((oneBucket.get(oneBucket.size() - 1)), i) <= bucketIndex){
                    oneBucket.add(array[k]);
                }else {
                    oneBucket.add(array[k]);
                    for(int cc = oneBucket.size(); cc > 1; cc--){
                        if(GetDigital(oneBucket.get(cc-1), i ) < GetDigital(oneBucket.get(cc-2), i)){
                            int temp = oneBucket.get(cc -1);
                            oneBucket.set(cc-1, oneBucket.get(cc-2));
                            oneBucket.set(cc-2, temp);
                        }
                    }
                }
            }
            // 回存
            int arrayIndex = 0;
            for(int m = 0; m < 10; m ++){
                for(int l = 0; l < bucket.get(m).size(); l ++){
                    array[arrayIndex] = bucket.get(m).get(l);
                    arrayIndex = arrayIndex + 1;
                }
            }
        }

        for(int i = 0 ; i < array.length; i ++){
            array[i] = array[i] + min;
        }

    }