0. 数组的API

1. 新建

int[] A=new int[5];
int[] B={5,3,4};
Integer[] B1={5,3,4};
System.out.println(Arrays.toString(A));//[0, 0, 0, 0, 0]
System.out.println(Arrays.toString(B));//[5, 3, 4]
System.out.println(B1[1].equals(B1[2]));//false
1
2
3
4
5
6

2. 遍历与修改

//1)遍历
for(int i=0;i<B.length;i++){
    System.out.println("B["+i+"]="+B[i]);
    }
    //B[0]=5；B[1]=3；B[2]=4

//2)遍历（支持foreach操作
for(int a:B){
    System.out.println(a);
    
    //5；4；3
1
2
3
4
5
6
7
8
9
10
11

3. 排序

//（1）函数sort默认排序：从小到大（可以对字符串进行排序）
System.out.println("oldArray"+Arrays.toString(B));//oldArray[5, 3, 4]
Arrays.sort(B);
System.out.println("newArray"+Arrays.toString(B));//newArray[3, 4, 5]

//(2) 函数sort一维自定义排序
Integer [] data={1,3,7,5,2};
//题目一：给一维数组data排序，从小到大（一维数组只能够使用包装类）
Arrays.sort(data,(a,b)->b.compareTo(a)); //大的数放在前面
System.out.println(Arrays.toString(data)); //[7, 5, 3, 2, 1]
//题目二：给一维数组data排序，从大到小
Arrays.sort(data, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
          return o1.compareTo(o2);
    }
});
System.out.println(Arrays.toString(data));//[1, 2, 3, 5, 7]

//(3) 函数sort二维自定义排序（二维不强求使用包装类）
//题目三：给二维数组自定义排序：先按第一维从大到小排，如果相同，那么就按第二位从小到大排(缩减）
Integer[][] data1={{1,5},{1,4},{2,3},{2,4}};
Arrays.sort(data1, (o1,o2)->{
      if(o1[0]==(o2[0])){ return o2[1]-(o1[0]);
       }else{  return o1[0]-(o2[0]);
       }
});
System.out.println(Arrays.deepToString(data1));//[[1, 5], [1, 4], [2, 3], [2, 4]]
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

1. 704. 二分查找

1. 题目展示
   
2. 代码详情：

