剑指OFFER-正则表达式匹配(Java)

1. 字符串的排列

1.1 题目描述

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则按字典序打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

1.2 输入描述

输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。

1.3 示例1

输入

“ab”

返回值

[“ab”,“ba”]

1.4 核心代码实现

//回溯算法：从一条路往前走，能进则进，不能进则退回一步重走
import java.util.*;

public class Solution {
    TreeSet<String> paths = new TreeSet<>();//TreeSet本质：有序，无重复元素的集合
    StringBuilder path = new StringBuilder();//path存储所有排列组合结果，含重复
    boolean[] flag;    //flag标记某字符是否已排列组合
    
    public ArrayList<String> Permutation(String str){
        ArrayList<String> result = new ArrayList<>();    //储存排列组合结果
        if(str == null || str.equals("")) return result;
        char[] strs = str.toCharArray();    //将字符串的字符分离
        flag = new boolean[strs.length];    //flag标记每位字符是否已排列组合
        Combination(strs, 0);    //回溯法求得所有排列组合的结果
        result.addAll(paths);    //将非重复的排列组合结果添加到result
        return result;    //返回result
    }
    
    private void Combination(char[] strs, int len){
        if(len == strs.length){
            paths.add(path.toString());    //利用paths存储非重复的排列组合结果
            return;
        }
        for(int i = 0; i < strs.length; i++){
            if(!flag[i]){
                flag[i] = true;
                path.append(strs[i]);
                Combination(strs, len + 1);
                flag[i] = false;    //回溯，用完了得重置状态
                path.deleteCharAt(path.length() - 1);
            }
        }
    }
}

2. 第一个只出现一次的字符

2.1 题目描述

在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.（从0开始计数）

2.2 示例1

输入

“google”

返回值

4

2.3 核心代码实现

public class Solution {
    public int FirstNotRepeatingChar(String str) {
        int index = -1;
        if(str == null || str.length() == 0) return index;
        char[] strs = str.toCharArray();
        
        for(int i = 0; i < strs.length; i++){
            //indexof()返回某个指定的字符串值在字符串中首次出现的位置（从左向右）,
            //若匹配则返回-1，否则返回首次出现位置的字符串的下标值。
            //lastIndexOf()返回从右向左出现某个字符或字符串的首个字符索引值，
            //没有匹配的则返回-1（与indexOf相反）
            if(str.indexOf(strs[i]) == str.lastIndexOf(strs[i])){
                return i;
            }
        }
        return index;
        
    }
}

3. 把字符串转换成整数

3.1 题目描述

将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0

输入描述：

输入一个字符串,包括数字字母符号,可以为空

返回值描述：

如果是合法的数值表达则返回该数字，否则返回0

3.2 示例1

输入

“+2147483647”

返回值

2147483647

3.3 示例2

输入

“1a33”

返回值

0

3.4 核心代码实现

public class Solution {
    public int StrToInt(String str) {
        if(str == null || str.length() == 0) return 0;
        char[] strs = str.toCharArray();
        int result = 0;
        int flag = (strs[0] == '-') ? -1 : 1;    //flag标记正数还是负数
        int index = (strs[0] == '+' || strs[0] == '-') ? 1 : 0;
        for(int i = index; i < strs.length; i++){
            if(strs[i] < '0' || strs[i] > '9'){    //越界返回0
                return 0;
            }
            result = result * 10 + strs[i] - '0';
        }
        return result * flag;
    }
}

4. 翻转单词顺序列

4.1 题目描述

牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

4.2 示例1

输入

“nowcoder. a am I”

返回值

“I am a nowcoder.”

4.3 核心代码实现

public class Solution {
    public String ReverseSentence(String str) {
        if(str == null || str.length() == 0) return str;    //字符串为空
        String[] strs = str.split(" ");
        if(strs.length == 0) return str;    //字符串只有空格
        String result = "";
        
        for(int i = strs.length - 1; i >= 0; i--){
            result += strs[i] + " ";
        }
        return result.substring(0, result.length() - 1);
    }
}

5. 扑克牌顺子

5.1 题目描述

LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。

5.2 示例1

输入

[0,3,2,6,4]

返回值

true

5.3 核心代码实现

import java.util.Arrays;

public class Solution {
    public boolean isContinuous(int [] numbers) {
        if(numbers == null || numbers.length == 0) return false;
        Arrays.sort(numbers);
        int len = numbers.length;
        int count = 0;
        boolean flag = false;
        for(int i = 0; i < len; i++){
            if(numbers[i] == 0) count++;
        }
        
        if(numbers[len - 1] - (numbers[count] + len - 1 - count) <= count 
           && numbers[len - 1] >= (numbers[count] + len - 1 - count)) {
            flag = true;
        }
        return flag;

    }
}

6. 左旋转字符串

6.1 题目描述

汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

6.2 示例1

输入

“abcXYZdef”,3

返回值

“XYZdefabc”

6.3 核心代码实现

public class Solution {
    public String LeftRotateString(String str,int n) {
        if(str == null || str.length() == 0 
           || n >= str.length() || n == 0) return str;
        return str.substring(n) + str.substring(0, n);
    }
}

7. 正则表达式匹配

7.1 题目描述

请实现一个函数用来匹配包括’.‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"ab*a"均不匹配

7.2 示例1

输入

“aaa”,“a*a”

返回值

true

7.3 核心代码实现

public class Solution {
    public boolean match(char[] str, char[] pattern){
        if(str == null || pattern == null) return false;
        return matchStr(str, 0, pattern, 0);
    }
    
