Java数组冒泡排序

冒泡排序内外两层循环，外层循环确定循环次数，内层循环进行数组内元素比较

1.升序排序

/**
     * @author:apple_pile
     * 冒泡排序升序排序    
     * 核心在于外层循环次数为长度-1
     * 内层循环次数为长度-1-外层循环数
     * @param array
     */
    public static void sortAscending(int[] array){
        int temp=0;
        for(int i=0;i<array.length-1;i++){
            for (int j=0;j< array.length-1-i;j++){
                if (array[j]>array[j+1]){  //若前一个数比后一个数大，则互相交换位置，升序排序
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
    }

2.降序排序

    /**
     * @author:apple_pile
     * 冒泡排序降序排序
     * 核心在于外层循环次数为长度-1
     * 内层循环次数为长度-1-外层循环数
     * @param array
     */
    public static void sortDescending(int[] array){
        int temp=0;
        for(int i=0;i<array.length-1;i++){
            for (int j=0;j< array.length-1-i;j++){
                if (array[j]<array[j+1]){  //若前一个数比后一个数小，则互相交换位置，降序排序
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
    }

3.全部代码

    public static void main(String[] args) {

        int[] array={78,97,76,786,67,43,45,46};
        System.out.println("对array进行升序排序（冒泡算法）：");
        sortAscending(array);
        System.out.println(Arrays.toString(array));

        System.out.println("对array进行降序排序（冒泡算法）：");
        sortDescending(array);
        System.out.println(Arrays.toString(array));
    }

    /**
     * @author:apple_pile
     * 冒泡排序升序排序
     * 核心在于外层循环次数为长度-1
     * 内层循环次数为长度-1-外层循环数
     * @param array
     */
    public static void sortAscending(int[] array){
        int temp=0;
        for(int i=0;i<array.length-1;i++){
            for (int j=0;j< array.length-1-i;j++){
                if (array[j]>array[j+1]){  //若前一个数比后一个数大，则互相交换位置，升序排序
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
    }

    /**
     * @author:apple_pile
     * 冒泡排序降序排序
     * 核心在于外层循环次数为长度-1
     * 内层循环次数为长度-1-外层循环数
     * @param array
     */
    public static void sortDescending(int[] array){
        int temp=0;
        for(int i=0;i<array.length-1;i++){
            for (int j=0;j< array.length-1-i;j++){
                if (array[j]<array[j+1]){  //若前一个数比后一个数小，则互相交换位置，降序排序
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
    }