数组总结及冒泡排序

数组总结及冒泡排序

反转数组

public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        for (int i = 0 , j = result.length-1 ; i < arrays.length ; i++ , j--) {
            result[j] = arrays[i];
        }
        return result;
    }

二维数组

public static void main(String[] args) {
    //二维数组:一个数组中每个数组元素嵌套另一个数组 疯狂套娃
    /*array[4][2]
    array[0] 1,2
    array[1] 2,3
    array[2] 3,4
    array[3] 4,5
     */

    int[][] array = {{1,2},{2,3},{3,4},{4,5}};
    System.oAut.println(array.length);//4
    System.out.println(array[0].length);//2
    System.out.println("============================");

    for (int i = 0; i <array.length ; i++) {
        for (int j = 0; j<array[i].length;j++){
            System.out.println(array[i][j]);
        }
    }

}

冒泡排序

  //冒泡排序
    /*
    1.比较数组中两个相邻的元素，如果第一个数比第二个数大，那么交换他们的位置
    2.第一次比较完后数组中最后一个数即为最大数，此时不用管它，继续比较它前面的所有数再
    比较出一个最大值，依次循环直到结束
     */
    public static void main(String[] args) {
        int[] arrays = {15,55,78,0,654,21,65};
        int[] sort = sort(arrays);
        System.out.println(Arrays.toString(sort));
    }

    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;

        for (int i = 0; i <array.length-1 ; i++) {//外层循环控制比较次数
            //内层循环，比较判断两个数，如果第一个数比第二个数大则交换位置
            boolean flag = false;
            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;
                    flag = true;
                }
            }
            if (flag == false){
                break;//说明这次（这一轮）比较已经有序，直接结束
            }

        }
        return array;
    }