数组基础学习

35.搜索插入位置（二分法）

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。

示例 1:

• 输入: [1,3,5,6], 5
• 输出: 2

示例 2:

• 输入: [1,3,5,6], 2
• 输出: 1

public static int binarysearch(int[] nums, int target) {
    if (target < nums[0]) {
        return 0;
    }
    if (target > nums[nums.length - 1]) {
        return nums.length;
    }
    int left = 0;
    int right = nums.length - 1;
    while (left <= right) {
        int mid = (right + left) >> 1;
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return right + 1;
}

34. 在排序数组中查找元素的第一个和最后一个位置（二分法）

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

进阶：你可以设计并实现时间复杂度为 $O(\log n)$ 的算法解决此问题吗？

示例 1：

• 输入：nums = [5,7,7,8,8,10], target = 8
• 输出：[3,4]

示例 2：

• 输入：nums = [5,7,7,8,8,10], target = 6
• 输出：[-1,-1]

示例 3：

• 输入：nums = [], target = 0
• 输出：[-1,-1]

public static int[] searchRange(int[] nums, int target) {
    int leftBorder = findLeftBorder(nums, target);
    int rightBorder = findRightBorder(nums, target);
    //左边界或者右边界没有被赋值
    if (leftBorder == -2 || rightBorder == -2) {
        return new int[]{-1, -1};
    }
    //左边界与右边界相差大于1 说明存在
    if (rightBorder - leftBorder > 1) {
        return new int[]{leftBorder + 1, rightBorder - 1};

    }
    //左边界与右边界相差小于等于1 说明不存在
    return new int[]{-1, -1};
}

//找右边界
public static int findRightBorder(int[] nums, int target) {
    int left = 0;
    int right = nums.length - 1;
    int rightBorder = -2;
    while (left <= right) {
        int mid = (right + left) >> 1;
        if (nums[mid] > target) {
            right = mid - 1;
        } else {
            left = mid + 1;
            rightBorder = left;
        }
    }
    return rightBorder;
}

//找左边界
public static int findLeftBorder(int[] nums, int target) {
    int left = 0;
    int right = nums.length - 1;
    int leftBorder = -2;
    while (left <= right) {
        int mid = (right + left) >> 1;
        if (nums[mid] >= target) {
            right = mid - 1;
            leftBorder = right;
        } else {
            left = mid + 1;
        }
    }
    return leftBorder;
}

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。

package com.yzu.lee.array.remove;

/**
 * @ClassName: RemoveEle
 * @Description:移除元素
 * @author: Leekuangyew
 * @date: 2022/3/31  19:37
 */
public class RemoveEle27 {
    public static int[] nums = {0, 1, 2, 3, 3, 0, 4, 2};

    //暴力破解
    public static int removeEle(int[] nums, int val) {
        int size = nums.length;
        for (int i = 0; i < size; i++) {
            if (nums[i] == val) {//发现需要移除的元素 将数组集体向前移动一位
                for (int j = i + 1; j < size; j++) {
                    nums[j - 1] = nums[j];
                }
                i--;//i也向前移动一位
                size--;//此时数组大小减一
            }
        }
        return size;
    }


    //双指针法
    public static int removeEle1(int[] nums, int val) {
        //定义快指针和满指针
        int fastIndex = 0;
        int slowIndex;
        for (slowIndex = 0; fastIndex < nums.length; fastIndex++) {
            if (nums[fastIndex] != val) {
                nums[slowIndex] = nums[fastIndex];
                slowIndex++;
            }
        }
        return slowIndex;
    }

    public static void main(String[] args) {
        int i = removeEle1(nums, 2);
        System.out.println(i);
        for (int j = 0; j < i; j++) {
            System.out.print(nums[j] + " ");
        }
    }
}

26.删除排序数组中的重复项（双指针法）

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

package com.yzu.lee.array.remove;

import java.util.Arrays;

/**
 * @ClassName: RemoveDuplicates26
 * @Description:删除有序数组中的重复项
 * @author: Leekuangyew
 * @date: 2022/3/31  20:25
 */
public class RemoveDuplicates26 {
    public static int[] nums = {0, 0, 1, 1, 1, 2, 2, 3, 3, 4};

    //暴力破解
    public static int bruteForce(int[] nums) {
        int size = nums.length;
        for (int i = 0; i < size; i++) {
            for (int j = i + 1; j < size; j++) {
                if (nums[j] == nums[i]) {
                    for (int k = j + 1; k < size; k++) {
                        nums[k - 1] = nums[k];
                    }
                    j--;
                    size--;
                }
            }
        }
        return size;
    }

    //双指针法
    public static int removeDuplicates(int[] nums) {
        //定义快慢指针
        int slowIndex = 0;
        int fastIndex;
        int size = nums.length;
        for (fastIndex = 0; fastIndex < size; fastIndex++) {
            if (nums[fastIndex] != nums[slowIndex]) {
                nums[++slowIndex] = nums[fastIndex];
            }
        }
        return slowIndex + 1;
    }


    public static void main(String[] args) {
        int size = bruteForce(nums);
        System.out.println(Arrays.toString(nums));
        System.out.println(size);

        size = removeDuplicates(nums);
        System.out.println(Arrays.toString(nums));
        System.out.println(size);
    }

}

977.有序数组的平方（双指针法）

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1： 输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

示例 2： 输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121]

