基本数组题练习

---

1: LC8 字符串转换整数

原题位置:8. 字符串转换整数 (atoi)

请你来实现一个 myAtoi(string s) 函数，
使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。
函数 myAtoi(string s) 的算法如下：

读入字符串并丢弃无用的前导空格
检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。
 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。
如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
如果整数数超过 32 位有符号整数范围 [−231,  231 − 1] ，需要截断这个整数，
使其保持在这个范围内。
具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为 231 − 1 。
返回整数作为最终结果。

注意：
本题中的空白字符只包括空格字符 ' ' 。
除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。

示例 2：
输入：s = "   -42"
输出：-42
解释：
第 1 步："   -42"（读入前导空格，但忽视掉）
            ^
第 2 步："   -42"（读入 '-' 字符，所以结果应该是负数）
             ^
第 3 步："   -42"（读入 "42"）
               ^
解析得到整数 -42 。
由于 "-42" 在范围 [-231, 231 - 1] 内，最终结果为 -42 。

示例 3：
输入：s = "4193 with words"
输出：4193
解释：
第 1 步："4193 with words"（当前没有读入字符，因为没有前导空格）
         ^
第 2 步："4193 with words"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
         ^
第 3 步："4193 with words"（读入 "4193"；由于下一个字符不是一个数字，所以读入停止）
             ^
解析得到整数 4193 。
由于 "4193" 在范围 [-231, 231 - 1] 内，最终结果为 4193 。
 

提示：
0 <= s.length <= 200
s 由英文字母（大写和小写）、数字（0-9）、' '、'+'、'-' 和 '.' 组成

class Solution {
    public int myAtoi(String s) {
        int index =0;
        char[] cArr = s.toCharArray();
        //首先排除空格;
        while(index < s.length() && cArr[index] == ' '){
            index++;
        }
        //排除全为空格的状况;
        if(index == s.length()){
            return 0;
        }

        //对正负号处理;
        int sign = 1;
        char start = s.charAt(index);
        if(start == '+'){
            index++;
        }else if(start == '-'){
            index++;
            sign = -1;
        }
        int res = 0;
        //操作;
        while(index<s.length()){
            char c = s.charAt(index);
            //遇到非数字的退出;
            if(c > '9'||c < '0'){
                break;
            }
            //注意不能超出int值范围;
            if(res > Integer.MAX_VALUE/10 
               ||res == Integer.MAX_VALUE/10 && (c - '0') > Integer.MAX_VALUE%10){
                return Integer.MAX_VALUE;
            }
            if(res < Integer.MIN_VALUE/10
               ||res == Integer.MIN_VALUE/10 && (c - '0') > -(Integer.MIN_VALUE%10)){
                return Integer.MIN_VALUE;
            }
            //计算正常返回值;
            res = res * 10 +sign*(c-'0');
            index++;
        }
        return res;
    }
}

---

2: LC13 罗马数字转整数

原题位置:13. 罗马数字转整数

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。
27 写做  XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，
例如 4 不写做 IIII，而是 IV。
数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。
同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。

示例 1:
输入: s = "III"
输出: 3
    
示例 2:
输入: s = "IV"
输出: 4
    
示例 3:
输入: s = "IX"
输出: 9
    
示例 4:
输入: s = "LVIII"
输出: 58
解释: L = 50, V= 5, III = 3.
    
示例 5:
输入: s = "MCMXCIV"
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.
 

提示：
1 <= s.length <= 15
s 仅含字符 ('I', 'V', 'X', 'L', 'C', 'D', 'M')
题目数据保证 s 是一个有效的罗马数字，且表示整数在范围 [1, 3999] 内
题目所给测试用例皆符合罗马数字书写规则，不会出现跨位等情况。
IL 和 IM 这样的例子并不符合题目要求，49 应该写作 XLIX，999 应该写作 CMXCIX 。
关于罗马数字的详尽书写规则，可以参考 罗马数字 - Mathematics 。

使用一个基本的哈希表完成

