LeetCode 算法 只出现一次的数字,两个数组的交集 II,加一，移动零，两数之和

文章目录

• • 只出现一次的数字
  • 两个数组的交集 II
  • 加一
  • 移动零
  • 两数之和

只出现一次的数字

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

class Solution {
    public int singleNumber(int[] nums) {
    //     与	&	两个数字相与：当两个数字对应的二进位均为1时，结果位为1，否则为0。参与运算的数以补码出现。
    //     或	|	两个数字相或：当两个数字对应的二进位有一个为1时，结果位为1，否则为0。参与运算的数以补码出现。	
    // 异或  ^  两个数字相异或：当两个数字对应的二进位相异时，结果位为1，否则为0。参与运算的数以补码出现。
        // 三个不同数（异或后）   两个相互异或必得第三个数 
    if(nums == null || nums.length == 0){
        return 0;
    }
    int a = 0;
    for(int i : nums){
        a = a^i;
    }
    return a;
    }
}

两个数组的交集 II

给定两个数组，编写一个函数来计算它们的交集。

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {

    //     /*
    //         首先对两个数组进行排序，然后使用两个指针遍历两个数组。
    //         初始时，两个指针分别指向两个数组的头部。
    //         每次比较两个指针指向的两个数组中的数字，如果两个数字不相等，则将指向较小数字的指针右移一位，
    //         如果两个数字相等，将该数字添加到答案，并将两个指针都右移一位。当至少有一个指针超出数组范围时，遍历结束。*/
    //     //第一个数组的第i个元素小于第二个数组的第j个元素
  
    Arrays.sort(nums1);
    Arrays.sort(nums2);
    List<Integer> as = new ArrayList<>();
    for(int i = 0,j = 0;i<nums1.length && j < nums2.length;){
        if(nums1[i] > nums2[j]){
            j++;
        }else if(nums1[i] < nums2[j]){
            i++;
        }else{
            as.add(nums2[j]);
            i++;
            j++;
        }

    }
    int[] an= new int[as.size()];
    for(int k = 0;k<as.size();k++){
        an[k] = as.get(k);
    }
    return an;

    }

}

加一

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

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

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

class Solution {
    public int[] plusOne(int[] digits) {
        
        digits[digits.length-1] = digits[digits.length-1]+1;

        for(int i = digits.length-1;i > 0;){
            if(digits[i] == 10){
                digits[i-1] = digits[i-1] + 1;
                digits[i] = 0;
            }else{
                i--;
            }
        }
        if(digits[0] == 10){
            int[] digits2 = Arrays.copyOf(digits,digits.length+1); 
            digits2[0] = 1;
            for(int i = 1;i<digits.length;i++){
                digits2[i] = digits[i-1];
            }
            digits2[1] = 0;
        return digits2;
        }else {
        return digits;
        }
    }
}

移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

class Solution {
    public void moveZeroes(int[] nums) {
        for(int j = 0;j<nums.length;j++){
            for(int i = 0;i<nums.length-1;i++){
            if(nums[i] == 0){
                int temp = nums[i];
                nums[i] = nums[i+1];
                nums[i+1] = temp;
            }
        }
        }
    }
}

两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

class Solution {
    public int[] twoSum(int[] nums, int target) {
       int i=1,j = 0;
       while(nums[i] + nums[j] != target){
           if(i == nums.length-1){
               j++;
               i = j;
           }
           i++;
           
           
       }
       return new int[]{j,i};
    }
}

标签：digits,加一,两个,数字,nums,int,II,数组,两数
来源： https://blog.csdn.net/wang121213145/article/details/121454607