LeetCode算法(二)字符串
字符串
目录
- 字符串
- 字符串反转
- 颠倒整数
-
- 解决思路
-
- 字符串中的第一个唯一字符
-
- 解题思路
-
- 有效的字母异位词
-
- 解决思路
-
- 判断回文串
-
- 解决思路
-
- 将字符串转换为整数
-
- 解题思路
-
- 实现strStr()
-
- 解决思路
-
- 数数并说
-
- 解决思路
-
- 最长公共前缀
字符串反转
请编写一个函数，其功能是将输入的字符串反转过来。
示例：
输入：s = “hello”
返回：”olleh”
解决思路:
- 逆序遍历字符串
具体思路：创建一个新的空字符串，将s的字符逆序放在空字符串中
问题:超出时间限制
String result = "";
for(int i=s.length()-1;i>=0;i--){
result += s.charAt(i);
}
System.out.print(result);
return result;- 通过数组来实现
具体思路：通过字符串转换为char数组，通过for循环来给char数组赋值
ps：一次可以给两个元素赋值
if(s==null || s.length()==0) return s;
char[] array = s.toCharArray();
for(int i=0;i2;i++){
array[i] = s.charAt(s.length()-i-1);
array[s.length()-i-1] = s.charAt(i);
}
return new String(array); - 使用栈来实现
具体思路：将字符串压栈之后，再弹出来的就是一个逆序的字符串
if(s==null || s.length()==0) return s;
Stack stack = new Stack<>();
char[] array = s.toCharArray();
for(Character c : array){
stack.push(c);
}
int length = s.length();
for(int i=0;iarray[i] = stack.pop();
}
return new String(array); - 使用递归
具体思路:找到递归临界条件，对临界条件不同的值做不同的处理
if(s==null || s.length()==0) return s;
int length = s.length();
if(length==1) {
return s;
}else{
return reverseString(s.substring(1)) + s.charAt(0);
}颠倒整数
给定一个 32 位有符号整数，将整数中的数字进行反转。
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:
假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−2^31, 2^31 − 1]。根据这个假设，如果反转后的整数溢出，则返回 0。
解决思路
x%10 取出最低位
x/10 去除最低位
public int reverse(int x){
int int_max= 0x7fffffff;
int int_min= 0x80000000;
long anwser = 0;
int result = 0;
while(x!=0){
anwser = anwser*10+(x%10);
x/=10;
}
if(anwser < int_min || anwser>int_max){
anwser = 0;
}else{
result = (int)anwser;
}
return result;
}字符串中的第一个唯一字符
给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
案例:
s = “leetcode”
返回 0.
s = “loveleetcode”,
返回 2.
注意事项：您可以假定该字符串只包含小写字母。
解题思路
通过一个map集合将字符串放在其中，遍历map，每次判断是否存在的时候，将当前元素从map中删除，结束后再将当前元素放入map中.
public int firstUniqChar(String s) {
Map map = new HashMap();
for(int i=0;imap.put(i,s.charAt(i));
}
for(int i=0;i//只需要将当前key与之后的字符串比较即可
Character c = map.get(i);
map.remove(i);
if(!map.containsValue(c)){
return i;
}
map.put(i,c);
}
return -1;
} 有效的字母异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的一个字母异位词。
示例 1:
输入: s = “anagram”, t = “nagaram”
输出: true
示例 2:
输入: s = “rat”, t = “car”
输出: false
说明:
你可以假设字符串只包含小写字母。
进阶:
如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？
解决思路
大体思路，都是记录字符串中各个字符出现的次数。然后比较两个字符串的内容情况.
- 使用hashmap
public boolean isAnagram(String s,String t){
Map map1 = new HashMap<>();
Map map2 = new HashMap<>();
int sLength = s.length();
int tLength = t.length();
if(sLength!=tLength){
return false;
}
for(int i=0;iget(s.charAt(i));
Integer tValue = map2.get(t.charAt(i));
map1.put(s.charAt(i),(sValue==null ? 0 : sValue)+1);
map2.put(t.charAt(i),(tValue==null ? 0 : tValue)+1);
}
/*
直接使用==操作符，比较的是两个字符串的引用地址，并不是比较内容
*/
for(Character c : map1.keySet()){
if(!map2.containsKey(c) || !map1.get(c).equals(map2.get(c))){
return false;
}
}
return true;
} - 使用数组，两个int型数组，sArray和tArray，来储存s和t字符串中的字符情况，a对应数组下标0，b对应数组下标1……
public boolean isAnagram(String s, String t) {
if (s.length() != t.length())
return false;
int[] sArray = new int[26];
int[] tArray = new int[26];
for (int i = 0; i < s.length(); i++) {
sArray[s.charAt(i)-97] ++;
tArray[t.charAt(i)-97] ++;
}
for (int i = 0; i < 26; i++)
if (sArray[i]!=tArray[i])
return false;
return true;
} - 更加简化的版本，使用一个数组，将第一个数组的各个字符出现次数++，在另一个字符中–，最后判断数组中各个字符的个数是否为0，若不为0，则返回false
public boolean isAnagram(String s, String t) {
int[] alphabet = new int[26];
for (int i = 0; i < s.length(); i++) alphabet[s.charAt(i) - 'a']++;
for (int i = 0; i < t.length(); i++) alphabet[t.charAt(i) - 'a']--;
for (int i : alphabet) if (i != 0) return false;
return true;
}判断回文串
给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
说明：本题中，我们将空字符串定义为有效的回文串。
示例 1:
输入: “A man, a plan, a canal: Panama”
输出: true
示例 2:
输入: “race a car”
输出: false
解决思路
我自己想的是，首先将多余字符去掉，然后在这个纯粹的字符串中比较，没想到提交之后时间超时了。这是我自己的代码
public boolean isPalindrome(String s) {
if(s == null){
return false;
}
if(s.equals("") || s.length()==1){
return true;
}
//首先将字符串变小写
String LowS = s.toLowerCase();
String temp = "";
String reserveTemp = "";
for(int i=0;i//若不是字母或数字，则跳过这个字符
while(!isNeed(LowS.charAt(i))){
if(i==LowS.length()-1){
break;
}
i++;
}
if(i == LowS.length()-1 && !isNeed(LowS.charAt(i))){
break;
}
temp += LowS.charAt(i);
}
for(int i=0;i2;i++){
//reserveTemp += temp.charAt(temp.length()-i-1);
if(temp.charAt(i) != temp.charAt(temp.length()-i-1)){
return false;
}
}
return true;
if(reserveTemp.equals(temp)){
return true;
}else{
return false;
}
} 上网看了别人的解答才知道自己的思路是对的，但做了太多不必要做的工作了。设置两个指针即可完成判断
public boolean isPalindrome(String s) {
int left =0,right = s.length()-1;
while(leftif(!isNeed(s.charAt(left))) left++;
else if(!isNeed(s.charAt(right))) right--;
else if((s.charAt(left)+32 - 'a')%32 != (s.charAt(right)+32 - 'a')%32) return false;
else{
left++;right--;
}
}
return true;
}
public boolean isNeed(Character c){
if((c >= 'a' && c<= 'z') ||(c>='0' && c<='9')
|| (c>='A' && c<='Z')){
return true;
}
return false;
} s.charAt(left)+32 - ‘a’)%32 != (s.charAt(right)+32 - ‘a’)%32 可忽略字符大小写判断的方法
将字符串转换为整数
题目大意
实现一个atoi函数，将字符串转成整形
要点：考虑所有的输入情况。
解题思路
前导字符是+或-或者没有，接下来输入的是数字，数字不能整数能表示的最大或最小数。如果超过就返回对应的最小或者最小的值。
public int myAtoi(String str){
//判断是否为空格，若是空格指针加1
int start=0;
int length = str.length();
//如果为空或者长度为0
//设置一个标志位，判断是正负
boolean positive = true;
if(str==null||length==0){
return 0;
}
if(str.charAt(start) == ' '){
while(str.charAt(start)==' '){
start++;
if(start>=length){
//全部都是空格
return 0;
}
}
}
//判断第一个字符是什么，若是正号
if(str.charAt(start) == '+'){
start++;
}else if(str.charAt(start)=='-'){
positive = false;
start++;
}else if(str.charAt(start) >= '0' && str.charAt(start) <='9'){
//strToNum字符串转数字
return strToNum(positive,start,str);
}else{
return 0;
}
//只有一个正号或负号
if(start>=length){
return 0;
}
//若后面跟的不是数字
if(str.charAt(start) < '0'||str.charAt(start) > '9'){
return 0;
}else{
return strToNum(positive,start,str);
}
}
/**
* 将已拿到的字符串转为数字 char-'0'就是其数字
* @param positive
* @param start
* @param str
* @return
*/
public int strToNum(boolean positive,int start,String str){
long result = 0;
while(start<str.length()&&str.charAt(start)>='0'&&str.charAt(start)<='9'){
result = result*10+(str.charAt(start)-'0');
if(positive){
if(result>Integer.MAX_VALUE){
return Integer.MAX_VALUE;
}
}else{
if(-resultreturn Integer.MIN_VALUE;
}
}
start++;
}
if(positive){
return (int)result;
}else{
return -(int)result;
}
} 实现strStr()
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
解决思路
设计两个指针，遍历haystack中所有和needle相同长度的字符串，进行比较
public int strStr(String haystack,String needle){
//异常处理:haystack的长度小于needle长度
if(haystack.length()return -1;
}
//判断needle是否为空
if(needle==null || needle.length()==0){
return 0;
}
//两个字符串长度相等的情况
if(needle.length() == haystack.length()){
//直接判断两个字符是否相等
if(haystack.equals(needle)){
return 0;
}else{
return -1;
}
}
//haystack长度大于needle的长度的时候
//得到两边的长度
int hLength = 0;
int nLength = needle.length();
String temp = "";
//遍历haystack，找出所有和needle长度相同的字符串，比较。若相同则返回hLength
while(hLength1){
temp = "";
for(int i=hLength;iif(temp.equals(needle)){
return hLength;
}
hLength++;
}
return -1;
} 数数并说
报数序列是指一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下：
- 1
- 11
- 21
- 1211
- 111221
解决思路
找到前一项中的连续相同的元素个数
public String countAndSay(int n){
/*
初步思路:计算其前一项，连续相同的元素个数，将得到的结果放在新的字符串中
*/
String result = "1";
if(n<=0){
return "";
}
//遍历n，先自减1
n = n-1;
while(n>0){
String cur = "";
for(int i=0;i//计数器，记录出现的次数
int cflag = 1;
while(i+11)){
cflag++;
i++;
}
cur += String.valueOf(cflag) + String.valueOf(result.charAt(i));
}
result = cur;
n--;
}
return result;
} 最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。
public String longestCommonPrefix(String[] strs){
//若字符串数组为空
if(strs==null || strs.length==0){
return "";
}
//若只有一个元素
if(strs.length==1){
return strs[0];
}
//两个以上元素
int pc = 0;
String result = "";
//找出字符串数组中最小的数组长度
int LowLength = strs[0].length();
for(int i=1;iif(LowLength>strs[i].length()){
LowLength = strs[i].length();
}
}
if(LowLength==0){
return "";
}
//若字符串数组中的字符串的第一个字符都相同，则将其加入结果字符串
while(pcfor (int i=0;i1;i++){
//得到元素
if(strs[i].charAt(pc) != strs[i+1].charAt(pc)){
return result;
}
}
result += strs[0].charAt(pc);
pc++;
}
return result;
}