字符串相关的处理

1. 判断某个字符串是否是回文Palindrome

思路：从字符串中轴位置左右判断字符是否相等（区分奇数和偶数字符串）

public class MaxStrPalindromeHandler {

    // 判断是否为回文
    public String judgeString(String str){
        int len = str.length();
        if(len<=1){
            return null;
        }
        int low =0;
        int high = 0;
        int mid = len%2; //取余
        int indexMid = len/2;
        if(mid==0){ // 偶数
            low = indexMid-1;
            high = indexMid;
            return  pubMethod(len,low,high,indexMid,str);
        }else { // 奇数 mid!=0
            low = indexMid-1;
            high = indexMid+1;
            return  pubMethod(len,low,high,indexMid,str);
        }
    }
    public String pubMethod(int len,int low,int high,int loopCount,String str){
        StringBuffer stringBuffer = new StringBuffer();
        String maxPStr = null;
        int loop = 0;
        while(low>=0 && high<=(len-1)){
            if(str.charAt(low)==str.charAt(high)){
                maxPStr = str.substring(low,high+1); //注意substring的stopIndex 要比实际下标+1
                loop++;
                low--;
                high++;
            }else {
                break;
            }
        }
        return maxPStr;
    }
    @Test
    public void mainTest(){
        String str = "cbbd";
        System.out.println(judgeString(str));
    }
}

2. 获取字符串数组里面相同的最大前缀(子串)

思路：获取数组第一个字符串，逐个字符与其他的字符串逐个字符比较。（注意结束条件，每个字符串长度不一致）

	public class MaxSubStringArrayTest {
    public String getSubStr(String[] strs){
        if(strs.length==0){
            return null;
        }
        StringBuffer stringBuffer = new StringBuffer();
        int i=0;
        String firstSubStr = strs[0];
        while(i<firstSubStr.length()){
            char ch = firstSubStr.charAt(i);
            for(int j=1;j<strs.length;j++){
                if((i+1)>strs[j].length()){ //循环的i值大于其他的字符长度 停止for循环
                    break;
                }
                String otherSubStr = strs[j];
                if(ch==otherSubStr.charAt(i)){
                    if(j==strs.length-1){
                        stringBuffer.append(ch);
                    }else {
                        continue;
                    }
                }
            }
            i++;
        }
        return stringBuffer.toString();

    }

    @Test
    public void test(){
        String[] strs = {"flower","flo","floght"};
        System.out.println(getSubStr(strs));
    }
}

3 获取回文的最大的子串

思路：（回文的子串必须在回文串中必须连续且满足aba或者acca格式）从字符串的第一个字符（每个字符的位置都有奇数和偶数可能，注意区分）开始读取，左边low与右边high比较字符值。

public class GetMaxSubPalindrome {

    /**
     * @desc 以某个元素为中心 向两边搜索对比 （区分偶数和奇数）
     * @param
     * @return
     */
    public static int maxSubLen=0;
    public static int index = 0;
    public String maxSubString(String ss){
        int len = ss.length();
        if(len<2){
            return ss;
        }
        for(int i=1;i<len;i++){
             //每个元素都有可能是偶数 或者奇数
            palindrome(ss,i-1,i,len);
            palindrome(ss,i-1,i+1,len);
        }
        System.out.println(index+" "+maxSubLen);
        return ss.substring(index,maxSubLen+index+1);
    }

    private void palindrome(String ss, int low, int high, int len) {
        while(low>=0 && high<=(len-1)){
            if(ss.charAt(low)==ss.charAt(high)){
                if((high-low)>maxSubLen){
                    maxSubLen = (high-low);
                    index = low;
                }
            }else {
                break;
            }
            low--;
            high++;

        }

    }

    @Test
    public void test(){
        String ss = "bcgcbcc";
        System.out.println(maxSubString(ss));
    }

}

4. 获取最大回文子序列的回文个数

思路：（回文子序列必须必须有序-按照字符串的顺序方向，可以不连续）

public class MaxPalindSeq {

