数组（3）—简单

Java实现

LeetCode

主要元素

数组中占比超过一半的元素称之为主要元素。给定一个整数数组，找到它的主要元素。若没有，返回-1。

示例 1：

输入：[1,2,5,9,5,9,5,5,5]
输出：5

示例 2：

输入：[3,2]
输出：-1

示例 3：

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

说明：
你有办法在时间复杂度为 O(N)，空间复杂度为 O(1) 内完成吗？

class Solution {
    public int majorityElement(int[] nums) {
        //投票算法+验证
        /*
        摩尔投票法：每次从序列里选择两个不相同的数字删除掉（或称为“抵消”），最后剩下一个数字或几个相同的数字，就是出现次数大于总数一半的那个。
        */
        int tmp = nums[0];
        int count = 1;

        for(int i = 1; i <nums.length; i++){
            if(tmp == nums[i])
              count ++;
            else
               count--;

            if(count == 0){
             tmp = nums[i];
             count = 1;
            }
        }

        //验证一遍
        int t = nums.length / 2 + 1;
        count = 0;
        for(int num : nums){
           if(num == tmp) count ++;
           if(count == t)
             return num;
        }

        return -1;

        
    }
}

两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

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

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

2 <= nums.length <= 10^3
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9
只会存在一个有效答案

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //暴力法会超时
        //哈希，哈希查找的时间复杂度为O(1)
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++){
           if(map.containsKey(target - nums[i]))
              return new int[] {map.get(target - nums[i]), i};
            
            else map.put(nums[i], i);
        }
         return null;
    }
}

删除排序数组中的重复项

给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,1,2],

函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。

你不需要考虑数组中超出新长度后面的元素。
示例 2:

给定 nums = [0,0,1,1,1,2,2,3,3,4],

函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。

你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}

class Solution {
    public int removeDuplicates(int[] nums) {
        //优雅的双指针~
        if(nums.length == 0)
          return 0;
        
        int i = 0;
        for(int j = 1; j < nums.length; j++){
            if(nums[j] != nums[i]){
               i++;
               nums[i] = nums[j];    //完成原地修改数组
            }
        }
        return i + 1;     
    }
}

移除元素

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

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

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

同上题

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

        return i;
    }
}

最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
进阶:

如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。

class Solution {
    public int maxSubArray(int[] nums) {
 
          int maxsum = nums[0];
          int tmp = 0;
          for(int i = 0; i < nums.length; i++){
              if(tmp > 0)   //tmp大于0，说明它对结果有增益
                 tmp += nums[i];
              else        //tmp小于0，对结果没有增益，直接丢弃
                  tmp = nums[i];
                 
                maxsum = Math.max(maxsum, tmp);
          }

          return maxsum;
    }
}

判定字符是否唯一

实现一个算法，确定一个字符串 s 的所有字符是否全都不同。

示例 1：
输入: s = “leetcode”
输出: false

示例 2：
输入: s = “abc”
输出: true

限制：
0 <= len(s) <= 100
如果你不使用额外的数据结构，会很加分。

class Solution {
    public boolean isUnique(String astr) {

        //题目想考察的：位运算，细节
        //如果字符串中的字符都是字母，则astr.length() > 52 直接输出false
        /*
        由于ASCII码字符个数为128个，可以使用两个64位的long变量来存储是否出现某个字符，
        二进制位1表示出现过， 0表示未出现过
        */

        long low = 0;
        long high = 0;

        for(char c : astr.toCharArray()){
            if(c >= 64){
                long index = 1L << (c - 64);
                if((high & index) != 0)    //若此位上为1，即该位代表的数字已存在
                   return false;
                high = high | index;
            }
            else{
                long index = 1L << c;
                if((low & index) != 0)
                   return false;
                low = low | index;
            }
        }
        return true;

 /*
        Set<Character> set = new HashSet<>();
        for(int i = 0; i < astr.length(); i++){
            if(set.contains(astr.charAt(i)))
              return false;
            set.add(astr.charAt(i));
        }

        return true;
        */
    }
}

子数组的最大平均数

给定 n 个整数，找出平均数最大且长度为 k 的连续子数组，并输出该最大平均数。

示例：

输入：[1,12,-5,-6,50,3], k = 4
输出：12.75
解释：最大平均数 (12-5-6+50)/4 = 51/4 = 12.75

提示：

1 <= k <= n <= 30,000。
所给数据范围 [-10,000，10,000]。

class Solution {
    public double findMaxAverage(int[] nums, int k) {
        //滑动窗口
        

        int sum = 0;
        for(int i = 0; i < k; i++)
           sum += nums[i];
        
        int maxs = sum;
        for(int i = k; i < nums.length; i++){
            sum = sum + nums[i] - nums[i - k];
            maxs = Math.max(maxs, sum);
        }

        return 1.0 * maxs / k;
    }
}

加一

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

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

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

示例 1：

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

输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。
示例 3：

输入：digits = [0]
输出：[1]

提示：

1 <= digits.length <= 100
0 <= digits[i] <= 9

class Solution {
    public int[] plusOne(int[] digits) {
        for(int i = digits.length - 1; i >= 0; i--){
            digits[i]++;
            digits[i] %= 10;
            if(digits[i] != 0)   //说明没有进位
              return digits;
        }
        //如果在上述没有返回，则表示最后一位还有进位，需扩展数组
        digits = new int[digits.length + 1];
        digits[0] = 1;

        return digits;
    }
}

杨辉三角

给定一个非负整数 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>> res = new ArrayList<>();
         
         for(int i = 0; i < numRows; i++){
             List<Integer> list = new ArrayList<>();
              for(int j = 0; j <= i; j++){
                  if(j == 0 || j == i)
                    list.add(1);
                  else{
                      list.add(res.get(i - 1).get(j - 1) + res.get(i - 1).get(j));
                  }
              }
              res.add(list);
         }

         return res;
    }
}

