2021-07-05

数组

概述

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

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

创建格式

格式 1. 数据类型[] 数组名称 = new 数据类型[数组长度];

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

格式 3. 数据类型[] 数组名; 格式 3 属于只创建了数组引用名， 并未在内存创建数组空间。

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

public static void main(String[] args) {
    //创建数组的格式
	//常用格式1.创建数组的同时，制定数组中的内容。
    // 数据类型[] 数组名称 = {数据1,数据2，数据3，...数据n};
    int[] ages = {10,11,12,13,14};
    //常用格式2.创建数组，并指定长度，不指定数组中的内容。
	// 数据类型[] 数组名称 = new 数据类型[数组长度]；
	// 数组长度通过int数据指定
    int[] ages2=new int[10];
    
    //通过下标操作数组数据的方式：
	//1.给数组某个下标赋值：数组名称[下标]=值;
    ages[e]=100;
	//2.从数组某个下标取值：数组名称[下标]
	System.out.println(ages[1]);
    ages2[e] = 99;
    System.out.println(ages2[0]);
    
    //如何获取数组的长度， 数组名称.length
    //数组的遍历
    for(int index=0;index<ages.length;index++) {
        //index: 0 1 2 3 4
        System.out,println(args[index]);
    }
    
    
    //数组不常用的创建方式：
	//1. 创建数组，不初始化
	//格式： 数据类型[] 数组名；
	int[] nums;
    //nums = new int[10];可以
    //nums = {1,2,3,4};不可以
	//2. 创建数组，并指定数组中的内容
	//格式： 数据类型[] 数组名称 = new 数据类型[]{内容1，内容2，内容3...内容n};
	int[] ages = new int[]{10,11,12,13,14};
}

下标

可以理解为数组中内容的数字序号，从 0 开始 ，对于长度为 n 的数组，下标的范围是 0~n-1。

可以通过下标的方式访问数组中的每一个元素。

例如： 创建 int 类型数组 arr ， 给数组 arr 的 5 下标赋值数据 ， 然后打印

int[] arr = new int[10];
arr[5] = 123;
System.out.println(arr[5]);

数组长度获取

数组名称.length

注意（数组常见问题）

使用数组不当， 会出现如下问题：

数组未赋值： 空指针异常

超出长度的下标操作： 数组越界异常

注意：数组的长度在创建时就固定了

//寻找数组中的最大值 | 最小值
public static void main(String[] args) {
    int[] nums = {10,30,40,33,22,20,11,0};
    //1.  创建一个变量，用于存储遍历数组时发现的最大值
    int n = nums[0];  //很多用0，极有可能发生所有数据都比n大。建议用数组第一个数
    //循环取出数组中的每一个内容与n比较，如果比n大，则将n的值赋值为这个内容
    for(int i=0;i<nums.length;i++) {
        n = n>nums[i]?n:nums[i];
    }
    System.out.println(n);
}

数组常用算法

冒泡排序

原理：

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

名字由来:

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

升序排列的口诀:

N个数字来排队

两两相比小靠前,

外层 循环length-1

内层循环length-i-1

降序排序的口诀:

N个数字来排队

两两相比大靠前,

外层 循环length-1

内层循环length-i-1

/**
 * 冒泡排序
 */
public static void main(String[] args) {
    int[] nums = {};
    int temp;
    //外层循环控制的是，比较的轮数
    //外层循环次数：length-1
    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;
            }
        }
    }
    
    //排序已经完成，下面是遍历打印查看的过程
    for(int i=0;i<nums.length;i++) {
        System.out.println(nums[i]);
    }
}

二分查找 （折半查找）

概述

二分查找也称折半查找（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 = 90;
    
    //关键的三个变量：
    //1. 最小范围下标
    int minIndex = 0;
    //2. 最大范围下标
    int maxIndex = nums.length-1;
    //3. 中间数据下标
    int midIndex = (minIndex+maxIndex)/2;
    while(true) {
        //System.out.println("循环了一次");
        if(nums[midIndex]>num) {
            //中间数据较大
            maxIndex = midIndex-1；
        }else if(nums[midIndex]<num) {
            //中间数据较小
            minIndex = midIndex+1;
        }else {
            //找到了数据，数据位置：midIndex
            break;
        }
        if(minIndex > maxIndex) {
            midIndex = -1;
            break;
        }
        //当边界发送变化，需要更新中间下标
        midIndex = (minIndex+maxIndex)/2;
    }
    System.out.println("位置："+midIndex);
}