LeetCode数组编程题

最新推荐文章于 2022-04-23 12:19:25 发布

原创最新推荐文章于 2022-04-23 12:19:25 发布 · 918 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode724 #LeetCode66 #LeetCode136 #LeetCode905

JAVA 专栏收录该内容

21 篇文章

订阅专栏

本文精选LeetCode上的经典算法题目，包括加一操作、寻找中心索引、查找唯一元素、按奇偶排序、两数之和及数组合并，通过实例详细解析了各种算法的实现方法，如双指针技巧、滑窗算法等，帮助读者深入理解并掌握算法设计思想。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.LeetCode66给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。最高位数字存放在数组的首位，数组中每个元素只存储一个数字。你可以假设除了整数 0 之外，这个整数不会以零开头。

class Solution {
    public int[] plusOne(int[] digits) {
         int num =0;
        int carry = 1; //进位
        for(int i=digits.length-1;i>=0;i--){
           num = digits[i]+carry;  //对数组加1
           digits[i] = num%10;     //将num对10求余 存入数组
           carry =num/10;         //0到9除10为0，10除10为1
           if(carry==0){          //判断carry是否变换

               break;
           }
           
        }
        if(carry==0){
            return digits;
        }
        //carry不等于0，建立新数组，新数组长度为原数组长度加1
        int[] newarr = new int[digits.length+1];
          newarr[0] = 1;
          return newarr;
    }
}

2.LeetCode724给定一个整数类型的数组 nums，请编写一个能够返回数组“中心索引”的方法。我们是这样定义数组中心索引的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。

class Solution {
    public int pivotIndex(int[] nums) {
         if(nums.length<=1){      //数组长度小于等于1，都没有中心索引
            return -1;
        }
        int leftSum =0;
        int rightSum = 0;
        int sum =0;
        for(int i=0;i<nums.length;i++){
            sum+= nums[i];        //计算总和
        }
       
        for(int j=0;j<nums.length;j++){
            
            if(j==0){
                leftSum=0;
            }else{
               leftSum+=nums[j-1];    //计算左边数字之和
            }
                rightSum = sum-leftSum-nums[j];  //计算右边数字之和
            
            if(leftSum==rightSum){
                return j;
            }
        }
        return -1;
         
        
    }
}

3.LeetCode136.给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

class Solution {
    public int singleNumber(int[] nums) {
            Arrays.sort(nums);  //数组从小到大排序
            int i = 0;
            while(  i < nums.length - 1 ){
                
                if( nums[i] == nums[i+1] ){
                    
                     i+=2;              //相等 步长为二
                    
                }else{
                    
                    return nums[i];      //不等 则返回
                    
                }
               
                
            }
            
            return nums[nums.length - 1];   //循环执行完都没找到则为最后一个
            
    }
}

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

推荐思路：利用双指针，定义L为数组的最左边元素，R为数组的最右边元素。

   若左偶右奇    L++，R--
   若左奇右偶    先交换，L++，R--；
   若左奇右奇    R--
   若左偶右偶    L++

class Solution {
    public int[] sortArrayByParity(int[] A) {
        //不改变元素的相对位置，利用插入排序
        for(int i=0;i<A.length;i++){
            if(A[i]%2==1){
                continue;  //若当前位置为奇数，则本次循环结束，执行下一次循环

            }
            //当前位置为偶数
            int j;
            int e=A[i];
            for( j=i;j>0&&A[j-1]%2==1;j--){  //循环执行条件j>0且A[j-1]为奇数
                A[j] =A[j-1];   //将奇数往后移
            }
            A[j] =e;

        }
        return A;
    }

    /*
    以下三种全部改变元素的相对位置
    
    public int[] sortArrayByParity(int[] A) {
        int[] arr =new int[A.length];  //建立新数组
        int m=0;    
        int n =A.length-1;
        for(int i=0;i<A.length;i++){
            
            if(A[i]%2==0){          //数字为偶数，将它从新数组第一个元素开始放
               arr[m]=A[i]; 
                m++;
            }else{
                arr[n] =A[i];       //数字为奇数，将它从新数组最后一个元素开始放
                n--;
            }
            
            
        }
        return arr;            //返回新数组
    }
    */
    /*
    public int[] sortArrayByParity(int[] A) {
        if(A==null){          //判断数组是否为空
            return A;
        }
        int temp=0;
        for(int i=0;i<A.length;i++){
            if(A[i]%2==0){    //若数字为偶数则执行下一次循环
                continue;
            }
           
            for(int j=0;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;
            }
        }
    }
    public int[] sortArrayByParity3(int[] A) {
        //双指针
        //左偶右奇  L++，R--
        //左奇右偶  交换，L++，R--；
        //左奇右奇  R--
        //左偶右偶  L++
        //i>=j 循环结束
        int L=0;
        int R=A.length-1;
        
            while(L<R){
               if(A[L]%2==0&&A[R]%2==1){
                  L++;
                  R--;
               }else if(A[L]%2==1&&A[R]%2==0){
                    A[L]=A[L]+A[R];
                    A[R]=A[L]-A[R];
                    A[L]=A[L]-A[R];   
                    L++;
                    R--;
               }else if(A[L]%2==1&&A[R]%2==1){
                   R--;
               }else{
                  L++;
               }
            }
            return A;
        }
    
    */
}

5.LeetCode167：给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。

提示：利用双指针

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int sum=0;
        int len=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;
    }
}

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

提示：滑窗算法

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        //双指针
        int l=0;
        int r=numbers.length-1;
        while(l<r){
            int sum=numbers[l]+numbers[r];
            if(sum==target){
                return new int[]{l+1,r+1};   //以数组的形式返回  他俩的下标且加一
            }else if(sum>target){
                r--;    //sum 大于目标值 则r--
            }else{ 
                l++;    //sum 小于目标值 则l++
            }
            
        }
        return null;
    }
}

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

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

class Solution {
    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];   //nums1[index1]大于nums2[index2] ，将                                                //将index1的值赋给indexEnd
                 indexEnd--;
                 index1--;
             }else{
                 nums1[indexEnd] =nums2[index2];
                 indexEnd--;
                 index2--;
             }
        }
        if(index2>=0){
            for(int i=0;i<=index2;i++){
                nums1[i]=nums2[i];
            }
        }
    }
}