LeetCode刷题笔记之数组

已于 2023-12-28 15:10:22 修改
阅读量1.1k 收藏 15
点赞数 20
分类专栏： 课程复习 文章标签： leetcode 笔记 算法
于 2023-12-06 16:45:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43790779/article/details/134765655
版权

一、二分查找

1. 704【二分查找】

  • 题目： 给定一个 n 个元素 有序的（升序） 整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
  • 代码：
class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        while(left <= right){
        	int mid = left - ((right-left)>>1);
        	if(nums[mid] < target){
        		left = mid + 1;
        	}
        	else if(nums[mid] > target){
        		right = mid - 1;
        	}else{
        		return mid;
        	}
        }
        return -1;
    }
}

2. 35【搜索插入位置】

  • 题目： 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
    请必须使用时间复杂度为 O(log n) 的算法。

  • 代码：

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

3. 34【在排序数组中查找元素的第一个和最后一个位置】

  • 题目： 给你一个按照非递减顺序 排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。
    你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

  • 代码：

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

4. 69【x 的平方根】

  • 题目： 给你一个非负整数 x ，计算并返回 x 的 算术平方根 。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被舍去 。
    注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

  • 代码：

class Solution {
    public int mySqrt(int x) {
    	if(x==0 || x==1){
    		return x;
    	}
	    int left = 1;  //注意这里需要由1开始
	    int right = x>>1 ;
	    while (left <= right){
	        int sqrt= left + ((right-left)>>1);
	        if(sqrt > x/sqrt){
	            right = sqrt- 1;
	        }else if(sqrt < x/sqrt){
	            left = sqrt + 1;
	        }else{
	            return sqrt;
	        }
	    }
	    return right;
    }
}

5. 367【有效的完全平方数】

  • 题目： 给你一个正整数 num 。如果 num 是一个完全平方数，则返回 true ，否则返回 false 。
    完全平方数 是一个可以写成某个整数的平方的整数。换句话说，它可以写成某个整数和自身的乘积。
    不能使用任何内置的库函数，如 sqrt 。
  • 代码：
class Solution {
    public boolean isPerfectSquare(int num) {
        if(num==0 || num==1){
            return true;
        }
        int left = 1;  //注意这里需要由1开始
        int right = num>>1 ;
        while (left <= right){
            int sqrt= left + ((right-left)>>1);
            if(sqrt > num/sqrt){
                right = sqrt- 1;
            }else if(sqrt < num/sqrt){
                left = sqrt + 1;
            }else{
                right = sqrt;
                break;
            }
        }
        if(right * right == num){
            return true;
        }else{
            return false;
        }
}

二、双指针（快慢指针）

1. 27【移除元素】

  • 题目： 给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1)额外空间并原地修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

  • 代码：

class Solution {
    public int removeElement(int[] nums, int val) {
    	int len = 0;
    	for(int j=0;j<nums.length;j++){
    		if(nums[j] != val){
    			nums[len++] = nums[j];
    		}
    	}
    	return len;
    }
}

2. 26【删除排序数组中的重复项】

  • 题目： 给你一个非严格递增排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次 ，返回删除后数组的新长度。元素的相对顺序应该保持一致 。然后返回 nums 中唯一元素的个数。考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：
    更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。返回 k 。
  • 代码：
class Solution {
    public int removeDuplicates(int[] nums) {
    	int k = 1;
    	for(int i=1;i<nums.length;i++){
    		if(nums[i] != nums[k-1]){
    			nums[k++] = nums[i];
    		}
    	}
    	return k;
    }
}

3. 283【移动零】

  • 题目： 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
    请注意 ，必须在不复制数组的情况下原地对数组进行操作。
  • 代码：
class Solution {
    public void moveZeroes(int[] nums) {
    	int len = 0;
    	for(int i=0;i<nums.length;i++){
    		if(nums[i] != 0){
    			nums[len++] = nums[i];
    		}
    	}
    	for(len;len<nums.length;len++){
    		nums[len] = 0;
    	}
    }
}

