字符串

1对于两棵彼此独立的二叉树A和B，请编写一个高效算法，检查A中是否存在一棵子树与B树的拓扑结构完全相同。

给定两棵二叉树的头结点A和B，请返回一个bool值，代表A中是否存在一棵同构于B的子树。

 

import java.util.*;
 
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class IdenticalTree {
    public boolean chkIdentical(TreeNode t1, TreeNode t2){
        String t1Str = serialByPre(t1);
        String t2Str = serialByPre(t2);
        return getIndexOf(t1Str, t2Str) != -1;
    }
 
    //KMP
    private int getIndexOf(String s, String m) {
        if(s == null || m == null || m.length() < 1 ||s.length() < m.length()){
            return -1;
        }
        char[] ss = s.toCharArray();
        char[] ms = m.toCharArray();
         
        int[] nextArr = getNextArray(ms);
        int index = 0;
        int mi = 0;
        while(index < ss.length && mi < ms.length){
            if(ss[index] == ms[mi]){
                index++;
                mi++;
            }else if(nextArr[mi] == -1){
                index++;
            }else{
                mi = nextArr[mi];
            }
        }
        return mi == ms.length? index - mi: -1;
    }
 
    private static int[] getNextArray(char[] ms) {
        if(ms.length == 1){
            return new int[]{-1};
        }
        int[] nextArr = new int[ms.length];
        nextArr[0] = -1;
        nextArr[1] = 0;
        int pos = 2;
        int cn = 0;
        while(pos < nextArr.length){
            if(ms[pos - 1] == ms[cn]){
                nextArr[pos++] = ++cn;
            }else if(cn > 0){
                cn = nextArr[cn];
            }else{
                nextArr[pos++] = 0;
            }
        }
        return nextArr;
    }
 
    private String serialByPre(TreeNode head) {
        if(head == null){
            return "#!";
        }
         
        String res = head.val + "!";
        res += serialByPre(head.left);
        res += serialByPre(head.right);
        return res;
    }
}

2对于两个字符串A和B，如果A和B中出现的字符种类相同且每种字符出现的次数相同，则A和B互为变形词，请设计一个高效算法，检查两给定串是否互为变形词。

给定两个字符串A和B及他们的长度，请返回一个bool值，代表他们是否互为变形词。

测试样例：

"abc",3,"bca",3

返回：true

import java.util.*;
 
public class Transform {
    public boolean chkTransform(String A, int lena, String B, int lenb) {
        if(A == null || B == null || lena != lenb){
            return false;
        }
         
        char[] chas1 = A.toCharArray();
        char[] chas2 = B.toCharArray();
        int[] map = new int[256];
        for(int i = 0; i < chas1.length; i++){
            map[chas1[i]]++;
        }
        for(int i = 0; i < chas2.length; i++){
            if(map[chas2[i]]-- == 0){
                return false;
            }
        }
        return true;
    }
}

3如果对于一个字符串A，将A的前面任意一部分挪到后边去形成的字符串称为A的旋转词。比如A="12345",A的旋转词有"12345","23451","34512","45123"和"51234"。对于两个字符串A和B，请判断A和B是否互为旋转词。

给定两个字符串A和B及他们的长度lena，lenb，请返回一个bool值，代表他们是否互为旋转词。

测试样例：

"cdab",4,"abcd",4

返回：true

import java.util.*;
 
public class Rotation {
    public boolean chkRotation(String A, int lena, String B, int lenb) {
        // write code here
       if(lena!=lenb){
           return false;
       }
        String C = A+A;
        return C.contains(B);
    }
}

4对于一个字符串，请设计一个算法，只在字符串的单词间做逆序调整，也就是说，字符串由一些由空格分隔的部分组成，你需要将这些部分逆序。

给定一个原字符串A和他的长度，请返回逆序后的字符串。

测试样例：

"dog loves pig",13

返回："pig loves dog"

import java.util.*;

public class Reverse {
    public String reverseSentence(String A, int n) {
        // write code here
        String[] arr=A.split(" ");
        String B="";
        for(int i=0;i<arr.length/2;i++){
            String temp=arr[i];
            arr[i]=arr[arr.length-i-1];
            arr[arr.length-i-1]=temp;
        }
        for(int i=0;i<arr.length;i++){
            B+=arr[i]+" ";
        }
        return B.trim();
    }
}

牛客网上答案

import java.util.*;

public class Reverse {
    public String reverseSentence(String A, int n) {
        // write code here
       String B="";
        String[] arr=A.split(" ");
        for(int i=0;i<arr.length;i++){
            B+=reverse(arr[i])+" ";
        }
        return reverse(B.trim());
    }
    
    public String reverse(String A){
        char[] array=A.toCharArray();
        for(int i=0;i<array.length/2;i++){
            char temp=array[i];
            array[i]=array[array.length-i-1];
            array[array.length-i-1]=temp;
        }
        return String.valueOf(array);
    }
}

5

对于一个字符串，请设计一个算法，将字符串的长度为len的前缀平移到字符串的最后。

给定一个字符串A和它的长度，同时给定len，请返回平移后的字符串。

测试样例：

"ABCDE",5,3

返回："DEABC"

import java.util.*;

public class Translation {
    public String stringTranslation(String A, int n, int len) {
        // write code here
        return reverse(reverse(A.substring(0,len))+reverse(A.substring(len)));
    }
    