package com.yzu.lee.array.sortedsquares;

import java.util.Arrays;

/**
 * @ClassName: sortedSquares
 * @Description:有序数组的平方
 * @author: Leekuangyew
 * @date: 2022/4/1  16:35
 */
public class SortedSquares977 {
    public static int[] nums = {-4, -1, 0, 3, 10};

    //暴力破解
    public static int[] bruteForce(int[] nums) {
        int size = nums.length;
        for (int i = 0; i < size; i++) {
            nums[i] *= nums[i];
        }
        Arrays.sort(nums);
        return nums;
    }

    //双指针法
    public static int[] sortedSquares(int[] nums) {
        //定义头尾指针
        int size = nums.length;
        int beginIndex = 0;
        int endIndex = size - 1;
        int resultIndex = size - 1;
        //定义结果数组
        int[] result = new int[size];
        while (endIndex - beginIndex >= 0) {
            if (nums[endIndex] * nums[endIndex] > nums[beginIndex] * nums[beginIndex]) {
                result[resultIndex--] = nums[endIndex] * nums[endIndex];
                endIndex--;
            } else {
                result[resultIndex--] = nums[beginIndex] * nums[beginIndex];
                beginIndex++;
            }
        }
        return result;
    }

    public static void main(String[] args) {
//        nums = bruteForce(nums);
//        System.out.println(Arrays.toString(nums));

        nums = sortedSquares(nums);
        System.out.println(Arrays.toString(nums));
    }
}

209.长度最小的子数组（滑动窗口）

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3] 输出：2 解释：子数组 [4,3] 是该条件下的长度最小的子数组。

package com.yzu.lee.array.minsubarrayLen;

/**
 * @ClassName: minSubArrayLen
 * @Description:长度最小的子数组
 * @author: Leekuangyew
 * @date: 2022/4/1  16:59
 */
public class MinSubArrayLen209 {
    public static int[] nums = {2, 3, 1, 2, 4, 3};