4. 977【有序数组的平方】

  • 题目： 给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
  • 代码：
class Solution {
    public int[] sortedSquares(int[] nums) {
    	for(int i=0;i<nums.length;i++){
    		nums[i] = nums[i] * nums[i];
    	}
    	int[] newNums = new int [nums.length];
    	int left = 0;
    	int right = nums.length-1;
    	int i = nums.length-1;
    	while(left <= right){
    		if(nums[left] <= nums[right]){
    			newNums[i--] = nums[right--];
    		}else{
				newNums[i--] = nums[left++]
			}
		}
		return newNums;
    }
}

三、滑动窗口

1. 209【长度最小的子数组】

  • 题目： 给定一个含有 n 个正整数的数组和一个正整数 target 。找出该数组中满足其总和大于等于 target 的长度最小的连续子数组 [ n u m s l , n u m s l + 1 , . . . , n u m s r − 1 , n u m s r ] [nums_l, nums_{l+1}, ..., nums_{r-1}, nums_r] [numsl​,numsl+1​,...,numsr−1​,numsr​] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
  • 代码：
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
    	int len = nums.length + 1;
    	int sum = 0;
    	int j = 0;
    	for(int i=0;i<nums.length;i++){
    		sum += nums[i];
    		while(sum >= target){
    			len = i - j + 1 < len ? (i - j + 1):len;
    			sum -= sum[j];
    			j++;
    		}
    	}
    	if(len == nums.length + 1){
    		return 0;
    	}else{
    		return len;
    	}
    }
}

2. 904【水果成篮】

  • 题目： 你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果种类 。
    你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：
    • 你只有两个篮子，并且每个篮子只能装单一类型的水果。每个篮子能够装的水果总量没有限制。
    • 你可以选择任意一棵树开始采摘，你必须从每棵树（包括开始采摘的树）上恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
    • 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
      给你一个整数数组 fruits ，返回你可以收集的水果的最大数目。
  • 代码：
class Solution {
    public int totalFruit(int[] fruits) {
        int left = 0;
        int maxNum = 0;
        Map<Integer,Integer> types = new HashMap<Integer,Integer>();
        for (int right = 0; right < fruits.length; right++) {
            int count = types.getOrDefault(fruits[right],0) + 1;
            types.put(fruits[right],count);
            while (types.size()>2){
                types.put(fruits[left],types.get(fruits[left])-1);
                if(types.get(fruits[left]) == 0){
                    types.remove(fruits[left]);
                }
                left++;
            }
            maxNum = maxNum > right-left+1 ? maxNum:right-left+1;
        }
        return maxNum;
    }
}

3. 76【最小覆盖子串】

  • 题目： 给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “” 。
    注意：对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
    如果 s 中存在这样的子串，我们保证它是唯一的答案。
  • 代码：
class Solution {
    Map<Character,Integer> sMap = new HashMap<Character,Integer>();
    Map<Character,Integer> tMap = new HashMap<Character,Integer>();
    public String minWindow(String s, String t) {
        if(s.equals(t)){
            return s;
        }
        String minSubStr = "";
        int left = 0;
        int subLeft = -1;
        int subRight = -1;
        int len = s.length();
        for (int i = 0; i < t.length(); i++) {
            int count = tMap.getOrDefault(t.charAt(i),0) + 1;
            tMap.put(t.charAt(i),count);
        }

        for (int i = 0; i < s.length(); i++) {
            char sChar = s.charAt(i);
            if(tMap.containsKey(sChar)){
                int count = sMap.getOrDefault(sChar,0) + 1;
                sMap.put(sChar,count);
            }
            while (hasSubStr() && left<=i){
                if(len >= i-left+1){
                    subLeft = left;
                    subRight = i;
                    len = i-left+1;
                }
                if(sMap.containsKey(s.charAt(left))){
                    int count = sMap.get(s.charAt(left)) - 1;
                    sMap.put(s.charAt(left),count);
                }
                left++;
            }
        }


        if(subLeft == subRight && subLeft==-1){
            return "";
        }
        return s.substring(subLeft,subRight+1);
    }
    public boolean hasSubStr(){
        Set tkeys = tMap.keySet();
        Iterator iterator = tkeys.iterator();
        while (iterator.hasNext()){
            Object tChar = iterator.next();
            if(sMap.containsKey(tChar)){
                if(sMap.get(tChar) < tMap.get(tChar)){
                    return false;
                }
            }else {
                return false;
            }
        }
        return true;
    }
}

