java实现排序算法

import java.util.ArrayList;
import java.util.Scanner;

public class SortAlgorithm {
    public static void main(String[] args) {
        System.out.println("Sort");
        int[] p = {65, 66, 97, 5, 2, 3, 54, 44, 68, 11, 62, 88, 94, 4, 1};
        System.out.println(p.length);
        for (; ; ) {
            Scanner i = new Scanner(System.in);
            Integer q = i.nextInt();
            switch (q) {
                case 1:
                    bubbleSort(p);
                    qPrint(p);
                    break;
                case 2:
                    selectionSort(p);
                    qPrint(p);
                    break;
                case 3:
                    System.out.println("quickSort");
                    quickSort(p, 0, p.length - 1);
                    qPrint(p);
                    break;
                case 4:
                    insertSort(p);
                    qPrint(p);
                    break;
                case 5:
                    shellSort(p);
                    qPrint(p);
                    break;
                case 6:
                    mergeSort(p,0,p.length-1);
                    qPrint(p);
                    break;
                case 7:
                    countSort(p);
                    qPrint(p);
                    break;
                case 0:
                    return;
            }
        }
    }

    public static void bubbleSort(int[] p) {//冒泡排序,复杂度O(N^2)
        System.out.println("Bubble Sort");
        int temp;
        for (int i = p.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (p[j] < p[j + 1]) {
                    temp = p[j];
                    p[j] = p[j + 1];
                    p[j + 1] = temp;
                }
            }
        }
    }

    public static void selectionSort(int[] a) {
        System.out.println("selectionSort");
        int temp = 0;
        for (int i = 0; i < a.length; i++) {
            int index = i;//保存最小值索引

            for (int j = i + 1; j < a.length; j++) {//寻找第i大的数值
                if (a[index] < a[j]) {
                    index = j;
                }
            }
            temp = a[index];
            a[index] = a[i];
            a[i] = temp;
        }
    }

    public static void quickSort(int[] a, int low, int high) {//快速排序，核心是递归算法实现(nlogn)
        int left = low;
        int right = high;
        int temp = 0;
        if (left <= right) {//待排序的元素至少为2个
            temp = a[left];//第一个元素作为基准
            while (left != right) {//左右双向扫描

                while (right > left && a[right] <= temp)//从右往左扫描，找的第一个比基准大的元素
                    right--;
                a[left] = a[right];//找到元素后a[right]与a[left]交换
                while (left < right && a[left] >= temp)//从左往右扫描，找的第一个比基准小的元素
                    left++;
                a[right] = a[left];//找到元素后a[left]与a[right]交换
            }
            a[right] = temp;//基准元素复位
            quickSort(a, low, high - 1);
            quickSort(a, low + 1, high);
        }
    }

    public static void insertSort(int[] a) {//插入排序:复杂度O(N^2)
        System.out.println("insertSort");
        int temp;
        for (int i = 1; i < a.length; i++) {
            int j = i - 1;
            temp = a[i];//a[i]赋值给temp作为比较的变量
            for (; j >= 0 && temp > a[j]; j--)//找到比temp小的变量后整体右移
                a[j + 1] = a[j];
            a[j + 1] = temp;
        }
    }

    public static void shellSort(int[] a) {
        System.out.println("shellSort");
        int N = a.length;
        int tp;
        for (int gap=a.length/2;gap>0;gap/=2)//对增量gap进行定义，并逐步缩小
        {
            for(int i=gap;i<a.length;i++)//从第gap个元素，逐个对所在组进行直接插入操作
            {int j=i;               // 口口口口/口口口口
            while (j-gap>=0&&a[j]>a[j-gap]){//口口/口口/口口/口口
                swap(a,j,j-gap);//插入排序使用交换法
                j-=gap;
            }
            }
        }
    }


    /**
     * 归并排序
     *
     * @param arr
     * @param l      指向数组第一个元素
     * @param r      指向数组最后一个元素
     */
    public static void mergeSort(int []arr,int l,int r) {
        if (l==r){return;}
        else {
            int m=(l+r)/2;
            mergeSort(arr,l,m);//左边拆分
            mergeSort(arr,m+1,r);
            merge(arr,l,m+1,r);

        }
    }

    /**
     * 合并数组
     *
     * @param arr
     * @param l      指向数组第一个元素
     * @param m      指向数组分隔的元素
     * @param r      指向数组最后的元素
     */
    public static void merge(int []arr,int l,int m,int r){
        int []leftArr= new int [m-l];
        int []rightArr= new int [r-m+1];
        for (int i=l;i<m;i++){//两个数组中填充数据
            leftArr[i-l]=arr[i];
        }
        for (int j=m;j<=r;j++){
            rightArr[j-m]=arr[j];
        }

        int i=0;
        int j=0;
        int k=l;//arr数组第一个元素
        while(i<leftArr.length&&j<rightArr.length){
            if (leftArr[i]>rightArr[j]){//谁比较大，就将元素放入arr中，移动指针比较下一个
                arr[k]=leftArr[i];
                i++;
                k++;
            }else {
                arr[k]=rightArr[j];
                j++;
                k++;
            }
        }
        while (i<leftArr.length){//如果左边没比较完，右边比较完毕，则将左边的数抄到大数组中
            arr[k]=leftArr[i];
            i++;
            k++;
        }
        while (j<rightArr.length){//如果右边没比较完，左边比较完毕，则将右边的数抄到大数组中
            arr[k]=rightArr[j];
            j++;
            k++;
        }
    }


    public static void countSort(int []a){
        System.out.println("countSort");
        int max=Integer.MAX_VALUE;
        int min=Integer.MIN_VALUE;

        for (int i = 0; i <a.length ; i++) {//计算最大最小值
            max=Math.max(max,a[i]);
            min=Math.min(max,a[i]);
        }
        int help[]=new int[97];//设置数组大小
        for (int i = 0; i < a.length; i++) {
            int m=a[i]-min;
            help[m]++;
        }
        int index=0;
        for (int i = 0; i <help.length ; i++) {
            while ((help[i]--)>0){
                a[index++]=i+min;
            }

        }
        for (int i = 0; i <a.length/2-1 ; i++) {
            swap(a,i,a.length-i-1);
        }
    }


    public static void swap(int[] p,int a,int b){//元素交换
        p[a]=p[a]+p[b];
        p[b]=p[a]-p[b];
        p[a]=p[a]-p[b];
    }
    public static void qPrint(int []q){
        for (int i = 0; i <q.length ; i++) {
            System.out.println(q[i]);
        }
    }
}