Leetcode刷题日记精选例题（附代码及链接）

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

一、查找指定元素下标

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

来源：力扣（LeetCode）
题目链接

提示：

• 你可以假设nums中的所有元素是不可重复的
• n将在[1,10000]之间
• nums的每个元素都将在[-9999,9999]之间

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

二、搜索插入位置

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

请必须使用时间复杂度为 O(log n) 的算法。

来源：力扣（LeetCode）
题目链接

使用二分

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

更简单的有暴力破解
暴力破解

    //非二分，暴力
    public static int searchInsert2(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            if (nums[i]>=target){
                return i;
            }
        }
        return nums.length;
    }

三、查找目标值在数组中的开始位置和结束位置

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

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

进阶：

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

来源：力扣（LeetCode）
题目链接

暴力破解

    private static int[] searchRange(int[] nums, int target){
        int[] test = new int[2];
        test[0]=-1;
        test[1]=-1;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i]==target){
                //左边界
                test[0] = i;
                test[1] = i;
                int j=i;
                while (j!=nums.length-1&&nums[j+1]==nums[j]){
                    test[1] = j + 1;
                    j++;
                }
                break;
            }
        }
        return test;
    }

二分

    public static int[] searchRange3(int[] nums, int target){
        int index = erfen(nums,target);
        int left = index;
        int right = index;
        if (index!=-1){
            //向左
            while (left-1>=0&&nums[left-1]==nums[left]){
                left--;
            }
            while (right+1<nums.length&&nums[right+1]==nums[right]){
                right++;
            }
        }
        return new int[]{left,right};
    }
    private static int erfen(int[] nums, int target) {
        int l = 0;
        int r = nums.length-1;
        while (l<=r){
            int mid = (l+r)/2;
            if (target<nums[mid]){
                r = mid-1;
            }else if (target>nums[mid]){
                l = mid+1;
            }else {
                return mid;
            }
        }
        return -1;
    }

四、移除元素

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

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

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

来源：力扣（LeetCode）
题目链接

暴力破解

    public static int removeElement(int[] nums, int val) {
        int length = nums.length;
        for (int i = 0; i < length; i++) {
            if (val==nums[i]){
                for (int j=i;j<length-1;j++){
                    nums[j] = nums[j+1];
                }
                length--;
                i--;
            }
        }
        return length;
    }

双指针算法

    public static int removeElement2(int[] nums, int val){
        int top = 0;
        int bot = 0;
        while (top<nums.length){
            if (nums[top]!=val){
                nums[bot] = nums[top];
                bot++;
            }
            top++;
        }
        return bot;
    }

五、有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
来源：力扣（LeetCode）
题目链接

双指针

    private static int[] method1(int[] arr) {
        int[] temp = new int[arr.length];
        int index = temp.length-1;
        int p1 = 0;
        int p2 = arr.length-1;
        while (p1<=p2){
            if (arr[p1]*arr[p1]<arr[p2]*arr[p2]){
                temp[index--] = arr[p2]*arr[p2];
                p2--;
            }else{
                temp[index--] = arr[p1]*arr[p1];
                p1++;
            }
        }
        return temp;
    }

六、长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

来源：力扣（LeetCode）
题目描述

暴力破解

    private static int check(int[] arr, int target) {
        int result = Integer.MAX_VALUE;
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = i; j < arr.length; j++) {
                sum+=arr[j];
                if(sum>=target){
                    //统计长度
                    int length = j-i+1;
                    result = result<length?result:length;
                }
            }
            sum=0;
        }
        return result<Integer.MAX_VALUE?result:0;
    }

滑动窗口算法

    public static int check2(int[] arr, int target){
        int left  = 0;
        int sum= 0;
        int result = Integer.MAX_VALUE;
        for (int right=0;right<arr.length;right++){
            sum+=right;
            while (sum>=target){
                //窗口收缩
                result = result<right-left+1?result:right-left+1;
                sum-=arr[left++];
            }
        }
        return result<Integer.MAX_VALUE?result:0;
    }

七、螺旋矩阵（高频）

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

力扣链接：
题目链接

    public static int[][] generateMatrix(int n) {
        int[][] arr = new int[n][n];
        //右下左上
        int loop = n/2;//循环次数//1
        int t = 1;
        int Xstart = 0;//每次循环x轴起始位置
        int Ystart = 0;//每次循环y轴起始位置
        int offset = 1;//偏移量

        int mid = n/2;
        while (loop>0){
            int i = Xstart;
            int j = Ystart;
            //上
            for (;j<Ystart+n-offset;++j){
                arr[Xstart][j]=t++;
            }

            //右
            for (;i<Xstart+n-offset;++i){
                arr[i][j]=t++;
            }

            //左
            //此时i=3,j=3
            for (;j>Ystart;j--){
                arr[i][j]=t++;
            }

            //此时i=3,j=0
            for (;i>Xstart;i--){
                arr[i][j]=t++;
            }
            Xstart+=1;
            Ystart+=1;
            offset+=2;
            loop--;
        }
        if (n%2==1){
            arr[mid][mid]=t;
        }
        return arr;
    }

八、最长和谐子序列

和谐数组是指一个数组里元素的最大值和最小值之间的差别 正好是 1 。

现在，给你一个整数数组 nums ，请你在所有可能的子序列中找到最长的和谐子序列的长度。

数组的子序列是一个由数组派生出来的序列，它可以通过删除一些元素或不删除元素、且不改变其余元素的顺序而得到。
力扣链接：
题目链接

    public int findLHS(int[] nums) {
        HashMap<Integer,Integer> map = new HashMap();
        int result = 0;
        for (int num : nums) {
            Integer count = map.get(num);
            if (count!=null){
                map.put(num,count+1);
            }else {
                map.put(num,1);
            }
        }
        for (int key :map.keySet()){
            if (map.containsKey(key+1)){
                int length = map.get(key)+map.get(key+1);
                result = result>length?result:length;
            }
        }
        return result;
    }