Java最基础的五种排序方式

Java五种排序方式

1.随机数字

随机生成数字，进行测试

private int [] arrs;
private int count=0;
public Test(int size){
    count=size;
    arrs=new int[count];
    Random ran=new Random();
    for (int i = 0; i < count; i++) {
        //随机到1000
        arrs[i]=ran.nextInt(1000);
    }
}

2.显示当前数组次数

    public void display(){
        System.out.println("当前数组次序为：");
        for(int arr:arrs){
            System.out.print(arr+" ");
        }
        System.out.println();
    }

3.测试方法

    //main方法
    public static void main(String[] args) {
        Test t=new Test(20000);
        long time=System.currentTimeMillis();
        t.popo();//冒泡，这边替换为其他方法
        System.out.println((System.currentTimeMillis()-time)/60);
    }

4.算法

1.冒泡排序(2W以下)

  /**
     * 冒泡排序基本概念是：
     * 依次比较相邻的两个数，将小数放在前面，大数放在后面。
     * 即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。
     * 然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，
     * 直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，
     * 将最大的数放到了最后。在第二趟：仍从第一对数开始比较
     * （因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），
     * 将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），
     * 第二趟结束，在倒数第二的位置上得到一个新的最大数
     *（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。
     */
public void popo(){
        for (int i = 0; i < count-1; i++) {
            for (int j = 0; j < count-1-i; j++) {
                if(arrs[j]>arrs[j+1]){
                    int temp=arrs[j];
                    arrs[j]=arrs[j+1];
                    arrs[j+1]=temp;
                }
            }
        }
    }

2.选择排序(4W以下)

 
   /** 
     * 选择排序基本思路：
     * 把第一个元素依次和后面的所有元素进行比较。
     * 第一次结束后，就会有最小值出现在最前面。
     * 依次类推
     */
    public void option(){
        for (int i = 0; i < count-1; i++) {
            int pos=i;
            for (int j = i+1; j <count; j++) {
                if(arrs[pos]>arrs[j]){
                    pos=j;
                }
            }
            int temp=arrs[i];
            arrs[i]=arrs[pos];
            arrs[pos]=temp;
        }
    }

3.插入排序(5W以下)

 
/**
     * 插入排序基本思路：
     * 将n个元素的数列分为已有序和无序两个部分，如插入排序过程示例下所示： 　　
     * {{a1}，{a2，a3，a4，…，an}} 　　
     * {{a1⑴，a2⑴}，{a3⑴，a4⑴ …，an⑴}} 　
     * {{a1(n-1），a2(n-1) ，…},{an(n-1)}} 　　
     * 每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较，
     * 找出插入位置，将该元素插入到有序数列的合适位置中
     */
    public void insert(){
        for(int i=1;i<count;i++){
            int pos=i;
            int temp=arrs[pos];
            while(pos>0&&arrs[pos-1]>temp){
                arrs[pos]=arrs[pos-1];
                pos--;
            }
            arrs[pos]=temp;
        }
    }

4.快速排序(300W以下)

public void quick(int low,int high){
        int l=low,h=high;
        if(l>h){
            return;
        }
        boolean flag=false;
        while(l<h){
            if(arrs[l]<arrs[h]){
                int temp=arrs[l];
                arrs[l]=arrs[h];
                arrs[h]=temp;
                flag=!flag;
            }
            if(flag){
                l++;
            }else{
                h--;
            }
        }
        l--;h++;
        quick(low,l);
        quick(h,high);
    }

5.快速排序2(1000W以下)

public void quick2(int low,int high){
        if(high-low<=0){
            return ;
        }else{
            int num = arrs[high];
            int pos = partcals(low,high,num);
            quick2(low,pos-1);
            quick2(pos+1,high);
        }
    }
    private int partcals(int low, int high, int num) {
        int leftPtr = low-1;
        int rightPtr = high;
        while(true){
            while(arrs[++leftPtr]<num);
            while(rightPtr>0 && arrs[--rightPtr]>num);
            if(leftPtr >=rightPtr){
                break;
            }else{
                int temp=arrs[leftPtr];
                arrs[leftPtr]=arrs[rightPtr];
                arrs[rightPtr]=temp;
            }
        }
        int temp=arrs[leftPtr];
        arrs[leftPtr]=arrs[high];
        arrs[high]=temp;
        return leftPtr;
    }