LeetCode

最新推荐文章于 2025-03-15 11:57:53 发布

原创最新推荐文章于 2025-03-15 11:57:53 发布 · 置顶 · 130 阅读

0 ·

CC 4.0 BY-SA版权

1

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位，数组中每个元素只存储一个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。
示例 2:

输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。

思路
1首先判断最后一位是不是9
2不是的话直接+1；输出。是的话，最后一位直接赋值0，构建一个新的数组（原数组加+1）然后输出
class Solution {
    public int[] plusOne(int[] digits) {
        for(int i=digits.length-1;i>=0;i--){
            if(digits[i]!=9){
                digits[i]++;
                return digits;
            }
            digits[i]=0;
        }
        int[] newDigits=new int[digits.length+1];
        newDigits[0]=1;
        return newDigits;
                
    }
}

2

给定一个整数类型的数组 nums，请编写一个能够返回数组“中心索引”的方法。

我们是这样定义数组中心索引的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。

如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。

示例 1:

输入:
nums = [1, 7, 3, 6, 5, 6]
输出: 3
解释:
索引3 (nums[3] = 6) 的左侧数之和(1 + 7 + 3 = 11)，与右侧数之和(5 + 6 = 11)相等。
同时, 3 也是第一个符合要求的中心索引。
示例 2:

输入:
nums = [1, 2, 3]
输出: -1
解释:
数组中不存在满足此条件的中心索引。

思路
1先判断下标长度小于等于1的直接输出-1；
  2分别求出总和sum,leftnum,rightnum
  3利用 rightnum=sum-leftnum-nums[i]
  4判断rightnum和leftnum是否相等
class Solution {
    public int pivotIndex(int[] nums) {
       if(nums.length<=1){
           return -1;
       }
         int sum=0;
        for(int i=0;i<nums.length;i++){
            sum+=nums[i];
        }
        int leftnum=0;
        int rightnum=0;
        for(int i=1;i<nums.length;i++){
            leftnum+=nums[i-1];
            rightnum=sum-leftnum-nums[i];
        
        if(leftnum==rightnum){
            return i;
         }
        }
        return -1;
    }
}

88
给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。

说明:

初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。
示例:

输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3

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

思路
1有效m，数组2元素n。将数组2元素放入数组1，然后打印，所有元素从小到大排序。
2即数组1的有效元素变成m+n。数组1角标有m个，数组2角标有n个，数组第一个角标为0。
3定义index1=m-1；index2=n-1；index3=m+n-1；对数组1和数组2从后往前比，谁的值大谁赋给index角标在数组1中的值。


class LC88{
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int index1=m-1;
        int index2=n-1;
        int indexEnd=m+n-1;
        while(index1>=0&&index2>=0){
            if(nums1[index1]>nums2[index2]){
                nums1[indexEnd--]=nums1[index1--];
            }else{
                nums1[indexEnd--]=nums2[index2--];
            }
        }
        if(index2>=0){
            for(int i=0;i<=index2;i++){
                nums1[i]=nums2[i];
            }
        }
    }
}

905
给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。

你可以返回满足此条件的任何数组作为答案。

示例：

输入：[3,1,2,4]
输出：[2,4,3,1]
输出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也会被接受。

思路：
1从数组第一个开始，对2取余，若为0，则当前不变，i++，用Scount++记录偶数的次数。。
2若对2取余不为0，则为奇数，将该值与末尾的第一个数互换，记录Dcount++偶数次数。i当前要减去1，对换的数进行余数判断。
3当Scount+Dcount时程序结束，将A返回。

       

class Solution {
    public int[] sortArrayByParity(int[] A) {
        if(A==null){
            return A;
        }
        int left=0;
        int right=A.length-1;
        int tem;
        while(left<right){
            if((A[left]&1)==1&&(A[right]&1)==0){
                tem=A[left];
                A[left]=A[right];
                A[right]=tem;
            }else if((A[left] & 1) == 0){
                left++;
                  }
           else if((A[right] & 1) == 1){
               right--;
                 }
        }
        return A;
    }
}

class Solution {
    public int[] sortArrayByParity(int[] A) {
        if(A==null){
            return A;
        }
       for(int i=1;i<A.length;i++){
        if(A[i]%2==1){
            continue;
        }
           int e=A[i];
           int j;
           for(j=i;j>0&&A[j-1]%2==1;j--){
               A[j]=A[j-1];
           }
           A[j]=e;
       }
        return A;
    }
}

