2.【数组】及Leetcode数组相关算法题

数组定义

数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。
数组是用于储存多个相同类型数据的集合。

结构形式

栈内存

在方法中定义的一些基本类型的变量和对象的引用变量都在方法的栈内存中分配，当在一段代码中定义一个变量时，java就在栈内存中为这个变量分配内存空间，当超出变量的作用域后，java会自动释放掉为该变量所分配的内存空间。

堆内存

堆内存用来存放由new运算符创建的对象和数组，在堆中分配的内存，由java虚拟机的自动垃圾回收器来管理。在堆中创建了一个数组或对象后，同时还在栈内存中定义一个特殊的变量。让栈内存中的这个变量的取值等于数组或者对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量，引用变量实际上保存的是数组或对象在堆内存中的地址（也称为对象的句柄），以后就可以在程序中使用栈的引用变量来访问堆中的数组或对象。

与结构或类中的字段的区别

数组中的所有元素都具有相同类型(这一点和结构或类中的字段不同，它们可以是不同类型)。数组中的元素存储在一个连续性的内存块中，并通过索引来访问(这一点也和结构和类中的字段不同，它们通过名称来访问)。

Java中Arrays详解

一、Arrays类的定义

Arrays类位于 java.util 包中，主要包含了操纵数组的各种方法
使用时导包:import java.util.Arrays

二、Arrays常用函数（都是静态的)

1.void Arrays.sort()

void Array.sort(Object[] array)

功能：对数组按照升序排序

int[] nums = {2,5,0,4,6,-10};
Arrays.sort(nums);
for(int i :nums)
    System.out.print(i+" ");
/* 之前:2 5 0 4 6 -10 
 * 结果:-10 0 2 4 5 6 
 */

Arrays.sort(Object[] array, int from, int to)

功能：对数组元素指定范围进行排序（排序范围是从元素下标为from,到下标为to-1的元素进行排序）

int[] nums = {2,5,0,4,1,-10};
        //对前四位元素进行排序
        Arrays.sort(nums, 0, 4);
        for(int i :nums)
            System.out.print(i+" ");
        /* 之前:2 5 0 4 1 -10
         * 结果:0 2 4 5 1 -10 
         */

2.Arrays.fill(Object[] array,Object object)

功能：可以为数组元素填充相同的值

int[] nums = {2,5,0,4,1,-10};
        Arrays.fill(nums, 1);
        for(int i :nums)
            System.out.print(i+" ");
        /* 之前:2 5 0 4 1 -10
         * 结果:1 1 1 1 1 1 
         */

Arrays.fill(Object[] array,int from,int to,Object object)

功能：对数组的部分元素填充一个值,从起始位置到结束位置，取头不取尾

int[] nums = {2,5,0,4,1,-10};
        //对数组元素下标2到4的元素赋值为3
        Arrays.fill(nums,2,5,3);
        for(int i :nums)
            System.out.print(i+" ");
        /* 之前:2 5 0 4 1 -10
         * 结果:2 5 3 3 3 -10 
         */

3.Arrays.toString(Object[] array)

功能：返回数组的字符串形式

int[] nums = {2,5,0,4,1,-10};
System.out.println(Arrays.toString(nums));
/*
 * 结果:[2, 5, 0, 4, 1, -10]
 */

4.Arrays.deepToString(Object[][] arrays)

功能：返回多维数组的字符串形式

int[][] nums = {{1,2},{3,4}};
        System.out.println(Arrays.deepToString(nums));
        /*
         * 结果:[[1, 2], [3, 4]]
         */

常用类型转换

String <—> Char

String str = String.valueOf('c');
char c=str.charAt(index) //返回在index位置的char字符。(返回值：char )
char[] chars=str.toCharArray( ) //将String 转化为 字符串数组。(返回值：char[] ) 

String数组 <—> List

String[] strs1= new String[]{"Tom", "Bob", "Jane"};
List<String> strList= Arrays.asList(strs1);
String[] strs2=new String[strList.size()];
strList.toArray(strs2);

int数组 <—> List

int[] data = {4, 5, 3, 6, 2, 5, 1};
List<Integer> list1 = Arrays.stream(data).boxed().collect(Collectors.toList());
int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray();