数组形式的整数加法

对于非负整数 X 而言，X 的数组形式是每位数字按从左到右的顺序形成的数组。例如，如果 X = 1231，那么其数组形式为 [1,2,3,1]。

给定非负整数 X 的数组形式 A，返回整数 X+K 的数组形式。

示例 1：

输入：A = [1,2,0,0], K = 34
输出：[1,2,3,4]
解释：1200 + 34 = 1234
示例 2：

输入：A = [2,7,4], K = 181
输出：[4,5,5]
解释：274 + 181 = 455
示例 3：

输入：A = [2,1,5], K = 806
输出：[1,0,2,1]
解释：215 + 806 = 1021
示例 4：

输入：A = [9,9,9,9,9,9,9,9,9,9], K = 1
输出：[1,0,0,0,0,0,0,0,0,0,0]
解释：9999999999 + 1 = 10000000000

提示：

1 <= A.length <= 10000
0 <= A[i] <= 9
0 <= K <= 10000
如果 A.length > 1，那么 A[0] != 0

class Solution {
    public List<Integer> addToArrayForm(int[] A, int K) {
        LinkedList<Integer> list = new LinkedList<>();
          int n = A.length;
          int i = n - 1;
          int lastnum = K;
          while(i >= 0 || lastnum > 0){
              if(i >= 0)   //在A还没完，K直接加上A本位的数，省略将进位单独拿出来
                lastnum += A[i];

              list.addFirst(lastnum % 10);

              lastnum /= 10;
              i--;
          }

        //反转链表

    return list;
    }
}

查找常用字符

给定仅有小写字母组成的字符串数组 A，返回列表中的每个字符串中都显示的全部字符（包括重复字符）组成的列表。例如，如果一个字符在每个字符串中出现 3 次，但不是 4 次，则需要在最终答案中包含该字符 3 次。

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

示例 1：

输入：[“bella”,“label”,“roller”]
输出：[“e”,“l”,“l”]
示例 2：

输入：[“cool”,“lock”,“cook”]
输出：[“c”,“o”]

提示：

1 <= A.length <= 100
1 <= A[i].length <= 100
A[i][j] 是小写字母

class Solution {
    public List<String> commonChars(String[] A) {
          //仅有小写字母，可以利用ascll码
          //
          List<String> list = new ArrayList<>();
          int[] num = new int[26];
          for(char ch : A[0].toCharArray()){
                  num[ch - 'a'] ++;
              }

          for(int i = 1; i < A.length; i++){
              int[] tmp = new int[26];
               for(char ch : A[i].toCharArray()){
                  tmp[ch - 'a'] ++;
              }

              for(int j = 0; j < 26; j++)
                 num[j] = Math.min(num[j], tmp[j]);    //找交集
          }

          for(int i = 0; i < num.length; i++){
              if(num[i] > 0){
                   for(int j = 0; j < num[i]; j++)
                      list.add(((char)('a' + i ) + ""));
              }
                 
          }

           
        return list;
    }
}

好数对的数目

给你一个整数数组 nums 。

如果一组数字 (i,j) 满足 nums[i] == nums[j] 且 i < j ，就可以认为这是一组 好数对 。

返回好数对的数目。

示例 1：

输入：nums = [1,2,3,1,1,3]
输出：4
解释：有 4 组好数对，分别是 (0,3), (0,4), (3,4), (2,5) ，下标从 0 开始
示例 2：

输入：nums = [1,1,1,1]
输出：6
解释：数组中的每组数字都是好数对
示例 3：

输入：nums = [1,2,3]
输出：0

提示：

1 <= nums.length <= 100
1 <= nums[i] <= 100

 代码实现

class Solution {
    public int numIdenticalPairs(int[] nums) {
        /*
        int count = 0;
         for(int i = 0; i < nums.length; i++)
            for(int j = i + 1; j < nums.length; j++)
               if(nums[i] == nums[j])
                  count ++;
        
        return count;
        */

        //简化 统计数组中出现的重复数字，可以利用map

        //再次简化，由题目可知，1 <= num[i] <= 100
        int ans = 0;   
        int[] tmp = new int[100];

        for(int num : nums){
            ans += tmp[num - 1];    //第一次碰到+0 (即此时只有一个数字，没有与它重复的，所以好数对为0)，第二次+1，第三次+2.....
            //可以用++累计实现组合方式
            tmp[num - 1] ++;    //临时数组存储数字出现的次数
        }

         return ans;

    }
}

第k个缺失的正整数

给你一个 严格升序排列 的正整数数组 arr 和一个整数 k 。

请你找到这个数组里第 k 个缺失的正整数。

示例 1：

输入：arr = [2,3,4,7,11], k = 5
输出：9
解释：缺失的正整数包括 [1,5,6,8,9,10,12,13,…] 。第 5 个缺失的正整数为 9 。
示例 2：

输入：arr = [1,2,3,4], k = 2
输出：6
解释：缺失的正整数包括 [5,6,7,…] 。第 2 个缺失的正整数为 6 。

提示：

1 <= arr.length <= 1000
1 <= arr[i] <= 1000
1 <= k <= 1000
对于所有 1 <= i < j <= arr.length 的 i 和 j 满足 arr[i] < arr[j]

class Solution {
    public int findKthPositive(int[] arr, int k) {
        int n = arr.length;
        for(int i = 0; i < n; i++){
            if(arr[i] - (i + 1)) >= k)      //一个不缺失元素的序列，会有arr[i]=i+1
               return k + i;
        }

        return k + n;     //数组范围内没有缺失的，补充在数组范围外
    }
}