JAVA学习-Day08

数组排序

定义：将一堆杂乱无序的数据，按照一定的顺序进行排列，排列的过程即为数组排序

系统提供的排序算法：

Arrays.sort(array);

冒泡排序

定义(思想)：依次比较相邻的2个数据，如果前面的数据大于后面的数据，二者交换位置，一趟下来之后，最大的数据就会移动到末尾，这个数据在下一趟不在参与比较。第二趟仍然是依次比较相邻的2个数据，如果前面的数据大于后面的数据，二者交换位置，一趟下来之后，第二大的数据就会移动到次末尾·······以此类推，对于具有n个数的数组而言，进行n-1趟上述过程，就能让数组有序。

冒泡排序的格式很固定：

for(int i=0;i<数组名.length-1;i++)
{
    for(int j=0;j<数组名.length-1-i;j++)//-i是为了减少后续比较多次数，即第一遍排序后得出的最大值在后面的排序中不参与比较，减少比较次数。
    {
        if(数组名[j]>数组名[j+1])
        {
            数组类型 temp = 数组名[j];
            数组名[j] = 数组名[j+1];
            数组名[j+1] = temp;
        }
    }
}

//冒泡排序(从小到大排序)
        for(int i=0;i<arr1.length-1;i++)
        {
            for(int j=0;j<arr1.length-1-i;j++)
            {
                if(arr1[j]>arr1[j+1])
                {
                    int temp = arr1[j];
                    arr1[j] = arr1[j+1];
                    arr1[j+1] = temp;
                }
            }
        }

选择排序

定义(思想)：第一趟，从数组中找出最小值，并记录最小值的下标，让最小值与数组下标为0的元素交换位置。第二趟，刨除数组下标为0的元素，在剩下的元素中找出最小值，并记录最小值的下标，与数组下标为1的元素交换位置。第三趟，刨除数组下标为0和1的元素，在剩下的元素中找出最小值，并记录最小值的下标，与数组下标为2的元素交换位置，以此类推，如果要对ｎ个数排序，ｎ－１趟即可让数组有序。

选择排序的写法很固定：

for(int i=0;i<数组名.length-1;i++)
{
    int index = i;
    int min = 数组名[i];
    for(int j=i+1;j<数组名.length;j++)
    {
        if(数组名[j]<min)
        {
            index = j;
            min = 数组名[j];
        }
    }
    数据类型 temp = 数组名[i];
    数组名[i] = 数组名[index];
    数组名[index] =temp;
}

for(int i=0;i<arr1.length-1;i++)
        {
            int min = arr1[i];
            int index =i;
            //遍历待排序元素，找出最小值下标
            for(int j=i+1;j<arr1.length;j++)
            {
                if(arr1[j]<min)
                {
                    min = arr1[j];
                    index = j;
                }
            }
            //和待排序元素的第一个元素交换
            int temp = arr1[index];
            arr1[index] = arr1[i];
            arr1[i] = temp;
        }

二维数组

定义：数组是一个容器，不仅可以存放数据类型，还可以存放引用类型，即数组的元素可以是数组。如果一个数组的元素是数组，这样就构成了一个二维数组。

二维数组的定义

1.格式一：数据类型 [] [] 数组名

int[][] arr;

2.格式二：数据类型 数组名 [] [] (为了兼容C语言)

int arr[][];

二维数组的初始化

1.动态初始化

格式：数据类型[] [] 数组名 = new 数据类型[第一维元素个数] [第二维元素个数] 各个小数组的值必须相等。

数据类型[][] 数组名 = new 数据类型[行数][列数];
int[][] arr = new int[4][3];
即：定义了一个4行3列的二维数组，数组中每个元素的初始值是0。

2.静态初始化

格式：数据类型[] [] 数组名 = new 数据类型[] []{{值1,值2,值3·····},{值1,值2,值3·····},······};各个小数组的值可以不等。

int[][] arr = new int[][]{{8,22,35,17},{13,9,26,21}};
即：定义了一个2行4列的二维数组，数组的初始值是8,22,35,17,13,9,26,21

简化格式：数据类型[] [] 数组名 = {{值1,值2,值3·····},{值1,值2,值3·····},······};

int[][] arr = {{8,22,35,17},{13,9,26,21}};
即：定义了一个2行4列的二维数组，数组的初始值是8,22,35,17,13,9,26,21

例：

int[][] arr1 = new int[2][3];
System.out.println(arr1);
//打印输出结果为：[[I@3d012ddd
//[[:二维数组
//I:表示元素类型是int
//@:表示它后面是地址
//3d012ddd:16位进制的地址 

二维数组的访问

1.访问第一维(行)

格式：数组名[第一维的下标]

由于二维数组可以看成1个元素是数组的一维数组。因此，数组名[第一维的下标]获取的是内层数组的地址。如果打印数组名[第一维的下标]得到的是一个地址值。

int[][] arr1 = new int[2][3] ;
System.out.println(arr1);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
//输出打印的结果为：[[I@3d012ddd
//               [I@626b2d4a
//               [I@5e91993f
//由上述结果可知，两个小数组的地址并不连续

2.二维数组元素的访问

格式：数组名[第一维的下标] [第二维的下标]

数组名[第一维的下标] [第二维的下标]可以看成是一个特殊的变量，因此可以对其进行赋值和取值。

在java中二维数组本身有一个堆区空间，内部每一个一维数组也有自己独立的堆区空间。二维数组中存储的是每一个一维数组的起始地址。

在C语言中，二维数组所有元素的内存是连续。

二维数组注意事项

1.数组下标越界

每一维的下标都不能越界

2.空指针异常

二维数组的数组名赋值为null的时候，不能再操作数据

二维数组内的每个一维数组赋值为null的时候，不能再操作数据

二维数组的遍历

二维数组的遍历指的是找到数组中的每个元素。通常使用循环嵌套来遍历数组元素。

通用格式：

数据类型[] [] 数组名 = new 数据类型 [第一维元素的个数] [第二维元素的个数];
for(int i=0;i<数组名.length;i++)
{
    for(int j=0;j<数组名[i].length;j++)
    {
        数组名[i][j];//数组名[i][j]就是具体的元素
    }
}

例：

int[][] arr1 = new int[][] {{1,5,3,7,9},{1,5,6},{5,99,36,56,8,3,56,2}};
System.out.println("输出该三维数组内的所有元素：");
for(int i=0;i<arr1.length;i++)
{
    for(int j=0;j<arr1[i].length;j++)
    {
        System.out.print(arr1[i][j] + " ");
    }
    System.out.println();
} 

多维数组

多维数组是指三维或者三维以上的数组。

几维数组就用几层循环嵌套来遍历。