    public int maxPalinSeqCount(String str,int start,int end){
        if(start==end){
            return 1;
        }
        if(start>end || str.length()==0){
            return 0;
        }
        if(str.charAt(start)==str.charAt(end)){
            return maxPalinSeqCount(str,start+1,end-1)+2;
        }else {
            return Math.max(maxPalinSeqCount(str,start+1,end),maxPalinSeqCount(str,start,end-1));
        }

    }
    
    @Test
    public void test(){
        String s = "bscdssbs";
        int start = 0;
        int end  = s.length()-1;
        int count  = maxPalinSeqCount(s,start,end);
        System.out.println("\n"+count);
    }
}

5 括号匹配深度（例如：()->深度1;()()->深度1;(())()->深度2;）

思路：注意代码中continue的使用（区分奇数和偶数字符串）

public class BracketsDeepMax {

    public int bracketsDeepHandler(String str){
        if(str==""){
            return 0;
        }
        int len = str.length();
        int nextNode = 0; // 下个节点（可跳跃）
        int finalDeep = 0;
        int count = 0;
        while(nextNode<len){
            if(str.charAt(nextNode)=='('){
                count++;
            }else if(str.charAt(nextNode)==')'){
                nextNode = nextNode+count;
                finalDeep = Math.max(finalDeep,count);
                count=0;
                continue;
            }else {
                return 0;
            }
            nextNode++;
        }
        return finalDeep;
    }

    @Test
    public void testDeep(){
        String ss = "((()))()()()";
        System.out.println(bracketsDeepHandler(ss));
    }
}

6 求字符串数组的连续公共子串（示例：{“aabc”,“ab”} 公共子串为"ab"）

public class PublicSubStr {
    public static void main(String[] args) {
        String[] strs = {"absaa","asa","sa"};
        String maxSubStr = strHandle(strs);
        System.out.println("maxSubStr: "+maxSubStr);
    }

    private static String strHandle(String[] strs) {
        String first = strs[0];
        int firstLen = strs[0].length();
        // 获取第一个字符串的所有子串（不重复）
        Set<String> set = new HashSet<>();
        int i=0;
        while(i<firstLen){
            for(int j=i;j<firstLen;j++){  // 循环初始j=i 即j得跟着i移动
                set.add(first.substring(i,j+1)); //取子串
            }
            i++;
        }
        int endFlag = 0;
        int maxLen = 0;
        String maxSubStr = null;
        for (String ss:set){
            System.out.println(ss);
            Pattern pattern  =Pattern.compile(ss);
            for(int s = 1;s<strs.length;s++){
                String other = strs[s];
                Matcher matcher  =pattern.matcher(other);
                if(matcher.find()){ //如果要查找次数 使用while,break组合
                    endFlag++;
                    continue;  //保证只匹配一次符合条件字符串
                }
            }
            if(endFlag==strs.length-1){
                //求最大的公共子串
                int subStrLen = ss.length();
                if(subStrLen>maxLen){
                    maxLen = subStrLen;
                    maxSubStr = ss;
                }
            }
            endFlag=0;  //复位
        }
        return maxSubStr;
    }
}

7 求数组的不重复的排列组合（示例：{1,2,3} 排列组合：123,132,231,213,321）参考链接

public class Permutations {

    public static Stack<Integer> stack = new Stack<Integer>();
    public static void main(String[] args) {
        int arr[] = {1,2,3,4};
        arrHandle(arr,0,4);
    }
    /**
     *
     * @param arr	待选择的数组
     * @param cur	当前选择的是第几次
     * @param targ	要选择多少个次
     */
    private static void arrHandle(int[] arr, int cur, int targ) {
        if(cur == targ) {
            System.out.println(stack);
            return;
        }

        for(int i=0;i<arr.length;i++) {
            if(!stack.contains(arr[i])) {
                stack.add(arr[i]);
                System.out.println("push: "+stack);
                arrHandle(arr, cur+1, targ);  //核心点 递归
                stack.pop(); //关键点
            }
        }
    }
}