class Solution {
    public int[] sortArrayByParity(int[] A) {
        if(A==null){
             return A;
        }
        int temp=0;
        int j=0;
        for(int i=0;i<A.length;i++){
             if(A[i]%2==0){
                continue;   
             }

        for(j=i+1;j<A.length;j++){
              if(A[j]%2==0){
                 temp=A[j];
                 A[j]=A[i];
                 A[i]=temp;
                 break;
               }           
         }
        if((A[j-1])%2==1&&j==A.length){
        break;
         }
           
        }
         return A;
    }
}

167
给定一个已按照升序排列的有序数组，找到两个数使得它们相加之和等于目标数。

函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。

说明:

返回的下标值（index1 和 index2）不是从零开始的。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
示例:

输入: numbers = [2, 7, 11, 15], target = 9
输出: [1,2]
解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。

思路
1、定义一个（最小角标）变量i=0，一个（最大角标）变量j=numbers.length-1。
2sum=nembers[i]+numbers[j]，如果sum的值小i++，sum的值大j--。
3i<j，找到后，将i+1，j+1返回。若运行下去，当i>j还没有结果那么返回null

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int a=0,r=numbers.length-1;
       
        while(a<r){
             int sum=numbers[a]+numbers[r];
            if(sum==target){
               
                return  new int[]{a+1,r+1};
            }else if(sum<target){
                a++;
            }else{
                r--;
            }
        }
        return null;
    }
}

169
给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在众数。

示例 1:

输入: [3,2,3]
输出: 3
示例 2:

输入: [2,2,1,1,1,2,2]
输出: 2

class LC169{
    public int majorityElement(int[] nums) {
        int result=nums[0];
        int count=1;
        for(int i=1;i<nums.length;i++){
            if(nums[i]==result){
                count++;
            }else{
                count--;
                if(count==0){
                    result=nums[i];
                    count=1;
                }
            }
        }
        return result;
    }
}

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

示例:

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

思路：
1双指针，划窗机制。定义长度len初值0。两个变量分别为i，j。从左边开始往右，定义sum的初值0与数组角标j的值相                    加。若结果大于等于s，i往右一点缩短长度，若结果小于s，j往右移动扩大数值。直到数组最右。
2长度为j-i+1，注意，得对输入的判断，若相加的数小于s，则返回0。可能输入[1,2]，[0]。

class LC209{
    //双指针 滑窗机制
    public int minSubArrayLen(int s, int[] nums) {
        int len=0;
        int sum=0;
        int i=0;
        for(int j=0;j<nums.length;j++){
            sum+=nums[j];
            while(sum>=s){
                len=len==0?j-i+1:Math.min(j-i+1,len);
                sum=sum-nums[i];
                i++;
            }
        }
        return len;
    }
}

240
编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：

每行的元素从左到右升序排列。
每列的元素从上到下升序排列。
示例:

现有矩阵 matrix 如下：

[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。

给定 target = 20，返回 false。

思路：
1先对数组判断是否为空数组，或者该数组长度为0，由于是二维数组，同样要判断行列的长度是否为0，为0的话，返回false。
2拿一个角落的值，比如左下角的值，由于数组是大小排序的，当该值比target小的时候，往右边移动，当该值比target大的时候，往上边移动。当i<0或者j>长度-1的时候返回false。找到的话返回true。

class LC240{
    public boolean searchMatrix(int[][] matrix, int target) {
        //[] [[]]
        if(matrix==null||matrix.length==0||matrix[0].length==0){
            return false;
        }
        int row=matrix.length;
        int col=matrix[0].length;
        int i=row-1;
        int j=0;
        while(true){
            if(target<matrix[i][j]){
                i--;
            }else if(target>matrix[i][j]){
                j++;
            }else{
                return true;
            }
            if(i<0||j>=col){
                return false;
            }
        }
    }
}

118杨辉三角：给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。
在这里插入图片描述
在杨辉三角中，每个数是它左上方和右上方的数的和。
示例:

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

思路：

class Solution {
    public List<List<Integer>> generate(int numRows) {
        
		List<List<Integer>> lists=new ArrayList<List<Integer>>();
//				不能直接创建对象，创建接口的子类对象
		for(int i=1;i<=numRows;i++) {
			ArrayList<Integer> list=new ArrayList<Integer>();
			
			for(int j=0;j<i;j++) {//添加行数
				if(j==0||j==i-1) {//i-1该行最后一个元素
					list.add(1);
				}else {
					//
					list.add(lists.get(i-2).get(j)+lists.get(i-2).get(j-1));//传的是角标
					
				}
			}
			
			lists.add(list);
		}
		return lists;
    }
    
}