四、模拟行为

1. 59【螺旋矩阵Ⅱ】

  • 题目： 给你一个正整数 n ，生成一个包含 1 到 n 2 n^2 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
  • 代码：
class Solution {
    public int[][] generateMatrix(int n) {
        int[][] arr = new int [n][n];
        int num = 1;
        for (int i = 0; i < n/2; i++) {
            for (int j = i; j < n-i; j++) {
                arr[i][j] = num++;
            }
            for (int j = i+1; j < n-i; j++) {
                arr[j][n-i-1] = num++;
            }
            for (int j = n-i-2; j >= i ; j--) {
                arr[n-i-1][j] = num++;
            }
            for (int j = n-i-2; j >i ; j--) {
                arr[j][i] = num++;
            }
        }
        if(n%2 != 0){
            int i = n/2;
            arr[i][i] = num;
        }
        return arr;
    }
}

2. 54【螺旋矩阵】

  • 题目： 给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
  • 代码：
class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        int n = matrix.length;
        int m = matrix[0].length;

        List<Integer> l = new ArrayList<>(n*m);

        for (int i = 0; i <= m/2; i++) {
            if(l.size() != n*m){
                for (int j = i; j < m-i; j++) {
                    l.add(matrix[i][j]);
                }
            }
            if(l.size() != n*m) {
                for (int j = i + 1; j < n - i; j++) {
                    l.add(matrix[j][m - i - 1]);
                }
            }
            if(l.size() != n*m) {
                for (int j = m - i - 2; j >= i; j--) {
                    l.add(matrix[n - i - 1][j]);
                }
            }
            if(l.size() != n*m){
                for (int j = n-i-2; j >i ; j--) {
                    l.add(matrix[j][i]);
                }
            }
        }
        return l;
    }
}

3. 146【螺旋遍历二维数组】

  • 题目： 给定一个二维数组 array，请返回「螺旋遍历」该数组的结果。
    螺旋遍历：从左上角开始，按照向右、向下、向左、向上的顺序依次提取元素，然后再进入内部一层重复相同的步骤，直到提取完所有元素。

  • 代码：