class Solution {
    public int search(int[] nums, int target) {
        //1）只要题目涉及到有序数组，就需要考虑二分查找了。
        //2）找到开始和结尾，书写一个函数（数组，目标值）
        int head=0;
        int end=nums.length-1;
        int middle;
        //左闭右闭（这个最好用，避免后面因为只有一个元素而额外判断）
        while(head<=end){
            middle=((end-head)>>1)+head;  //通过移位符进行优化(重点)，里面括号不能忘记
            //middle=(end-head)/2+head;
            if(nums[middle]==target){
                return middle;
            }else{
                if(nums[middle]<target){
                    head=middle+1;
                }else{
                    end=middle-1;
                }
            }
        }
        return -1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

4. 解题思路

• 核心思路：二分查找
• 具体操作：选取三个指针：head，end和middle，middle每次都对半选取。大循环为一个while循环，head<=end，采用左闭右闭的方式。
• 注意事项：1）大的循环体里面是有等号；2）生成新的middle的时候，head和end要加+1或者-1；3）需要优化的地方就是middle的形成过程：middle=((end-head)>>1)+head,才用移位符。

2. 977. 有序数组的平方

1. 题目展示

2. 代码详情：

class Solution {
    public int[] sortedSquares(int[] nums) {
        //双指针法：从两边开始着手，从大数开始找
        int left=0;
        int right=nums.length-1;
        int[] result=new int[right+1];

        //遍历两边的值，然后依次存入数组中
        int i=right;
        //循环条件中包含等号，因为要把最后自己也添加进去。
        while(left<=right){
            if(nums[left]+nums[right]>0){
                //右边的更大
                result[i--]=nums[right]*nums[right];
                right--;
            }else{
                //左边的更大
                result[i--]=nums[left]*nums[left];
                left++;
            }
        }
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

4. 解题思路

• 核心思路：双指针
• 具体操作：双指针从两边开始，比较大的输出在最后一位上面。
• 注意事项：大的while循环需要里面是等号，因为需要把每一位数都存入结果中

1. 27. 移除元素

1. 题目展示

3. 代码详情：

class Solution {
    public int removeElement(int[] nums, int val) {
        
    //快慢指针:快指针的值如果不是目标值，就赋予给慢指针】
    int slow,fast;
    for(slow=0,fast=0;fast<nums.length;fast++){
        if(nums[fast]!=val){
            nums[slow]=nums[fast];
            slow++;
        }
    }
    return slow;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5. 解题思路

• 核心思路：快慢指针
• 具体操作：快指针进行遍历，如果遇到了非目标值，就把它赋值给慢指针，最后慢指针的大小即为结果的大小。
• 注意事项：单循环

4. 209. 长度最小的子数组

1. 题目展示

2. 代码详情：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //通过滑动窗口解析题目
        //与暴力解法的区别就是利用了已经计算好了的信息
        int sum=0;
        int min=nums.length+1;
        int slow=0;   //慢指针
        int fast;    //快指针
        int subset;  //序号差
        //通过快指针遍历定位
        for(fast=0;fast<nums.length;fast++){
            sum+=nums[fast];
            //如果目前的和大于需求值，则需要修改慢指针和最小数组大小
            while(sum>=target){
                subset=fast-slow+1;  //序列号
                min=subset<=min?subset:min;  //修正输出值,需要带等号
                //尝试把慢指针向前移动一位，同时值加上1
                sum-=nums[slow++];
            }
        }
        return min=(min==nums.length+1)?0:min;  //如果min值一直未变，输出0，否则输出最新的min
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

4. 解题思路

• 核心思路：滑动窗口
• 具体操作：定义两个前后指针，以end指针作为循环对象，对head指针使用while循环，如果不超出，就一直向前。
• 注意事项：1）大循环是for，小循环是while；2）for循环一定要从0开始，不然会漏掉1的情况。

59. 螺旋矩阵 II

1. 题目展示

3. 代码详情：

class Solution {
    public int[][] generateMatrix(int n) {

        //思路:如何绘制好一个圆
        //四边+中心（边为奇数）
        //四边（边为偶数）
        //1)新建数组
        int[][] data=new int[n][n];
        
        //2)特殊情况
        if(n==1) data[0][0]=1;

        //每一圈开始的位置
        int X=0;
        int Y=0;
        int num=0;
        while(n>1){
            //第一条边
            for(int x=X,y=Y ;y<X+n-1;y++){
                data[x][y]=++num;
                }
            //第二条边
            for(int x=X,y=Y+n-1;x<Y+n-1;x++){
                data[x][y]=++num;
                }
            //第三条边
            for(int x=X+n-1,y=X+n-1;y>=X+1;y--){
                data[x][y]=++num;
                }
            //第四条边
            for(int x=X+n-1, y=Y;x>=X+1;x--){
                data[x][y]=++num;

                }

            //更新值,填补中间值
            n=n-2;
            X++;
            Y++;
            if(n==1) data[X][Y]=++num;

        }
        return data;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

4. 解题思路

• 核心思路：定义边界，循环遍历
• 具体操作：就是要定义好遍历的规则。
  1）方法一：与之前螺旋矩阵II不同的是，这个不再是规律的正方形了，故需要写出通式。
  2）首先去除特殊情况；3）然后定义好四边的大小；4）逆时针你条边一条边遍历，遍历依次四边大小就要注意修正下；5）在遍历后面两条边的时候，for循环中约束有两条，即长和宽大小都要约束。
• 注意事项：1）最开始记录矩阵四边的序标（是序标不是长度）；在对四边进行遍历的时候，x和y的约束都加上吧。（有两个约束）

1. 54. 螺旋矩阵

1. 题目展示

2. 代码详情：

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        //思路和螺旋矩阵二是一样的。

        //1)起始位置标定
        int X=0;
        int Y=0;
        //2)长度标定
        int lX=matrix.length;
        int lY=matrix[0].length;
        //3)数字标定
        int num=1;
        //4)循环体
        while(lX>1 &&lY>1){
            //第一条边
            for(int x=X,y=Y;y<Y+lY-1;y++){
               matrix[x][y]=num++; 
            }

            //第二条边
            for(int x=X,y=X+lY-1;x<x+lX-1;x++){
               matrix[x][y]=num++; 
            }

            //第三条边
            for(int x=x+lX-1,y=X+lY-1;y>Y;y++){
               matrix[x][y]=num++; 
            }

            //第四条边
            for(int x=X,y=X+lY-1;x<x+lX-1;x++){
               matrix[x][y]=num++; 
            }


        }
        if(lX==1 && lY!=1){

        }
       if(lX!=1 && lY==1){

        }
        
        if(lX==1 && lY==1){



        }

        //5)输出结果
        List<Integer> list=new ArrayList<>();
        for(int i=0;i<matrix.length;i++){
            for(int j=0;j<matrix[0].length;j++){
                list.add(matrix[i][j]);
            }
        }
        return list;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

4. 解题思路

• 核心思路：定义边界，循环遍历
• 具体操作：就是要定义好遍历的规则。
  1）方法一：与之前螺旋矩阵II不同的是，这个不再是规律的正方形了，故需要写出通式。
  2）首先去除特殊情况；3）然后定义好四边的大小；4）逆时针你条边一条边遍历，遍历依次四边大小就要注意修正下；5）在遍历后面两条边的时候，for循环中约束有两条，即长和宽大小都要约束。
• 注意事项：1）最开始记录矩阵四边的序标（是序标不是长度）；在对四边进行遍历的时候，x和y的约束都加上吧。（有两个约束）