数组 <—> Set

String[] strs1= new String[]{"Tom", "Bob", "Jane"};
Set<String> set = new HashSet<String>(Arrays.asList(strs1)); 
String[] strs2=new String[set.size()];
set.toArray(strs2);

Set <—> List

List<String> list=new ArrayList<String>();
list.add("a");
list.add("b");
list.add("a");
Set<String> set=new HashSet<String>(list);
List<String> newlist=new ArrayList<String>(set);

List<int[ ]> <—> int[][]

List<int[]> list= new ArrayList<>();
list.add(new int[] {1,2});
list.add(new int[] {3,4});
int[][] arrs= list.toArray(new int[0][]);

数组相关的算法题

1.最大连续1的个数（力扣485）

给定一个二进制数组， 计算其中最大连续1的个数。

示例 1:

输入: [1,1,0,1,1,1]
输出: 3
解释: 开头的两位和最后的三位都是连续1，所以最大连续1的个数是 3.

注意：

输入的数组只包含 0 和1。
输入数组的长度是正整数，且不超过 10,000。

Java代码：

public int findMaxConsecutiveOnes(int[] nums) {
    int max = 0,temp = 0;
    for (int i:nums){
        if (i == 1)
            temp ++;
        else{
            max = Math.max(max, temp);
            temp = 0;
        }
    }
    return Math.max(max, temp);
}

2.移动零（力扣283）

https://blog.csdn.net/m0_46864744/article/details/111145419

3.移除元素（力扣27）

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1:

给定 nums = [3,2,2,3], val = 3,

函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。

你不需要考虑数组中超出新长度后面的元素。

示例 2:

给定 nums = [0,1,2,2,3,0,4,2], val = 2,

函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

注意这五个元素可为任意顺序。

你不需要考虑数组中超出新长度后面的元素。

Java解法的代码如下：

public int removeElement(int[] nums, int val) {
    int i = 0,len = 0;
    while (i < nums.length)
        if (nums[i] != val)
            nums[len++] = nums[i++];
        else i++;
        return len;
}

4.重新排列数组（力扣1470）

给你一个数组 nums ，数组中有 2n 个元素，按 [x1,x2,…,xn,y1,y2,…,yn] 的格式排列。

请你将数组按 [x1,y1,x2,y2,…,xn,yn] 格式重新排列，返回重排后的数组。

示例 1：

输入：nums = [2,5,1,3,4,7], n = 3
输出：[2,3,5,4,1,7]
解释：由于 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ，所以答案为 [2,3,5,4,1,7]

示例 2：

输入：nums = [1,2,3,4,4,3,2,1], n = 4
输出：[1,4,2,3,3,2,4,1]

示例 3：

输入：nums = [1,1,2,2], n = 2
输出：[1,2,1,2]

提示：

1 <= n <= 500
nums.length == 2n
1 <= nums[i] <= 10^3

解题思路（空间复杂度为O(n)的算法太简单，这里略过）：
因为题目限制了每一个元素 nums[i] 最大只有可能是 1000，这就意味着每一个元素只占据了 10 个 bit。（2^10 - 1 = 1023 > 1000）

而一个 int 有 32 个 bit，所以我们还可以使用剩下的 22 个 bit 做存储。实际上，每个 int，我们再借 10 个 bit 用就好了。

因此，在下面的代码中，每一个 nums[i] 的最低的十个 bit（0-9 位），我们用来存储原来 nums[i] 的数字；再往前的十个 bit（10-19 位），我们用来存储重新排列后正确的数字是什么。

在循环中，我们每次首先计算 nums[i] 对应的重新排列后的索引 j，之后，取 nums[i] 的低 10 位（nums[i] & 1023），即 nums[i] 的原始信息，把他放到 nums[j] 的高十位上。

最后，每个元素都取高 10 位的信息(e >> 10)，即是答案。
Java代码如下：

public int[] shuffle(int[] nums, int n) {
    int a = 0,b = n;
    for (int i = 0;i < nums.length;i ++)
        nums[i] |= (i % 2 == 0)?(nums[a ++] & 1023) << 10:(nums[b ++] & 1023) << 10;
    for (int i = 0; i < n << 1; i++)
        nums[i] >>= 10;
    return nums;
}