8个排序算法——java

public static void radixsort(int[] a){
        int max=a[0];
        for(int i=1;i<a.length;i++){
            if (max<a[i]) {
                max=a[i];
            }
        }
        int time=0;
        while(max>0){
            max/=10;
            time++;
        }
        java.util.List<ArrayList> queue=new ArrayList<ArrayList>();
        for(int i=0;i<10;i++){
            ArrayList<Integer> queue1=new ArrayList<>();
            queue.add(queue1);
        }
        for(int i=0;i<time;i++){
            for(int j=0;j<a.length;j++){
                int x=a[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);
                queue.get(x).add(a[j]);
            }
            int tmp=0;
            for(int j=0;j<10;j++){
                while(!queue.get(j).isEmpty()){
                    a[tmp++]=(int)queue.get(j).remove(0);
                }
            }
        }
        
        for (int i = 0; i < a.length; i++) {
            System.out.println("radixsort" + a[i]);
        }
    }

    public static void mergesort(int[] a) {
        sort(a, 0, a.length-1);
        for (int i = 0; i < a.length; i++) {
            System.out.println("mergesort" + a[i]);
        }
    }

    public static void merging(int[] a, int left, int middle, int right) {
        if (middle < left || middle > right) {
            return;
        }
        int[] tmpArray = new int[a.length];
        int tmp = left;
        int tmpIndex = left;
        int begin1 = left;
        int begin2 = middle+1;
        while (begin1 <= middle && begin2 <= right) {
            if (a[begin1] < a[begin2]) {
                tmpArray[tmp++] = a[begin1++];
            } else {
                tmpArray[tmp++] = a[begin2++];
            }
        }
        while (begin1 <= middle) {
            tmpArray[tmp++] = a[begin1++];
        }
        while (begin2 <= right) {
            tmpArray[tmp++] = a[begin2++];
        }
        while(tmpIndex<=right){
            a[tmpIndex]=tmpArray[tmpIndex++];
        }
    }

    public static void sort(int[] a, int left, int right) {
        if (left < right) {
            int middle = (right - left) / 2 + left;
            sort(a, left, middle);
            sort(a, middle + 1, right);
            merging(a, left, middle, right);
        }
    }

    public static void quicksort(int[] a) {
        System.out.println("quicksort");
        quick(a, 0, a.length - 1);
        for (int i = 0; i < a.length; i++) {
            System.out.println("quicksort" + a[i]);
        }
    }

    public static void quick(int[] a, int left, int right) {
        if (left < right) {
            int middle = getMiddle(a, left, right);
            quick(a, left, middle);
            quick(a, middle + 1, right);
        }
    }

    public static int getMiddle(int[] a, int left, int right) {
        int tmp = a[left];
        while (left < right) {
            while (a[right] >= tmp && right > left) {
                right--;
            }
            a[left] = a[right];
            while (a[left] <= tmp && left < right) {
                left++;
            }
            a[right] = a[left];
        }
        a[left] = tmp;
        return left;
    }

    public static void bubblesort(int[] a) {
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length - i - 1; j++) {
                if (a[j] > a[j + 1]) {
                    swap(a, j, j + 1);
                }
            }
        }
        for (int i = 0; i < a.length; i++) {
            System.out.println("bubblesort" + a[i]);
        }
    }

    public static void heapsort(int[] a) {
        for (int i = a.length - 1; i >= 0; i--) {
            buildmaxheap(a, i);
            swap(a, i, 0);

        }
        for (int i = 0; i < a.length; i++) {
            System.out.println("heapsort" + a[i]);
        }
    }

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

    public static void buildmaxheap(int[] a, int lastindex) {
        int length = a.length;
        if (lastindex >= length) {
            return;
        }
        int index = (lastindex - 1) / 2;
        for (; index >= 0; index--) {
            int left = index * 2 + 1;
            if (left <= lastindex) {
                if (a[index] < a[left]) {
                    swap(a, index, left);
                }
            }
            if (left < lastindex && a[index] < a[left + 1]) {
                swap(a, index, left + 1);
            }
        }
    }

    public static void selectsort(int[] a) {
        int pos = 0;
        for (int i = 0; i < a.length; i++) {
            pos = i;
            for (int j = i + 1; j < a.length; j++) {
                if (a[pos] > a[j]) {
                    pos = j;
                }
            }
            if (pos != i) {
                int temp = a[i];
                a[i] = a[pos];
                a[pos] = temp;
            }
        }
        for (int i = 0; i < a.length; i++) {
            System.out.println("shellsort" + a[i]);
        }
    }

    public static void shellsort(int[] a) {
        int length = a.length;
        System.out.println(length);
        for (int d = (int) Math.ceil(length / 2); d > 0; d /= 2) {
            for (int i = 0; i < d; i++) {
                System.out.println("i=" + i + " d=" + d);
                for (int j = i + d; j < length; j += d) {
                    int temp = a[j];
                    int k = j - d;
                    System.out.println("j=" + j + " temp=" + temp + " k=" + k);
                    for (; k >= 0 && temp < a[k]; k -= d) {
                        System.out.println("k+d=" + (k + d) + " k=" + k + " a[k+d]=" + a[k + d] + " a[k]=" + a[k]);
                        a[k + d] = a[k];
                    }
                    System.out.println("end" + "k+d=" + (k + d) + " a[k+d]=" + a[k + d] + " temp=" + temp);
                    a[k + d] = temp;
                }
            }
        }
        for (int i = 0; i < a.length; i++) {
            System.out.println("shellsort" + a[i]);
        }
    }

    public static void selectSort(int[] a) {
        int length = a.length;
        int position = 0;
        for (int i = 0; i < length - 1; i++) {
            int temp = a[i];
            int j = i + 1;
            position = i;
            for (; j < length; j++) {
                if (a[j] < temp) {
                    temp = a[j];
                    position = j;
                }
            }
            a[position] = a[i];
            a[i] = temp;
        }
        for (int i = 0; i < a.length; i++) {
            System.out.println("selectSort" + a[i]);
        }
    }

    public static void insertSort(int[] a) {
        int temp = 0;
        for (int i = 1; i < a.length; i++) {
            int j = i - 1;
            temp = a[j + 1];
            for (; j >= 0 && a[j] > temp; j--) {
                System.out.println(j);
                a[j + 1] = a[j];
            }
            System.out.println(j);
            a[j + 1] = temp;
        }
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
}