冒泡排序和二维数组

二维数组

• 多维数组在平常很少使用，二维数组已经可以满足日常开发使用
• 以二维数组为例，简单介绍多维数组

先上代码：

package com.yuqu.www.arrays;

public class Demo09 { //多维数组：以二维数组为例
    public static void main(String[] args) {
        /**
         * 二维数组：定义一个数组，数组中的每个元素均为一个数组  
         * 以arr数组为例：  此处定义了一个二维数组arr[]，其中有四个元素，即有四个数组arr[0]arr[1]arr[2]arr[3]
         * 理解：此时arr[0]arr[1]arr[2]arr[3]各自为一个数组，但对于arr[]来说，都属于arr[]数组当中的元素
         * 此处我们将称为arr[0]arr[1]arr[2]arr[3]二维组,每个二维组当中有两个元素。
         * 而多维数组的含义即可解释为：
         * inr[][][]  arrs = new int
         * 当我们需要索引每个二维组当中的元素时，分别表示为（此处以arr[0]示例）：
         * arr[0][0] = 1;    arr[0][1] = 2;
         * [4][2]
         * 1,2   arr[0]
         * 2,3   arr[1]
         * 3,4   arr[2]
         * 4,5   arr[3]
         * arr.length =  4  ，即arr[]数组中包含了四个元素，每个元素均为一个数组
         */
        //定义一个3*4的数组
       int[][] arrs = new int[3][4];//此时定义动态初始化二维数组
        arrs[0][0] = 99;
        arrs[0][1] = 98;
        arrs[0][2] = 97;
        arrs[0][3] = 96;
        /**
         *  定义三个二维组，每个数组四个元素即三行四列
         *  行的个数即为二维组个数，列的个数即为每个二维组中元素的个数
         *  每个二维组四个元素
         *  即arrs[0]arrs[1]arrs[2]三个数组
         *  数组元素为arrs[0][0]arrs[0][1]arrs[0][2]arrs[0][3]
         */
        arrs[1][0] = 1;
        int[][] arr = {{1,2},{2,3},{3,4},{4,5}};//此时定义静态初始化二维数组
        System.out.println(arr[0]);//打印arr[0]的地址名  arr[0][0]即是索引arr[0]数组中的第一个元素
        printarr(arr);
    }
    public static int[][] printarr(int[][] arrays){
        for (int i = 0; i < arrays.length; i++) {//打印四个二维组
            for (int j = 0; j < arrays[i].length; j++) {//打印各个二维组当中的元素
                System.out.print(arrays[i][j]);
            }
            System.out.print("  ");
        }
        return arrays;
    }
}

理解如：

• 如上图所示，创建了一个三行两列的二维数组
• 其中包含三个二维组，每个二维组当中含有两个元素
• 而往后的三维、四维数组不需要深究，了解即可
• 以三维数组为例：
• 可以简单理解为在一个二维数组中继续嵌套数组，得到的便是三维组
• 此时的三维组便是作为一个二维组的元素存在，二维组则作为整个数组的元素

如下：

public static void main(String[] args) {//了解三维数组
        int[][][] arr = new int[2][2][2];//动态初始化三维数组
        /**
         * 与二维数组理解一样，首先定义了数组arr[],此时arr[0]arr[1]作为arr[]数组的元素
         * arr[0]arr[1]是两个数组，我们称作二维组，同时也作为arr[]的元素存在
         * arr[0][0]arr[0][1]是两个数组，称三维组，同时作为arr[0]的元素存在
         */
        int[][][] arr2 = {{{10,20,30,40}},{{1,2,3,4,5}}};// 静态初始化三维数组
        /**等同于       int[][][] arr2 = new int[1][0][元素]
         * 此时索引：我们来索引arr[1][0]数组中的最后一个元素   5
         * arr2[1][0][4]
         */
        System.out.println(arr2[1][0][4]);//   5
    }

理解如：

冒泡排序

• 比较一个数组中，两个相邻的元素，若甲>乙则互换位置
• 每次比较都会产生一个最大或最小的数字
• 下一轮可以少一次排序：每过一轮排序都会有一个最大或最小的数字下沉到底，则在下一轮该数据可以不参与比较
• 最后一个元素不参与比较，在前面所有元素比较过程中，最后的元素将也会随着循环结束而交换至对应位置

public static void main(String[] args) {
        int[] arr = {2, 6, 23, 5, 12};
        arr(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static int[] arr(int[] Arrays) {//冒泡排序
        int str = 0;
        int i;
        //外层循环，决定循环几轮   循环i轮
        for (i = 0; i < Arrays.length-1; i++) {
            boolean _1 = false;//避免无意义的比较
            //内层循环，j = 每轮比较的次数   
            //一轮下沉一个数，少比一个数
            for (int j = 0; j < Arrays.length-1-i; j++) {
                //j<Arrays.length-1-i：每过一轮则会有一个数据下沉到底，该数据则不需要再次比较，所以每次-i
                //j<Arrays.length-1：将会把已经下沉的数据仍参与比较，虽然结果正确，但出现了不必要的比较
                //每次比较都会比较到j的极限从而停止比较
                if (Arrays[j]>Arrays[j+1]){//升序
                    //交换位置
                    str = Arrays[j];
                    Arrays[j] = Arrays[j+1];
                    Arrays[j+1] = str;
                    _1 = true;
                }
            }
            if (_1 == false){
                break;
            }
        }
        System.out.println(i);//循环i轮
        return Arrays;
    }

Arrays类了解*

• Arrays数组工具类Java.util.Arrays
• API中提供了一个工具类可以对数据类型进行一些基本操作
• 注意查看JDK帮助文档
• Arrays类中的方法均为static修饰的静态方法，使用时可直接调用
• 常见具有以下功能：