算法导论第八章:快速排序-全部代码实现

import java.lang.reflect.Array;
import java.util.*;

public class Main {
    static int max;

    public static void main(String[] args) {
        Main main = new Main();
//        int A[] = {2, 5, 3, 0, 2, 3, 0, 3};
//        练习8.2-1例子
        int A[] = {6,0,2,0,1,3,4,6,1,3,2};
//        基数排序例子
//        int A[] = {329, 457, 657, 839, 436, 720, 355};
//
//        for (int i : A) { max = Math.max(max, i); }
//        int B[] = new int[A.length];


//        计数排序
//        main.COUNTING_SORT(A, B,max);
//        for (int i : B) { System.out.print(i + " "); }

//        基数排序
//        main.RADIX_SORT(A, 3, B);

//        for (int i : A) { System.out.print(i + " "); }

//        double[] A = {0.78, 0.17, 0.39, 0.26, 0.72, 0.94, 0.21, 0.12, 0.23, 0.68};
//        练习8.4-1例子
//        double[] A = {0.79,0.13,0.16,0.64,0.39,0.20,0.89,0.53,0.71,0.42};

        main.INSERTION_SORT(A);
    }

    //    计数排序
    public void COUNTING_SORT(int A[], int B[], int k) {
        int[] C = new int[k + 1];
        for (int i = 0; i < A.length; i++) {
            C[A[i]]++;
        }
        for (int i = 1; i < k + 1; i++) {
            C[i] = C[i] + C[i - 1];
        }
//        练习8.2-4 有多少个落在区间[a,b]内
//        int quantity=C[b]-C[a-1];
        //必须是倒序,保证稳定排序
        for (int j = A.length - 1; j >= 0; j--) {
            B[C[A[j]] - 1] = A[j];
            C[A[j]]--;
        }
    }


    //  基数排序
    public void RADIX_SORT(int[] A, int d, int[] B) {
        int[] curr = new int[A.length];
        for (int i = 0; i < d; i++) {
            for (int j = 0; j < A.length; j++) {
                int x = (int) (A[j] / Math.pow(10, i) % 10);
                curr[j] = x;
            }
            COUNTING_SORT_RADIX(curr, B, max, A);
        }
    }

    public void COUNTING_SORT_RADIX(int curr[], int B[], int k, int A[]) {
        int[] C = new int[k + 1];
        for (int i = 0; i < curr.length; i++) {
            C[curr[i]]++;
        }
        for (int i = 1; i < k + 1; i++) {
            C[i] = C[i] + C[i - 1];
        }
        for (int j = curr.length - 1; j >= 0; j--) {
            B[C[curr[j]] - 1] = A[j];
            C[curr[j]]--;
        }
        for (int i = 0; i < B.length; i++) {
            A[i] = B[i];
        }
    }


    //     桶排序
    class newArray {
        //这里直接用treeSet了,自动排序
        TreeSet<Double> list=new TreeSet<>();
        public newArray() { this.list = new TreeSet<>(); }
    }
    public void BUCKET_SORT(double[] A) {
        int key=1;
        newArray[] lists = new newArray[A.length];
        //一定要先初始化建立链表,不然会报空指针错误
        for (int i = 0; i < A.length; i++) {
            lists[(int) (A[i] * 10)] = new newArray();
        }
        for (int i = 0; i < A.length; i++) {
            lists[(int) (A[i] * 10)].list.add(A[i]);
        }
        for (newArray i : lists) {
            //注意一定要有判断,不然会有空指针判错,因为每个lists都创建了TreeSet
            if (i!=null){
                for (Double j : i.list) {
                    System.out.print(j+" ");
                }
            }
        }
    }

    //遗忘比较交换算法
    public void INSERTION_SORT(int[] A) {
        for (int i = 1; i < A.length; i++) {
            for (int j = i - 1; j >= 0; j--) {
                if (A[j] > A[j+1]) {
                    int temp = A[j];
                    A[j] = A[j+1];
                    A[j+1] = temp;
                }
            }
        }
        for (int i : A) {
            System.out.print(i + " ");
        }
    }
}