基本数组题练习
Posted 小智RE0
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了基本数组题练习相关的知识，希望对你有一定的参考价值。
文章目录
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以上是关于基本数组题练习的主要内容，如果未能解决你的问题，请参考以下文章
Leetcode练习(Python)：树类：第108题：将有序数组转换为二叉搜索树：将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。 本题中，一个高度平衡二叉树是指一个二叉树每个节点 的