持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第1天，[点击查看活动详情]

一，数组

数组主要解决多数据处理情况。变量与变量之间是独立的，没有联系，变量在内存中划分的时候，地址是随机的，最终通过变量名来访问数据。
数组相当于是一个有规则的容器，将所有的数据都存储在容器里，可以统一操作数据。
数组的本质是：一堆变量的总称，变量的地址是连续的。可以方便操作这些变量。等差数列
数组的特点：数组中每一个变量空间的类型和大小是一致的。数组一旦创建长度不可修改。内容可以在兼容情况下修改。数组提供角标来访问元素。数组本身是一个对象。在堆内存中创建‘有默认初始化值，0’。有一个属性length
函数中的引用数据类型变量存储的数组在堆内存中首元素的地址。
字符串的长度是一个方法，s.length()。数组的长度是一个属性
创建数组：
数据类型【】数组名=new 数据类型【长度】；//创建一个一维数组的数据类型数组，长度为【】
数据类型【】数组名=new 数据类型【】{元素1，元素2，元素3}；//创建一个一维数组的数据类型数组，指定元素。
数据类型【】数组名={元素1，元素2，元素3}；
访问元素：数组名【角标】；

二，一维数组

最值问题

获取数组的最大值，最小值。

public class Sample{
    public static void main(String [] args){
        int[] arr={5,7,1,4,3,8,2};
        int max=arr[0];
        int min=arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){
            max=arr[i];}
             if(arr[i]<min){
            min=arr[i];}
        }
      System.out.println("max = "+max,"min = "+min );
      arr=Add(arr,10);
    }
}

扩容问题

在数组中增加一个数。
数组的长度一旦确定不能改，非要改，只能创建新数组。

public static int[] add(int[] arr,int e){
    int[] newArr = new int[arr.length+1];
    for(int i=0;i< arr.length,i++)
    {
    newArr[i]=arr[i];
    }
    newArr[newArr.length-1]=e;
    return newArr;
}

二分查找

线性查找：从左到右，O（n）
二分查找：前提数组必须是有序的。时间复杂度为logn.

public class Sample{
    public static void main(String [] args){
        int[] arr={1,2,3,4,5,6,7,8}
        int key = 9;
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max)/2;
        while (true){
            if(  key < arr[mid]){
                max = mid -1;
            }
            else if(arr[mid] < key){
                min = mid +1;
            }
            else{
                break;
            }
            if(min>max){
            mid=-1;break;
            }
            mid=(min+max)/2;
        }
        System.out.print(mid);
    }
}

冒泡排序

bubbleSort();.从左到右两者之间依次进行比较。O(N^2)\

for(int i=0;i<arr.length-1;i++)//-1少一轮比较 {你你你你你你你你你你你你你你你你你你你
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;
     }
}
}
show(arr);

选择排序

暴力排序：每个元素都要比较。O（n^2）
当前元素和之后所有的元素进行比较，如果当前大于后者，则交换。selectSort();

public static void main(String[] args){
    int[] arr={2,5,1,5,7}
    for(int i = 0;i<arr.length-1;i++){
        for(int j=i+1;j<arr.length;j++){
            if(arr[i] > arr[j]){
                int temp = arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }
    }
    for(int i=0;i<arr.length;i++){
    System.out.print(arr[i]+" ")}
}

插入排序

insertSort();如果当前的数字的左边有数字的话，且左边的数字大于当前数字交换。O(N^2)

int [] arr={1,3,2,5,8,4};
for(int i=1;i<arr.length;i++){
    for(int j=i;j<0&&arr[j-1]>arr[j];j--){
        int temp = arr[j]; arr[j]=arr[j-1]; arr[j-1]=temp;
    }
}

计数排序

上面三个排序都是根据数据之间的大小关系来进行比较排序的。计数，基数，桶都是根据数据本身的特性比较，与大小无关的排序，这些排序只针对整数。
countSort();个数。是一个典型的牺牲空间换时间的排序。
核心思想：将数字和角标进行规整。
1,先获取最大值，最小值。
2，根据最大值和最小值计算存储数据的大小，max-min+1
3,计算偏移量offset,角标=数据-offset
nums【arr【i】-offset】++：表示arr【i】这个数字出现一次并累加。
nums【i】表示i+offset这个数据出现的次数。
O(N+M)

int[] arr={1,4,8,2,7,3,9,1,5,2,4,8,4,3}
int min=arr[0];
int max=arr[0];
for(int i=0;i<arr.length;i++){//N
    if(arr[i]>max){
        max=arr[i];
    }
     if(arr[i]<min){
        min=arr[i];
    }
}
int[] nums =new int[max-min+1];
int offset=min;
for(int i=0;i<arr.length;i++){//N
    nums[arr[i]-offset]++;
}
int index=0;
for(int i=0;i<nums.length;i++)//i是nums的角标{//M
    if(nums[i]!=0){
        for(int j=0;j<nums[i];j++){
        arr[index++]=i+offset;}
    }
}
show(arr);

三，二维数组

是由行列组成的表格，矩阵。我们在矩阵中访问元素的话，是根据行角标和列角标所确定的。
可以把一个二维数组看成多个一维数组。
本质：多维数组本身就是一个一维数组，只不过该一维数组中的每一个元素是另一个一维数组。
创建数组：
int 【】【】matrix=new int【3】【4】//3行4列
int 【】【】matrix=new int【】【】{{1，2，3，4}，{2，3，4，5}，{3，4，5，6}}
int【】【】matrix={{1，2，3，4}，{2，3，4，5}，{3，4，5，6}}
matrix:一维数组，matrix【0】：第一行数组。
matrix.length:表示行数。二维数组的行数
matrix【1】.length：表示二维数组中第二行的列数，第二个一维数组的长度
矩阵一定是二维数组，二维数组不一定是矩阵（锯齿矩阵）
matrix【i]【j]:表示这个一维数组元素中角标j的那个元素
matrix【i】：表示最外层那个一维数组当中角标i的那个元素。
特别的，如果一个二位数组的行和列相等为方阵

public static void main(String[] args){
    int【】【】matrix={{1，2，3，4}，{2，3，4，5}，{3，4，5，6}};
    for（int i=0;i<matrix.length;i++）{
        for(int j=0;j<matrix[i].length;j++){
            System.out.print(matrix[i][j]+" ");
        }
         System.out.println();
    }
}

JAVA——数组