3-数组

数组

数组的概述

1>数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
2>创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
3>数组的长度一旦确定，就不能修改。

一维数组

声明

type var[] 或 type[] var;

Java语言中声明数组时不能指定其长度(数组中元素的数) 例如：int a[5];

初始化

静态初始化

静态初始化 ：在定义数组的同时就为数组元素分配空间并赋值。

int arr[] = new int[]{ 3, 9, 8};
或
int[] arr = {3,9,8};

动态初始化

动态初始化 ：数组声明且为数组元素分配空间与赋值的操作分开进行

int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;

数组元素的引用

定义并用运算符new为之分配空间后，才可以引用数组中的每个元素

数组元素下标可以是整型常量或整型表达式

数组元素下标从0开始

每个数组都有一个属性length指明它的长度，数组一旦初始化，其长度是不可变的

数组元素的默认初始化值

数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化

内存解析

多维数组

二维数组的声明和初始化

静态初始化

int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
System.out.println(arr.length); //3
System.out.println(arr[1].length); //2
int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};//类型推断，只能一行时使用

注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。

动态初始化1

int[][] arr = new int[3][2];
System.out.println(arr[0]); //一维数组地址
System.out.println(arr[0][0]); //0

动态初始化2

int[][] arr = new int[3][];
System.out.println(arr[0]); //null

int[][] arr = new int[][3];//非法

数组元素的默认初始化值

针对于初始化方式一：比如：

int[][] arr = new int[4][3];

外层元素的初始化值为：地址值

内层元素的初始化值为：与一维数组初始化情况相同

针对于初始化方式二：比如：

int[][] arr = new int[4][];

外层元素的初始化值为：null

内层元素的初始化值为：不能调用，否则报错。

二分法查找

前提：所要查找的数组有序

int arr1[] = new int[]{-98,-77,-55,-22,0,1,23,34,54,66,77,88,99};
int dest = 2;
int head = 0; //初始的索引
int end = arr1.length - 1; //初始的末索引
boolean isFlag = true;
while(head <= end){
    int middle = (head+end)/2;
    if(dest == arr1[middle]){
        System.out.println("找到了，位置:"+middle);
        isFlag = false;
        break;
    }else if(arr1[middle] > dest){
        end = middle - 1;
    }else{
        head = middle + 1;
    }
}
if(isFlag){
    System.out.println("没找到");
}

排序算法

衡量排序算法的优劣

1.时间复杂度

2.空间复杂度

3.稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。

分类

排序算法分类： 内部排序 和 外部排序 。
内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。
外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

冒泡排序

排序思想：

1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。

int arr[] = new int[]{22,33,11,-99,0,62,21};
//冒泡排序
for(int i = 0;i < arr.length-1;i++){
    for(int j = 0;j<arr.length-1-i;j++){
        if(arr[j]>arr[j+1]){
            int temp = arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=temp;
        }
    }
}
for(int i = 0;i<arr.length;i++){
    System.out.print(arr[i]+" ");
}

快速排序

Arrays工具类的使用

java.util.Arrays

1 boolean equals(int[] a,int[] b) 判断两个数组是否相等。
2 String toString(int[] a) 输出数组信息。
3 void fill(int[] a,int val) 将指定值填充到数组之中。
4 void sort(int[] a) 对数组进行排序。
5 int binarySearch(int[] a,int key) 对排序后的数组进行二分法检索指定的值。