    //暴力破解
    public static int bruteForce(int[] nums, int target) {
        int size = nums.length;
        int result = Integer.MAX_VALUE;
        for (int i = 0; i < size; i++) {
            int sum = 0;
            for (int j = i; j < size; j++) {
                sum += nums[j];
                if (sum >= target) {
                    result = Integer.min(result, j - i + 1);
                }
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }

    //滑动窗口
    public static int minSubArrayLen(int[] nums, int target) {
        //定义滑动窗口开始位置与结束位置
        int left = 0;
        int right;
        int size = nums.length;
        int sum = 0;
        int result = Integer.MAX_VALUE;
        for (right = 0; right < size; right++) {
            sum += nums[right];
            while (sum >= target) {
                result = Integer.min(result, right - left + 1);
                sum -= nums[left++];
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }

    public static void main(String[] args) {
        int result = bruteForce(nums, 7);
        System.out.println(result);
    }
}

904.水果成篮（滑动窗口）

你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。

你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。

package com.yzu.lee.array.minsubarrayLen;

import java.util.HashSet;

/**
 * @ClassName: TotalFruit904
 * @Description:水果成篮
 * @author: Leekuangyew
 * @date: 2022/4/2  15:49
 */
public class TotalFruit904 {
    public static int[] nums = {3, 3, 3, 1, 2, 1, 1, 2, 3, 3, 4};

    //（滑动窗口）
    public static int bruteForce(int[] nums) {
        //定义窗口起始和终止位置
        int left = 0;
        HashSet<Integer> ans = new HashSet<>();
        int result = 0;
        int size = nums.length;
        for (int right = 0; right < size; right++) {
            ans.add(nums[right]);
            while (ans.size() > 2) {
                ans.remove(nums[left++]);
                for (int i = left; i < right; i++) {
                    ans.add(nums[i]);
                }
            }
            result = Integer.max(result, right - left + 1);
        }
        return result;
    }

    public static void main(String[] args) {
        int i = bruteForce(nums);
        System.out.println(i);
    }
}

59.螺旋矩阵II

​ 给你一个正整数 n ，生成一个包含 1 到 n2所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵 matrix 。

 输入：n = 3
 输出：[[1,2,3],[8,9,4],[7,6,5]]

思路：

1. 针对n*n的矩阵，定义循环次数int loop = n / 2;
2. 定义每次循环的起点 StartX，StartY
3. 定义偏移量offset，用于计算每次小循环的结束位置
4. 如果n为奇数，中间位置的mid需要单独赋值
5. 核心：代码块32行到53行 注意开始和结束条件
6. 退出循环后，如果n为奇数，给中间mid位置赋值

 package com.yzu.lee.array.generatematrix;
 
 import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
 
 /**
  * @ClassName: GenerateMatrix
  * @Description:螺旋矩阵2
  * @author: Leekuangyew
  * @date: 2022/4/2  17:20
  */
 public class GenerateMatrix59 {
 
     public static int[][] bruteForce(int n) {
         //定义总循环次数
         int loop = n / 2;
         //定义一个每次循环的起点
         int StartX = 0;
         int StartY = 0;
         //定义一个偏移量
         int offset = 1;
         //定义填充数字
         int count = 1;
         //定义结果数组
         int[][] result = new int[n][n];
         //定义中间位置
         int mid = n / 2;
         while (loop > 0) {
             int i = StartX;
             int j = StartY;
             //模拟上侧从左到右
             for (; j < StartY + n - offset; j++) {
                 result[StartX][j] = count++;
             }
             //模拟右侧从上到下
             for (; i < StartX + n - offset; i++) {
                 result[i][j] = count++;
             }
             //模拟下侧从右到左
             for (; j > StartY; j--) {
                 result[i][j] = count++;
             }
             //模拟左侧从下往上
             for (; i > StartX; i--) {
                 result[i][j] = count++;
             }
             //循环次数减一
             loop--;
             //起点加1
             StartX++;
             StartY++;
             //偏移量加2  左右上下各减1
             offset += 2;
         }
 
         if (n % 2 == 1) {
             result[mid][mid] = count;
         }
         return result;
     }
 
     public static void main(String[] args) {
         int[][] result = bruteForce(4);
         for (int i = 0; i < result.length; i++) {
             System.out.println(Arrays.toString(result[i]));
         }
     }
 }

54.螺旋矩阵

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

 输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
 输出：[1,2,3,4,8,12,11,10,9,5,6,7]

思路：

1. 获取数组大小m行n列
2. 定义边界
3. 退出循环条件：bottom >= top && right >= left （即底部边界大于等于顶部边界，右侧边界大于等于左侧边界）
4. 上侧从left开始，当col小于等于right时结束；右侧从top+1开始，当row小于等于right时结束
5. 进入下侧和左侧的判断条件：bottom > top && right > left （意思是下侧和左侧要同时满足条件 比如2行1列的数组 就需要循环两次）
6. 下侧从right-1开始，col大于等于left时结束；左侧从botton-1开始，row大于top时结束

 package com.yzu.lee.array.generatematrix;
 
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.LinkedList;
 
 /**
  * @ClassName: SpiralOrder
  * @Description:螺旋矩阵
  * @author: Leekuangyew
  * @date: 2022/5/6  18:53
  */
 
 public class SpiralOrder {
 
     public static int[] bruteForce(int[][] matrix) {
         //输入数组大小
         int m = matrix.length;
         int n = matrix[0].length;
         //定义结果数组
         int[] result = new int[m * n];
         //定义边界
         int left = 0;
         int right = n - 1;
         int top = 0;
         int bottom = m - 1;
         //定义填充结果数组的位置
         int count = 0;
 
         //这边主要注意边界条件
         while (bottom >= top && right >= left) {
             //上侧从左往右
             for (int col = left; col <= right; col++) {
                 result[count++] = matrix[top][col];
             }
             //右侧从上往下
             for (int row = top + 1; row <= bottom; row++) {
                 result[count++] = matrix[row][right];
             }
             //下侧从右往左 //左侧从下往上
             //这个判断条件的意思是下侧和左侧要同时满足条件 比如2行1列的数组 就需要循环两次
             if (bottom > top && right > left) {
                 /**
                  * 下侧和左侧的循环条件与上侧和右侧的有所不同
                  * 上侧从left开始，当col小于等于right时结束
                  * 右侧从top+1开始，当row小于等于right时结束
                  * 下侧从right-1开始，col大于等于left时结束
                  * 左侧从botton-1开始，row大于top时结束
                  */
                 //下侧从右往左
                 for (int col = right - 1; col >= left; col--) {
                     result[count++] = matrix[bottom][col];
                 }
                 //左侧从下往上
                 for (int row = bottom-1; row > top; row--) {
                     result[count++] = matrix[row][left];
                 }
             }
             //边界条件变化
             left++;
             right--;
             top++;
             bottom--;
         }
         return result;
     }
 
     public static void main(String[] args) {
         int[][] matrix = new int[2][1];
 //        matrix[0] = new int[]{1, 2, 3};
 //        matrix[1] = new int[]{4, 5, 6};
 //        matrix[2] = new int[]{7, 8, 9};
         matrix[0] = new int[]{1};
         matrix[1] = new int[]{2};
         int[] ints = bruteForce(matrix);
         System.out.println(Arrays.toString(ints));
     }
 }