    private boolean matchStr(char[] str, int i, char[] pattern, int j){
        //递归结束条件
        if(i == str.length && j == pattern.length) return true;
        if(i < str.length && j == pattern.length) return false;
        //pattern中有*的情况，根据i与j指向是否相同进行不同的操作
        if(j + 1 < pattern.length && pattern[j + 1] == '*'){
            //i与j的指向相同时
            if((i < str.length && pattern[j] == str[i])
              || (i < str.length && pattern[j] == '.')){
                return matchStr(str, i, pattern, j + 2)
                    || matchStr(str, i + 1, pattern, j)
                    || matchStr(str, i + 1, pattern, j + 2);
            }else{
                //i与j的指向不同时
                return matchStr(str, i, pattern, j + 2);
            }
        }
        //pattern中有.的情况
        if(i < str.length && (pattern[j] == str[i] || pattern[j] == '.')){
            return matchStr(str, i + 1, pattern, j + 1);
        }
        //pattern中既没*也没.
        return false;
    }
}   

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param str string字符串 
     * @param pattern string字符串 
     * @return bool布尔型
     */
    public boolean match (String str, String pattern) {
        int ls = str.length();
        int lp = pattern.length();
        char[] strs = str.toCharArray();
        char[] pats = pattern.toCharArray();
        //新建res数组存放字符串的前i个元素是否和模式串的前j个元素匹配
        boolean[][] res = new boolean[ls + 1][lp + 1];
        res[0][0] = true;//初始化为true，表示两个串均为空时，匹配
        for(int i = 2; i <= lp; i++){
            if(pats[i - 1] == '*' && res[0][i - 2]) res[0][i] = true;
        }
        
        for(int i = 1; i <= ls; i++){
            for(int j = 1; j <= lp; j++){
                if(strs[i - 1] == pats[j - 1] || pats[j - 1] == '.'){//当第j个元素不是‘*’
                    res[i][j] = res[i - 1][j - 1];
                }else if(pats[j - 1] == '*'){    //当第j个元素为'*'，分两种情况讨论
                    if(res[i][j - 2] == true){
                        res[i][j] = res[i][j - 2];
                    }else if(strs[i - 1] == pats[j - 2] || pats[j - 2] == '.'){
                        res[i][j] = res[i - 1][j];
                    }
                }
            }
        }
        return res[ls][lp];
    }
}

8. 表示数值的字符串

8.1 题目描述

请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100",“5e2”,"-123",“3.1416"和”-1E-16"都表示数值。 但是"12e",“1a3.14”,“1.2.3”,"±5"和"12e+4.3"都不是。

8.2 示例1

输入

“123.45e+6”

返回值

true

8.3 核心代码实现

public class Solution {
    public boolean isNumeric(char[] str) {
        if(str == null || str.length == 0) return false;
        
        boolean hadDot = false;
        boolean hasExp = false;
        //逐个遍历字符串的字符，判断是否符合条件
        for(int i = 0; i < str.length; i++){
            if(str[i] == '+' || str[i] == '-'){
                //'+'与'-'只能出现在开头或'e'与'E'的后面
                if(i == 0) continue;
                if(!hasExp || str[i - 1] != 'e' && str[i - 1] != 'E'){
                    return false;
                }
            
            }else if(str[i] == '.'){
                //'.'不能出现在开头，且不能重复出现，不能出现在'e'与'E'之后
                if(i == 0 || hadDot || hasExp){
                    return false;
                }
                //'.'前面必须跟数字或'+'或'-'
                if(!isNum(str[i - 1]) && str[i - 1] != '+' && str[i - 1] != '-'){
                    return false;
                }
                hadDot = true;
                
            }else if(str[i] == 'e' || str[i] == 'E'){
                //'e'与'E'不能出现在开头和结尾
                if(i == 0 || i == str.length - 1) {
                    return false;
                }
                //'e'与'E'必须跟在数字后面
                if(!isNum(str[i - 1])){
                    return false;
                }
                hasExp = true;
                
            }else if(isNum(str[i])){
                continue;
            }else{
                return false;
            }
        }
        return true;
    }
    
    private boolean isNum(char ch){
        if(ch >= '0' && ch <= '9'){
            return true;
        }else{
            return false;
        }
    }
    
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param str string字符串 
     * @return bool布尔型
     */
    public boolean isNumeric (String str) {
        if(str == null) return false;
        char[] strs = str.toCharArray();
        int len = strs.length;
        int oddCount = 0;
        boolean hasA = false, hasE = false, hasPoint = false;
        for(int i = 0; i < len; i++){
            if(strs[i] == '+' || strs[i] == '-'){//加减号只能出现在开头或者指数后
                if(!hasA && i != 0 && strs[i - 1] != 'e' && strs[i - 1] != 'E'){
                    return false;
                }
                //加减号已经出现过一次，第二次出现在指数后
                if(hasA && strs[i - 1] != 'e' && strs[i - 1] != 'E'){
                    return false;
                }
                hasA = true;
            }else if(strs[i] == 'e' || strs[i] == 'E'){//e/E不能出现在末尾，且只能出现一次
                if(i == len - 1) return false;
                if(hasE) return false;
                hasE = true;
            }else if(strs[i] == '.'){//小数点不能出现在末尾，不能与指数共存，且只能出现一次，
                if(i == len - 1 || hasE || hasPoint) return false;
                hasPoint = true;
            }else if(strs[i] < '0' || strs[i] > '9'){
                return false;
            }
        }
        return true;
    }
}