import java.util.*;
import java.util.HashMap;
public class Solution {
    public int romanToInt(String s) {
        int l = s.length();
        if(l == 0){
            return 0;
        }
        HashMap<Character,Integer> map = new HashMap<>();
        map.put('I',1);
        map.put('V',5);
        map.put('X',10);
        map.put('L',50);
        map.put('C',100);
        map.put('D',500);
        map.put('M',1000);
        
        int res = map.get(s.charAt(0));
        for(int i=1;i<l;i++){
            //比较前一位数和当前数;
            int pre = map.get(s.charAt(i-1));
            int cur = map.get(s.charAt(i));
            if(pre >= cur){
                res += cur;
            }else{
                res += (cur - 2*pre);
            }
        }
        return  res;
    }
}

---

3: LC 加一

原题位置:66. 加一

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 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) {
        int l = digits.length;
        for(int i = l-1;i>=0;i--){
            digits[i]+=1;
            digits[i]%=10;
            //直到不进位;
            if(digits[i]!=0){
                return digits;
            }
        }
        //注意特殊用例; 99 / 999/9999....
        digits = new int[l+1];
        digits[0] = 1;
        return digits;
    }
}

---

4: LC 二进制求和

原题位置:67. 二进制求和

给你两个二进制字符串，返回它们的和（用二进制表示）。
输入为 非空 字符串且只包含数字 1 和 0。

示例 1:
输入: a = "11", b = "1"
输出: "100"
    
示例 2:
输入: a = "1010", b = "1011"
输出: "10101"
 
提示：
每个字符串仅由字符 '0' 或 '1' 组成。
1 <= a.length, b.length <= 10^4
字符串如果不是 "0" ，就都不含前导零。

注意二进制满2进1;

class Solution {
    public String addBinary(String a, String b) {
        int l1 = a.length();
        int l2 = b.length();
        //找出最大长度;
        int maxL = Math.max(l1,l2);
        if(l1==0){
            return b;
        }
        if(l2==0){
            return a;
        }
        //两个字符串反转;
        StringBuilder sb1 = new StringBuilder(a).reverse();
        StringBuilder sb2 = new StringBuilder(b).reverse();
        //两个字符串同等长度;
        while (sb1.length()<maxL){
            sb1.append("0");
        }
        while(sb2.length()<maxL){
            sb2.append("0");
        }

        StringBuilder result = new StringBuilder();
        int carry = 0;
        int number1 =0;
        int number2 =0;
        for(int i =0;i<maxL;i++){
            number1 = sb1.charAt(i) - '0';
            number2 = sb2.charAt(i) - '0';
            if(number1+number2+carry > 1){
                //满2进1;
                result.append(number1+number2+carry -2);
                carry = 1;
            }else{
                result.append(number1+number2+carry);
                carry = 0;
            }
        }
        //若最后还有进位;则补1;
        if(carry == 1){
            result.append("1");
        }
        //结果字符串反转;
        return  result.reverse().toString();
    }
}

---

5: LC 只出现一次的数字

原题位置:136. 只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。
找出那个只出现了一次的元素。
说明：你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:
输入: [2,2,1]
输出: 1
    
示例 2:
输入: [4,1,2,1,2]
输出: 4

可使用HashSet的值不可重复性进行挑选

class Solution {
    public int singleNumber(int[] nums) {
        Set<Integer> set=new HashSet<>();
        for (int item : nums) {
            //若已经添加则删除;
            if(!set.add(item)){
                set.remove(item);
            }
        }
        return (int) set.toArray()[0];
    }
}

或者使用异或运算的规则;

class Solution {
    public int singleNumber(int[] nums) {
        //采用异或运算;
        int res =0;
        for(int n: nums){
            //若数字和0异或;则为数字本身;
            //若数字和自己异或;则为0;
            res^=n;
        }
        return res;
    }
}

---

6: LC 137. 只出现一次的数字 II

原题位置 :137. 只出现一次的数字 II

给你一个整数数组 nums ，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次 。
请你找出并返回那个只出现了一次的元素。

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

示例 2：
输入：nums = [0,1,0,1,0,1,99]
输出：99
 
提示：
1 <= nums.length <= 3 * 104
-231 <= nums[i] <= 231 - 1
nums 中，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次

使用map集合遍历统计;

