使用Java语言实现几种常见的排序算法

看官你好，我的初衷是复习数据结构中所学的各种算法，之前都是用C语言写的，这次改成了Java语言，感觉更简单一些。

为了容易分享，我把它写在一个类里面，都用了静态方法，莫怪！

算法功能：输入一个任意长度的整形数组，以String的形式输出数组的由小到大的排序结果。

下面则是全部代码：

public class Sort {

    public static void main(String[] args) {

        int a[]={12,56,95,35,88,102,89,63,154};
        String sa=mpSort(a);
        System.out.println("数组A的排序结果是："+sa);

        int b[]={32,55,175,75,82,111,26,159};
        String sb=ksSort(b);
        System.out.println("数组B的排序结果是："+sb);

        int c[]={137,555,186,45,92,150,48,360};
        String sc=crSort(c);
        System.out.println("数组C的排序结果是："+sc);
    }

    //不排序
    public static String noSort(int arr[])
    {
        String s=" ";
        for(int i=0;i<arr.length;i++)
        {
            s=s+arr[i]+" ";
        }
        return s;
    }

    //冒泡排序
    public static String mpSort(int arr[])
    {
        String s=" ";
        int temp;  //temp 为交换时的暂存数据
        boolean move;  //move 判断是否有过交换
        for(int i=1;i<arr.length;i++)  // i 表示趟数，共arr.length-1趟
        {
            move=false;
            for(int j=arr.length-1;j>=i;j--)
            {
                if(arr[j]<arr[j-1])
                {
                    temp=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=temp;
                    move=true;
                }
            }
            if(!move) break;
        }
        for(int i=0;i<arr.length;i++)
        {
            s=s+arr[i]+" ";
        }
        return s;
    }

    //快速排序
    public static String ksSort(int arr[])
    {
        String s=" ";
        quicksort(arr,0,arr.length-1);  //初始以arr[0]为最低位，arr[arr.length-1]为最高位
        for(int i=0;i<arr.length;i++)
        {
            s=s+arr[i]+" ";
        }
        return s;
    }
    //快速排序的分区算法，返回基准数据的下标
    private static int partition(int arr[],int low,int high)
    {
        int key=arr[low];  //基准值赋给岗哨
        while(low<high)
        {
            if(low<high && arr[high]>=key)
                high--;
            arr[low]=arr[high];
            if(low<high && arr[low]<=key)
                low++;
            arr[high]=arr[low];
        }
        arr[low]=key;  //空位填上基准值
        return low;
    }
    //真正的快速排序：一种递归算法
    private static void quicksort(int arr[],int low,int high)
    {
        if(low<high)
        {
            int result=partition(arr,low,high);
            quicksort(arr,low,result-1);
            quicksort(arr,result+1,high);
        }
    }

    //插入排序
    public static String crSort(int arr[])
    {
        String s=" ";
        int key;  //key 表示岗哨，记录新增的数据
        for(int i=2;i<=arr.length;i++)  // i 表示有序区长度，从2开始递增，直到arr.length结束
        {
            if(arr[i-1]<arr[i-2])  //新增数据小于上一轮有序区最后一位
            {
                key=arr[i-1];
                for(int j=i-2;j>=0;j--)
                {
                    if(j>0)
                    {
                        if(arr[j]>key)
                        {
                            arr[j+1]=arr[j];  //大于新增数据，则后移一位
                        }
                        else
                        {
                            arr[j+1]=key;  //小于等于新增数据，则空位填上新增数据
                            break;
                        }
                    }
                    else  //如果新增数据一直比较到arr[0]，需要特殊处理
                    {
                        if(arr[0]>key)
                        {
                            arr[1]=arr[0];
                            arr[0]=key;
                        }
                        else
                            arr[1]=key;
                    }
                }
            }
        }
        for(int i=0;i<arr.length;i++)
        {
            s=s+arr[i]+" ";
        }
        return s;
    }
}

运行的结果：
数组A的排序结果是： 12 35 56 63 88 89 95 102 154
数组B的排序结果是： 26 32 55 75 82 111 159 175
数组C的排序结果是： 45 48 92 137 150 186 360 555
成功生成（总时间：0 秒）