数组

3-4 数组

概述

​ 数组是相同数据类型的**多个数据的容器。**

​ 这些元素按**线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素。（“简单理解就是，一个跟一个顺序排列**”）。

创建格式

• 常用格式1. 数据类型[] 数组名称 = new 数据类型[数组长度];
• 创建数组的同时，制定数组中的内容

int[] ages = {10,11,12,13,14};

• 常用格式2. 数据类型[] 数组名称 = {数据内容1,数据内容2,…数据内容n};
• 数组长度通过 int 数据指定

int[] ages2 = new int[10];

通过下标操作数组数据的方式

1. 给数组某个下标赋值： 数组名称[下标] = 值;

ages[0] = 100;

2. 从数组某个下标取值： 数组名称[下标]

System.out.println(ages[0]);
ages2[0] = 99;
System.out.println(ages2[0]);

如何获取数组的长度：数组名称.length

for(int index = 0; index < ages.length; index ++){
    System.out.println(ages[index]);
}

数组不常用的创建方式

1. 创建数组，不初始化

格式： 数据类型[] 数组名;

int[] nums;

2. 创建数组，并制定数组中的内容

   格式： 数据类型[] 数组名称 = new 数据类型[]{内容1,内容2,内容3…内容n};

    int[] ages = new int[] {11,12,13,14};

数组常见问题

1. 数组下标越界问题；

int[] nums = {11,12,13,14,15};
System.out.println(nums[5]);

2. 空指针问题

int[] = nums;
System.out.println(nums);

寻找数组中的最大值/最小值

//1.	创建一个变量，用于存储遍历数组时发现的最大值
int n = nums[0];
//2.	循环取出数组中每一个内容，从1开始
for(int i = 1; i < nums.length; i ++) {
//3.	将数组中每一个内容与n比较，如果比n打，则将n的内容赋值为这个内容
    n = n > nums[i] ? n : nums[i];
}
System.out.println(n);

数组常用算法

冒泡排序

原理：
    - 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 
    - 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。
     	  在这一点，最后的元素应该会 是最大的数。 
    - 针对所有的元素重复以上的步骤，除了最后一个。 
    - 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public static void main(String[] args){

    int[] nums = {20,15,18,13,30,60};
    int temp;
    for(int i =0; i < nums.length-1; i ++){
        //内层循环控制的是，每轮比较的次数
        //第 i 轮 （i从0开始计算），比较次数为：length - i - 1
        for(int j = 0; j < nums.length - i - 1;j ++) {
            if(nums[j] > nums[j + 1]) {
                //两两相比，满足移动条件
                temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = temp;
            }
        }
    }
}

名字由来: 
	是因为最小（或最大）的元素会经由交换慢慢“浮”到数列的顶端（降序或升序），就如同水中的气泡最 终会上浮到顶端一样，故名“冒泡排序”。

升序排列的口诀:
	N个数字来排队 
	两两相比小靠前, 
	外层 循环length-1 
	内层循环length-i-1 
降序排序的口诀: 
	N个数字来排队 
	两两相比大靠前, 
	外层 循环length-1 
	内层循环length-i-1

二分查找（折半查找）

概述

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，二分查找要求数组数据 必须采用顺序存储结构有序排列。

原理

	首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功； 否则利用中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数 组，否则进一步查找后子数组。 
	重复以上过程，直到找到满足条件的数据，则表示查找成功， 直到子数组不存在为止，表示查找不成功。

1. 确定查找的范围 最小-最大

2. 计算中间的下标 (最小+最大) / 2

3. 比较中间下标数据，中间数据较大，则最大下标等于中间下标 - 1

   比较中间下标数据，中间数据较小，则最小下标等于中间下标 + 1

4. 当最小下标 大于 最大下标时，说明数据是不存在的

public static void main(String[] args){

	int[] nums = {10,20,30,40,50,60,70,80,90};
    //要查找的数据
    int num = 30;
    //关键的三个变量
    //1.	最小范围下标
    int minIndex = 0;
    //2.	最大范围下标
    int maxIndex = nums.length - 1;
    //3.	中间数据下标
    int centerIndex = (minIndex + maxIndex) / 2;
    while(true) {
        if(nums[centerIndex] > num) {
            //中间数据较大
            maxIndex = centerIndex - 1;
        }else if(nums[centerIndex] < num) {
            //中间数据较小
            minIndex = centerIndex + 1;
        }else {
            //找到了数据 数据位置： centerIndex
            break;
        }

        if(minIndex > maxIndex) {
            centerIndex = -1;
            break;
        }
        //当便捷发生变化，需要更新中间下标
        centerIndex = (minIndex + maxIndex) / 2;
    }
    System.out.println("位置是第 " + centerIndex + "个。");
}

多维数组

/*
	多维数组
	创建格式：
		数据类型[] 数组名 = new 数据类型[长度]
		int[][] 二维数组名称 = new int[长度][];
*/
public static void main(String[] args) {
    int[][] nums = new int[10][];
    
    nums[0] = new int[]{1,2,3};
    
    System.out.println(nums[0][2]);
}