class Solution {
    public int[] spiralArray(int[][] array) {
        if (array.length == 0)
            return new int[]{};
        int n = array.length;
        int m = array[0].length;

        int[] arr = new int[n*m];
        int index = 0;
        for (int i = 0; i <= m/2; i++) {
            if(index != n*m){
                for (int j = i; j < m-i; j++) {
                    arr[index++] = array[i][j];
                }
            }
            if(index != n*m) {
                for (int j = i + 1; j < n - i; j++) {
                    arr[index++] = array[j][m - i - 1];
                }
            }
            if(index != n*m) {
                for (int j = m - i - 2; j >= i; j--) {
                    arr[index++] = array[n - i - 1][j];
                }
            }
            if(index != n*m){
                for (int j = n-i-2; j >i ; j--) {
                    arr[index++] = array[j][i];
                }
            }
        }
        return arr;
    }
}
abtgu
关注
  • 20
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode刷题笔记之 数组
weixin_43540151的博客
07-29 342
57. 插入区间 难度中等379 给你一个 无重叠的 *，*按照区间起始端点排序的区间列表。 在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。 示例 1： 输入：intervals = [[1,3],[6,9]], newInterval = [2,5] 输出：[[1,5],[6,9]] 示例 2： 输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8] 输出：[[1,.
LeetCode 刷题--数组
只不停的博客
02-27 1111
面试题03 数组中重复的数字 找出数组中重复的数字。 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。 示例 1： 输入： [2, 3, 1, 0, 2, 5, 3] 输出：2 或 3 class Solution { public int findRe...
LeetCode刷题笔记
m0_73731708的博客
06-12 897
第二遍重新遍历链表，同时记录前缀和 sum，哈希表中对应 sum 的节点是最后一次出现相同前缀和的节点，我们将这个节点的下一个节点，赋值给当前节点的下一个节点，中间跳过的部分总和即为 0。给你一个链表的头节点 head，反复删去链表中总和值为 0 的连续节点组成的序列。遍历一遍链表，同时记录前缀和，以当前前缀和为 key，当前节点为，存入哈希表中。简单来说就是，在原来链表基础上，头部添加0，利用前缀和的性质，前轴和相同时，两者之间的和为0(包括后一个)；两数之和梦开始的地方，让我们开始追逐自己的梦想吧！
Leetcode刷题笔记
qq_41910518的博客
09-16 518
2、是否可以定义一个递归函数，通过子问题（子树）的答案推导出原问题的答案？如果可以，写出这个递归函数的定义，并充分利用这个函数的返回值，这叫。前序位置的代码执行是自顶向下的，而后序位置的代码执行是自底向上的。前序位置是刚刚进入节点的时刻，后序位置是即将离开节点的时刻。在处理数组和链表相关问题时，双指针技巧是经常用到的，双指针技巧主要分为两类：左右指针和快慢指针。，我们可以理解为快速排序就是个二叉树的前序遍历，归并排序就是个二叉树的后序遍历。场景中，你完全可以把 BST 的中序遍历认为是遍历有序数组。
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
LeetCode 刷题笔记 with Java.zip
11-23
《LeetCode刷题笔记withJava》是一份专为Java开发者准备的算法实战指南，涵盖了LeetCode网站上前一百道编程挑战题目。这份资料旨在帮助程序员提升算法能力，掌握数据结构和问题解决技巧，对于准备面试或者想要提升...
leetcode刷题笔记之JavaScript
最新发布
11-08
leetcode刷题笔记之JavaScript LeetCode刷题笔记之JavaScript知识分享 在本篇文章中，我们将讨论LeetCode中的二叉树、数组、链表、哈希表、栈、队列、图等数据结构和算法题目，并提供相应的JavaScript解决方案。 ...
LeetCode:LeetCode 刷题笔记(C++, Python 实现)
04-12
LeetCode刷题笔记 ＃ 标题 标签 1个 两次总和 哈希表 2个 加两个数字 链表 3 最长子串，无重复字符 细绳 4 两个排序数组的中位数 大批 5 最长回文子串 细绳 6 之字形转换 细绳 7 反整数 数学 8 字符串到整数 ...
leetcode跳跃-leetcode:leetcode刷题笔记
06-30
leetcode刷题笔记 005-2. 最长回文子串 字符串+中心扩散 :star:010-3. 正则表达式匹配 动态规划 019-2. 删除链表的倒数第N个节点 链表+快慢指针 022-2. 括号生成 回溯法 :star:031-2. 下一个排列 数组+思维 034-2. ...
已知模式串t=“abcaabbabcab”，写出用KMP法求得的每个字符串对应的next和nextval函数值
热门推荐
abtgu的博客
04-18 2万+
#include <iostream> using namespace std; #define MAXLEN 255 typedef struct { char ch[MAXLEN+1]; int length; }SString; //next void get_next(SString T,int next[]); //nextval void get_next...
计算机组成原理期末复习题目
abtgu的博客
06-24 2万+
假定基准程序A在某计算机上的运行时间为100秒，其中90秒为CPU时间，其余为I/O时间。若CPU速度提高50%，I/O速度不变，则运行基准程序A所消耗的时间是 A. 55秒 B. 60秒 C. 65秒 D. 70秒 答案解析：假设提高速度后CPU消耗的时间为X秒，之前CPU的速度为v，则提高后为1.5v； CPU执行的指令条数不变，所以有 90×\times×V=X$\times$1.5V，则 X=60，再加上I/O时间，共70秒。 一个C语言程序在一台32位机.
gmpy2常见函数使用
abtgu的博客
09-08 1万+
gmpy2常见函数使用 1.初始化大整数 import gmpy2 gmpy2.mpz(909090) result:mpz(909090) 2.求大整数a,b的最大公因数 import gmpy2 gmpy2.gcd(6,18) result:mpz(6) 3.求大整数x模m的逆元y import gmpy2 #4*6 ≡ 1 mod 23 gmpy2.invert(4,23) result:mpz(6) 4.检验大整数是否为偶数 import gmpy2 gmpy2.is_even(6)
设计一个算法，通过一趟遍历确定长度为n的单链表中值最大的结点。
abtgu的博客
03-24 1万+
#include <iostream> using namespace std; typedef int ElemType; typedef struct LNode { ElemType data; //结点的数据域 struct LNode *next; //结点的指针域 }LNode,*LinkList; //LinkList为...
假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(注意不设头指针)，试编写相应的置空队列、判断队列是否为空、入队和出队等算法。
abtgu的博客
04-04 1万+
1. //置空队列 2. void initQueue(LinkQueue &Q) 3. { 4. Q.rear = new QNode; 5. Q.rear->next = Q.rear; 6. } 7. 8. //判断队列是否为空 9. int EmptyQueue(LinkQueue &Q) 10. { 11. ...
计算机网络实验-企业级网络构建与配置实现
abtgu的博客
12-14 1万+
一、实验目的 根据企业的网络建设需求，运用计算机网络课程中所学的理论知识与实践技能，用路由器和交换机等网络设备构建符合企业需求的物理网络，并进行正确的配置，保证整个网络系统能正常运行。 二、实验设备 ensp仿真软件 三、实验要求 用交换机和路由器等网络设备构建满足企业需求的复杂物理网络，对交换机和路由器进行正确配置实现企业级网络功能。并设计方案测试网络运行状态，有效处理和解决出现的问题，保证所构建的网络正常运行，满足企业网络的功能和性能需求。 四、实验内容 对各个设备进行命名和端口规划； IP地址规划；
回文是指正读反读均相同的字符序列，如“abba”和“abdba”均是回文，但“good”不是回文。试写一个算法判定给定的字符序列是否是回文。（提示：将一半的字符入栈）
abtgu的博客
04-04 1万+
1. int HuiWen(char *str) 2. { 3. SqStack S; 4. InitStact(S); 5. int len = strlen(str); 6. int i,judge=1; 7. for(i = 1;i<=len/2;i++) 8. { 9. push(S,*s...
CTF中关于RSA的常见题型
abtgu的博客
09-11 1万+
CTF中关于RSA的常见题型 关RSA算法原理的描述请看https://blog.csdn.net/weixin_43790779/article/details/105622327 1.已知(p, q, e)，求d。 示例：【CTF秀-crypto4】 p=447685307 q=2037 e=17，提交flag{d}即可。 解题思路： import gmpy2 p = 447685307 q = 2037 e = 17 phi = (p-1)*(q-1) d = gmpy2.invert(e,phi
下面程序段中带下划线的语句的执行次数的数量级是( )
abtgu的博客
05-22 8783
问题： 下面程序段中带下划线的语句的执行次数的数量级是( nlog2nnlog_2nnlog2​n )。 i:=1; WHILE i<n BEGIN FOR j:=1 TO n DO x:=x+1; i:=i*2; END 分析： i:=1; WHILE i<n BEGIN FOR j:=1 TO n DO x:=x+1; i:=i*2; END 语句频度最大的语句是i=i*2， 根据WHILE语句可知，2x∗i=n2^x*i = n2x∗i=n，执行次数x=log2n
Java版LeetCode刷题笔记：51-100题解析
这本Java版的LeetCode刷题笔记不仅提供了N皇后问题的解法，还涵盖了其他49个问题的详细解答，对于提升Java编程能力和算法理解具有很大帮助。读者可以通过提供的链接访问在线题解和项目源码，以便深入学习和实践。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值