import java.util.HashMap;
class Solution {
    public int singleNumber(int[] nums) {
       //使用简易map;
       HashMap<Integer,Integer> map = new HashMap<>();
       //统计到数字的次数;
       for(int n:nums){
           map.put(n,map.getOrDefault(n,0)+1);
       }
       //遍历map集合;
       for(Map.Entry<Integer,Integer> m:map.entrySet()){
           if(m.getValue()==1){
               return m.getKey();
           }
       }
       return 0;
    }
}

---

7: LC 189. 轮转数组

原题位置:189. 轮转数组

给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

示例 1:
输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]

示例 2:
输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释: 
向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]
 
提示：
1 <= nums.length <= 105
-231 <= nums[i] <= 231 - 1
0 <= k <= 105

螺旋数组,若正好旋转一遍,元素位置不变;直接返回即可;
若需要旋转,则分别对前半部分,后半部分,整体数组进行交换反转,

class Solution {
    public void rotate(int[] nums, int k) {
        int l = nums.length;
        //若反转正好数组没变,直接结束;
        if(k%l == 0){
            return;
        }
        k = k%l;
        //反转前半部分;后半部分,整体;
        reverse(nums,0,l-k-1);
        reverse(nums,l-k,l-1);
        reverse(nums,0,l-1);
    }

    //反转数组;
    private void reverse(int[] nums,int left,int right){
        while(left<right){
            //交换;
            swap(nums,left,right);
            left++;
            right--;
        }
    }
    //交换数组元素;
    private void swap(int[] nums,int a,int b){
        if(a == b) return;
        int temp = nums[a];
        nums[a] = nums[b];
        nums[b] = temp;
    }
}

---

8: LC 240. 搜索二维矩阵 II

原题位置:240. 搜索二维矩阵 II

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

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

示例 1：
输入：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

提示：
m == matrix.length
n == matrix[i].length
1 <= n, m <= 300
-109 <= matrix[i][j] <= 109
每行的所有元素从左到右升序排列
每列的所有元素从上到下升序排列
-109 <= target <= 109

从左下角开始,对二维矩阵进行搜索;

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        //排除特殊用例;
        int row = matrix.length;
        int col = matrix[0].length;
        if(row == 0||col == 0){
            return false;
        }

        //同行内自左向右增大,同列内自上而下增大;
        //由左下角出发,进行探索;
        int x = row - 1;
        int y = 0;
        while(x>=0 && y <col){
            //若当前元素小于目标,那么该列即可排除;
            if(matrix[x][y]<target){
                y++;
            }else if(matrix[x][y]>target){
                //若当前元素大于目标,则该行排除;
                x--;
            }else{
                return true;
            }
        }
        return false;
    }
}

---

10: LC 448. 找到所有数组中消失的数字

原题位置:448. 找到所有数组中消失的数字

给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。
请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。
 
示例 1：
输入：nums = [4,3,2,7,8,2,3,1]
输出：[5,6]

示例 2：
输入：nums = [1,1]
输出：[2]
 
提示：
n == nums.length
1 <= n <= 105
1 <= nums[i] <= n

注意其中交换元素的方式;不用第三个变量, 用异步运算完成变量的交换;

import java.util.ArrayList;
class Solution {
    public List<Integer> findDisappearedNumbers(int[] nums) {
        List<Integer> list = new ArrayList<>();
        //桶排序思想;
        for(int i =0;i<nums.length;i++){
            while(nums[i]!=nums[nums[i]-1]){
                swap(nums,i,nums[i]-1);
            }
        }
        //比如[4,3,2,7,8,2,3,1]经过排序后;
        //[1, 2, 3, 4, 3, 2, 7, 8]

        //放置缺失的;
        for(int i = 0;i<nums.length;i++){
            if(nums[i]!=i+1){
                list.add(i+1);
            }
        }
        return list;        
    }
    //交换;
    private void swap(int[] nums,int a,int b){
        //排除同一位置的;
        if(a==b) return;
        nums[a] = nums[a]^nums[b];
        nums[b] = nums[a]^nums[b];
        nums[a] = nums[a]^nums[b];
    }
}

---