java 基本算法排序（简单桶、冒泡、快速）-包含升降序（一)

java 基本算法排序（包含升降序）

1. 简单的桶排序：

   /**
     * 桶排序
     * 1.时间复杂度：o(M+N) [M为桶的个数；N为待排序数的个数];
     * 2.优缺点：
     *   1)优点：执行效率高，排序速度快;
     *   2)缺点：极浪费空间;
     */
    public void bucketSort(){
        int[] arrayA = new int[11];
        for(int i=0;i<=10;i++){
            arrayA[i]=0;
        }
        //目前写死对应的值，仅为测试
        arrayA[2] =1;
        arrayA[3] =1;
        arrayA[5] =2;
        arrayA[8] =1;
        // 简单的桶排序（旗子插桶法）
        // 升序
        // for(int i=0;i<=10;i++ ){
        //降序
         for(int i=10;i>=0;i-- ){
            for (int j=1;j<=arrayA[i];j++){
                System.out.println(i);
            }
        }
    }

升序输出结果：

降序输出结果：

2. 冒泡排序：

   /**
     * 冒泡排序：
     * 1.核心部分：双重嵌套循环；
     * 2.时间复杂度 o(n^2)，这是非常高的时间复杂度
     * 3.优缺点：
     *   1) 优点：省空间；
     *   2) 缺点：执行效率低；
     */
    public void bubblingSort(){
        int[] arrayA = new int[5];
        arrayA[0] =82;
        arrayA[1] =41;
        arrayA[2] =19;
        arrayA[3] =39;
        arrayA[4] =154;
        int arrayALength = arrayA.length;
        for(int i= 0;i<arrayALength-1;i++){
            for (int j=0;j<arrayALength-i-1;j++){
                //降序
                if ( arrayA[j]<arrayA[j+1] ){
                //升序
                //if ( arrayA[j]>arrayA[j+1] ){
                    int t = arrayA[j];
                    arrayA[j]= arrayA[j+1];
                    arrayA[j+1]= t;
                }
            }
        }
        for (int i=0;i<arrayALength;i++){
            System.out.println(arrayA[i]);
        }
    }

升序输出结果：

降序输出结果：

3.快速排序：
使用数据用例如下：

public static void main(String[] args) {
        DemoTest a =new DemoTest();
        //调用简单桶排序
        //a.bucketSort();
        //调用冒泡排序
        //a.bubblingSort();
        //1.快速排序用例数据如下:
        int[] arrayA = new int[10];
        arrayA[0] =82;
        arrayA[1] =41;
        arrayA[2] =19;
        arrayA[3] =74;
        arrayA[4] =154;
        arrayA[5] =4;
        arrayA[6] =9;
        arrayA[7] =15;
        arrayA[8] =25;
        arrayA[9] =39;
        //2.调用快速排序
        a.fastSort(arrayA, 0, 9);
        //3.进行快速排序结果的输出
        for ( int i = 0;i<arrayA.length;i++ ){
            if ( i == arrayA.length -1 ){
                System.out.print(arrayA[i]);
            }else{
                System.out.print(arrayA[i]+",");
            }

        }
    }

3.1 递归调用：

    /**
     * 快速排序
     * @param arrayA 数组
     * @param left 左
     * @param right 右
     */
    public void  fastSort(int[] arrayA,int left,int right ){
        int benchmarkPart ;
        if(left < right){
            benchmarkPart = getBenchmarkAscOrDesc(arrayA,left,right);
            fastSort(arrayA,left,benchmarkPart-1);
            fastSort(arrayA,benchmarkPart+1,right);
        }
    }

3.2 获取基准数的位置，以便后期左右2边进行排序：

   /**
     * 获取基准数的位置(升序、降序)
     * @param arrayA 排序数组
     * @param left 左
     * @param right 右
     * @return 基准数位置
     */
    public int getBenchmarkAscOrDesc(int[] arrayA,int left,int right){
        int benchmarkNo =  arrayA[left];
        while (left < right){
            // 升序
            // while ( left < right && arrayA[right]>=benchmarkNo ){
            // 降序
            while ( left < right && arrayA[right]<=benchmarkNo ){
                right--;
            }
            // 升序
            if ( left < right ){
                arrayA[left++] = arrayA[right];
            }
            // 升序
            // while ( left <right && arrayA[left] <=benchmarkNo  ){
            // 降序
            while ( left <right && arrayA[left] >=benchmarkNo  ){
                left++;
            }
            // 升序
            if ( left <right ){
                arrayA[right--] = arrayA [left];
            }
        }
        arrayA[left] = benchmarkNo;
        return left;
    }

升序输出结果：

降序输出结果：