文章目录
- 题目大意：
- 两次遍历：
- 使用Java的API
- 题目大意：
- 使用Java的API
- 双指针
- KMP算法
励志：
Why waste precious time dreaming when waking life is so much better.
人生之美醒时现，何必耽梦负韶华。
1.反转字符串
Leetcode344.
Write a function that reverses a string. The input string is given as an array of characters s.
题目大意：
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
示例 1：
输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]
示例 2：
输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]
图解：
AC代码：
class Solution {
public void reverseString(char[] s) {
int len = s.length;
for(int i = 0; i < len/2; i++){
char temp = s[i];
s[i] = s[len - 1 - i];
s[len - 1 - i] = temp;
}
}
}时间复杂度：O（N）遍历数组长度
空间复杂度：O（1）
// 更好的体现双指针模板
class Solution {
public void reverseString(char[] s) {
int len = s.length;
int left = 0;
int right = len - 1;
while(left < right){
char temp = s[left];
s[left] = s[right];
s[right] = temp;
left++;
right--;
}
}
}
2. 整数反转
Leetcode7.
Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-231, 231 - 1], then return 0.
题目大意：
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
示例 1：
示例 2：
示例 3：
示例 4：
提示：
思路：判断整数是否溢出+整数反转 图解：
对于int整数型：取值范围应为
判定条件，我们可以简化为：
Ps：Integer.MIN_VALUE、Integer.MAX_VALUE
AC代码：
法一：
class Solution {
public int reverse(int x) {
int res = 0;
while(x!=0){
// 整数溢出
if(res < Integer.MIN_VALUE/10 || res > Integer.MAX_VALUE/10){
return 0;
}
int rem = x % 10;
res = res*10 + rem ;
x /= 10;
}
return res;
}
}法二：
class Solution {
public int reverse(int x) {
int res = 0;
while(x!=0){
int rem = x % 10;
int newRes = res*10 + rem ;
// 整数溢出
if(newRes/10 != res){
return 0;
}
res = newRes;
x /= 10;
}
return res;
}
}3.字符串中的第一个唯一字符
Leetcode387.
Given a string s, find the first non-repeating character in it and return its index. If it does not exist, return -1.
题目大意：
给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
示例：
s = "leetcode"
返回 0
s = "loveleetcode"
返回 2
两次遍历：
思路：统计次数+寻找一次 AC代码：
class Solution {
public int firstUniqChar(String s) {
// 将字符串转化成字符数组
char[] ss = s.toCharArray();
int len = ss.length;
// 统计字符出现的次数
int[] count = new int[26];
for(int i = 0; i < len; i++){
count[ss[i] - 'a'] ++;
}
// 查找出现过一次的字符
for(int i = 0; i < len; i++){
if(count[ss[i] - 'a'] == 1) {
return i;
}
}
return -1;
}
}使用Java的API
思路：
charAt(i) 函数 是获取字符串中第i位置的字符.
图解：
AC代码：
class Solution {
public int firstUniqChar(String s) {
int len = s.length();
for(int i = 0; i < len; i++){
if(s.indexOf(s.charAt(i)) == s.lastIndexOf(s.charAt(i))){
return i;
}
}
return -1;
}
}4.有效的字母异位词
Leetcode242.
Given two strings s and t, return true if t is an anagram of s, and false otherwise.
题目大意：
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
思路：字符串→字符数组→排序→比对 AC代码：
class Solution {
public boolean isAnagram(String s, String t) {
if(s.length() != t.length()){
return false;
}
char[] s1 = s.toCharArray();
char[] s2 = t.toCharArray();
Arrays.sort(s1);
Arrays.sort(s2);
return Arrays.equals(s1,s2);
}
}5.验证回文串
Leetcode125.
Given a string s, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.
题目大意：
给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
示例 1:
输入: "A man, a plan, a canal: Panama"
输出: true
解释："amanaplanacanalpanama" 是回文串
示例 2:
输入: "race a car"
输出: false
解释："raceacar" 不是回文串
提示：
1 <= s.length <= 2 * 105
字符串 s 由 ASCII 字符组成
双指针
思路：
双指针+跳过非数字字母+字母统一小写 AC代码：
class Solution {
public boolean isPalindrome(String s) {
if(s == null){
return true;
}
s = s.toLowerCase(); // 全部转化成小写
int len = s.length();
int left = 0;
int right = len - 1;
while(left < right){
// 跳过非数字字母
while(left < right && !Character.isLetterOrDigit(s.charAt(left))){
left++;
}
while(left < right && !Character.isLetterOrDigit(s.charAt(right))){
right--;
}
if(s.charAt(left) != s.charAt(right)){
return false;
}
left++;
right--;
}
return true;
}
}正则匹配
class Solution {
public boolean isPalindrome(String s) {
s = s.replaceAll("[^a-zA-Z0-9]","").toLowerCase();
String s1 = new StringBuffer(s).reverse().toString();
return s.equals(s1);
}
}6. 字符串转换整数 (atoi)
Leetcode8.
Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer (similar to C/C++'s atoi function).
题目大意：
实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。
函数 myAtoi(string s) 的算法如下：
- 读入字符串并丢弃无用的前导空格
- 检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
- 读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
- 将前面步骤读入的这些数字转换为整数（即，“123” -> 123， “0032” -> 32）。如果没有读入数字，则整数为 0。必要时更改符号（从步骤 2 开始）。
- 如果整数数超过 32 位有符号整数范围 [−2^31, 2^31 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于−2^31 的整数应该被固定为 −2^31 ，大于 2^31 − 1 的整数应该被固定为 2^31 − 1 。
- 返回整数作为最终结果。
注意：
本题中的空白字符只包括空格字符 ' ' 。
除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。
AC代码：
法一：
public int myAtoi(String str) {
str = str.trim();//去掉前后的空格
int len = str.length();
if (len == 0){
return 0;
}
int index = 0;
int res = 0;
int sign = 1;//符号，1是正数，-1是负数，默认为正数
//判断符号
if (str.charAt(index) == '-' || str.charAt(index) == '+')
sign = str.charAt(index) == '+' ? 1 : -1;
index++;
for (; index < len; ++index) {
int digit = str.charAt(index) - '0';
if (digit < 0 || digit > 9)
break;
//越界处理
if (res > Integer.MAX_VALUE / 10 || (res == Integer.MAX_VALUE / 10 && digit > Integer.MAX_VALUE % 10))
return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
res = res * 10 + digit;
}
return sign * res;
}法二：
class Solution {
public int myAtoi(String s) {
s = s.trim(); // 去除首尾空格
int len = s.length();
if(len == 0){
return 0;
}
int index = 0;
int sign = 1; // 默认正数
int res = 0;
// 判断符号，没有符号默认正数
if(s.charAt(index) == '-' || s.charAt(index) == '+'){
sign = s.charAt(index) == '+' ? 1 : -1;
index++;
}
// 判断数字
for(; index < len; index++){
int digit = s.charAt(index) - '0';
// 判断当前是否为数字
if( digit< 0 || digit > 9){
break;
}
int newRes = res * 10 + digit;
// 越界处理,数字在0-9之间所以，可以/10忽略
if(newRes/10 != res){
return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
}else{
res = newRes;
}
}
return sign * res;
}
}7. 实现 strStr()
Leetcode28.
Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.
题目大意：
给两个字符串 haystack 和 needle ，在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。
使用Java的API
AC代码：
class Solution {
public int strStr(String haystack, String needle) {
return haystack.indexOf(needle);
}
}双指针
思路：双指针 +一一比对 AC代码：
class Solution {
public int strStr(String haystack, String needle) {
int len1 = haystack.length();
int len2 = needle.length();
if(len2 == 0){
return 0;
}
int p = 0; // haystack
int q = 0; // needle
while(p < len1 && q < len2){
if(haystack.charAt(p) == needle.charAt(q)){
p++;
q++;
}else{ // 若不匹配,指针回退,p:原位的下一位,q:0位
p = p - q + 1; // p = (p - q) + 1
q = 0; // q = q - q
}
// 全部匹配
if(q == len2){
return p - q;
}
}
return -1;
}
}KMP算法
图解：
补充，next数组储存的是前缀==后缀，缀的长度
AC代码：
class Solution {
public int strStr(String haystack, String needle) {
int len1 = haystack.length();
int len2 = needle.length();
if(len2 == 0){
return 0;
}
// 放个哨兵
haystack = " " + haystack;
needle = " " + needle;
char[] s1 = haystack.toCharArray();
char[] s2 = needle.toCharArray();
// 构造next[]
int[] next = new int[len2 + 1];
// 从第二个开始，第一个默认为0
for(int i = 2, j = 0; i <= len2; i++){
// 不匹配
while(s2[i] != s2[j + 1] && j > 0){
j = next[j];
}
// 匹配成功
if(s2[i] == s2[j + 1]){
j++;
}
next[i] = j;
}
// 两字符串匹配
for(int i = 1, j = 0; i <= len1; i++){
// 不匹配
while(s1[i] != s2[j + 1] && j > 0){
j = next[j];
}
// 匹配成功
if(s1[i] == s2[j + 1]){
j++;
}
if(j == len2){
return i - j;
}
}
return -1;
}
}8. 外观数列
Leetcode38.
The count-and-say sequence is a sequence of digit strings defined by the recursive formula
题目大意：
给定一个正整数 n ，输出外观数列的第 n 项。
「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。
1. 1
2. 11
3. 21
4. 1211
5. 111221
第一项是数字 1
描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 "11"
描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 "21"
描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 "1211"
描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 "111221"
要 描述 一个数字字符串，首先要将字符串分割为 最小 数量的组，每个组都由连续的最多 相同字符 组成。然后对于每个组，先描述字符的数量，然后描述字符，形成一个描述组。要将描述转换为数字字符串，先将每组中的字符数量用数字替换，再将所有描述组连接起来。
例如，数字字符串 “3322251” 的描述如下图：
示例 1：
输入：n = 1
输出："1"
解释：这是一个基本样例。
示例 2：
输入：n = 4
输出："1211"
解释：
countAndSay(1) = "1"
countAndSay(2) = 读 "1" = 一 个 1 = "11"
countAndSay(3) = 读 "11" = 二 个 1 = "21"
countAndSay(4) = 读 "21" = 一 个 2 + 一 个 1 = "12" + "11" = "1211"
提示：
1 <= n <= 30
思路：递归 (每次的结果都与上一次的结果有关)
AC代码：
class Solution {
public String countAndSay(int n) {
// 递归出口
if(n==1){
return "1";
}
// 上一次的结果
String s1 = countAndSay(n - 1);
// 结果
StringBuilder res = new StringBuilder();
// 从第一个开始比对
char local = s1.charAt(0);
int count = 1;
for (int i = 1; i < s1.length(); i++) {
// 同一个数字出现的次数 count
if(s1.charAt(i) == local){
count++;
}else {
// 不符合
res.append(count);
res.append(local);
count = 1;
local = s1.charAt(i);
}
}
// 追加剩下的最后一次
res.append(count);
res.append(local);
return res.toString();
}
}9. 最长公共前缀
Leetcode14.
Write a function to find the longest common prefix string amongst an array of strings.
题目大意：
编写一个函数来查找字符串数组中的最长公共前缀。
示例 1：
输入：strs = ["flower","flow","flight"]
输出："fl"
示例 2：
输入：strs = ["dog","racecar","car"]
输出：""
解释：输入不存在公共前缀。
提示：
0 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] 仅由小写英文字母组成
AC代码：
class Solution {
public String longestCommonPrefix(String[] strs) {
int len = strs.length;
if (strs == null || len == 0)
return "";
// 假设第一个为公共前缀
String str = strs[0];
for(int i = 1; i < len; i ++){
// 逐一比对取共同
while(strs[i].indexOf(str) != 0){
str = str.substring(0, str.length() - 1);
}
}
return str;
}
}总结