    public String reverse(String A){
        char[] array=A.toCharArray();
        for(int i=0;i<array.length/2;i++){
            char temp=array[i];
            array[i]=array[array.length-i-1];
            array[array.length-i-1]=temp;
        }
        return String.valueOf(array);
    }
}

牛客网上代码

import java.util.*;
 
public class Translation {
    public String stringTranslation(String A, int n, int len) {
        if(A == null || len == 0 || len == n){
            return A;
        }
        int index = len - 1;
        char[] arrC = A.toCharArray();
        reverseChars(arrC, 0, index);
        reverseChars(arrC, index+1, n-1);
        reverseChars(arrC, 0, n-1);
        return String.valueOf(arrC);
    }
     
    public void reverseChars(char[] arr, int start, int end){
        if(start == end){
            return;
        }
        int mid = (start + end)/2;
        for(int i = 0; start+i <= mid; i++){
            swap(arr, start + i, end - i);
        }
    }
     
    public void swap(char[] arr, int index1, int index2){
        char temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }
}

6对于一个给定的字符串数组，请找到一种拼接顺序，使所有小字符串拼接成的大字符串是所有可能的拼接中字典序最小的。

给定一个字符串数组strs，同时给定它的大小，请返回拼接成的串。

测试样例：

["abc","de"],2

"abcde"

利用排序实现

import java.util.*;

public class Prior {
    public String findSmallest(String[] strs,int n){
        for(int i=n-1;i>=0;i--){
            for(int j=0;j<i;j++){
                if(compare(strs[j],strs[j+1])>0){
                    swap(strs,j,j+1);
                }
            }
        }
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<n;i++){
            sb.append(strs[i]);
        }
        return sb.toString();
    }
    
    public void swap(String[] strs,int i,int j){
        String temp=strs[i];
        strs[i]=strs[j];
        strs[j]=temp;
    }
    
    public int compare(String a,String b){
        return (a+b).compareTo(b+a);
    }
}

7请编写一个方法，将字符串中的空格全部替换为“%20”。假定该字符串有足够的空间存放新增的字符，并且知道字符串的真实长度(小于等于1000)，同时保证字符串由大小写的英文字母组成。

给定一个string iniString 为原始的串，以及串的长度 int len, 返回替换后的string。

测试样例：

"Mr John Smith”,13

返回："Mr%20John%20Smith"

 

”Hello  World”,12

返回：”Hello%20%20World”

import java.util.*;

public class Replacement {
    public String replaceSpace(String iniString, int length) {
        // write code here
       char[] str=iniString.toCharArray();
        int count=0;
        for(int i=0;i<str.length;i++){
            if(str[i]==' '){
                count++;
            }
        }
        
        char[] str2=new char[str.length+count*2];
        int index=0;
        for(int i=0;i<length;i++){
            if(str[i]!=' '){
                str2[index]=str[i];
                index++;
            }else{
                str2[index]='%';
                str2[index+1]='2';
                str2[index+2]='0';
                index+=3;
            }
        }
        return String.valueOf(str2);
    }
}

8对于一个字符串，请设计一个算法，判断其是否为一个合法的括号串。

给定一个字符串A和它的长度n，请返回一个bool值代表它是否为一个合法的括号串。

测试样例：

"(()())",6

返回：true

测试样例：

"()a()()",7

返回：false

测试样例：

"()(()()",7

返回：false

import java.util.*;

public class Parenthesis {
    public boolean chkParenthesis(String A, int n) {
        // write code here
        char[] arr=A.toCharArray();
        int num=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]=='('){
                num++;
            }
            if(arr[i]==')'){
                num--;
            }
            if(num<0){
                return false;
            }
        }
        if(num==0){
            return true;
        }else{
            return false;
        }
    }
}

牛客网上代码

import java.util.*;
 
public class Parenthesis {
    public boolean chkParenthesis(String A, int n) {
        char[] arrC = A.toCharArray();
        int num = 0;
        int i = 0;
        while(i < arrC.length && num >= 0){
            if(arrC[i] == '('){
                num++;
            }else if(arrC[i] == ')'){
                num--;
            }
            i++;
        }
         
        if(i < arrC.length || num != 0){
            return false;
        }
        return true;
    }
}

9对于一个字符串,请设计一个高效算法，找到字符串的最长无重复字符的子串长度。

给定一个字符串A及它的长度n，请返回它的最长无重复字符子串长度。保证A中字符全部为小写英文字符，且长度小于等于500。

测试样例：

"aabcb",5

返回：3

import java.util.*;
 
public class DistinctSubstring {
    public int longestSubstring(String A, int n) {
        // write code here
        if(A==null || n==0){
            return 0;
        }
        char[] chas=A.toCharArray();
        int[] map=new int[256];//256个字符：记录每种字符之前出现的位置
        for(int i=0;i<256;i++){
            map[i]=-1;
        }
        int len=0;
        int pre=-1;
        int cur=0;//当前字符为止的最长无重复字符串的长度
        for(int i=0;i<n;i++){
            pre=Math.max(pre, map[chas[i]]);
            cur=i-pre;
            len=Math.max(len, cur);
            map[chas[i]]=i;
        }
        return len;
    }
}