对于两棵彼此独立的二叉树A和B，请编写一个高效算法，检查A中是否存在一棵子树与B树的拓扑结构完全相同。
给定两棵二叉树的头结点A和B，请返回一个bool值，代表A中是否存在一棵同构于B的子树。
核心代码：
class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
public class TreeSearch {
public void Search(TreeNode cur,StringBuffer s){
if(cur!=null){
s.append(cur.val+"");
Search(cur.left,s);
Search(cur.right,s);
}else
s.append(" ");
}
public boolean chkIdentical(TreeNode A, TreeNode B) {
// write code heref
StringBuffer sb = new StringBuffer();
Search(A,sb);
StringBuffer sb2 = new StringBuffer();
Search(B,sb2);
if(sb.toString().contains(sb2.toString()))
return true;
else
return false;
}
}
对于两个字符串A和B，如果A和B中出现的字符种类相同且每种字符出现的次数相同，则A和B互为变形词，请设计一个高效算法，检查两给定串是否互为变形词。
给定两个字符串A和B及他们的长度，请返回一个bool值，代表他们是否互为变形词。
测试样例：
"abc",3,"bca",3
返回：true
public boolean chkTransform(String A, int lena, String B, int lenb) {
Map<Character,Integer> map = new HashMap<Character,Integer>();
Map<Character,Integer> map2 = new HashMap<Character,Integer>();
for(int i = 0;i < lena; i++)
if(map.containsKey(A.charAt(i))){
map.put(A.charAt(i), map.get(A.charAt(i))+1);
}else
map.put(A.charAt(i),1);
for(int i = 0;i < lenb; i++)
if(map2.containsKey(B.charAt(i))){
map2.put(B.charAt(i), map2.get(B.charAt(i))+1);
}else
map2.put(B.charAt(i),1);
for(Map.Entry<Character, Integer> entry:map.entrySet()){
int value = entry.getValue();
char key = entry.getKey();
if(map2.keySet().contains(key)&&map2.get(key)!=value)
return false;
}
for(Map.Entry<Character, Integer> entry:map2.entrySet()){
int value = entry.getValue();
char key = entry.getKey();
if(map.keySet().contains(key)&&map.get(key)!=value)
return false;
}
return true;
}
对于一个字符串，请设计一个算法，只在字符串的单词间做逆序调整，也就是说，字符串由一些由空格分隔的部分组成，你需要将这些部分逆序。
给定一个原字符串A和他的长度，请返回逆序后的字符串。
测试样例：
"dog loves pig",13
返回："pig loves dog"
核心代码：
char[] str = A.toCharArray();
for(int i = 0;i <n/2; i++){
char temp = str[i];
str[i] = str[n-1-i];
str[n-1-i] = temp;
}
for(int i = 0;i < n; i++){
if(i==0||str[i-1]==' '){
for(int j = i;j<=n;j++)
if(j==n||str[j]==' '){
for(int k = i;k < j;k++)
System.out.print(str[k]);
System.out.println();
for(int k = i;k<=(i+j-1)/2;k++){
char temp = str[k];
str[k] = str[j-k+i-1];
str[j-k+i-1] = temp;
}
for(int k = i;k < j;k++)
System.out.print(str[k]);
System.out.println(" ******"+i+" "+j);
break;
}
}
}
StringBuffer sb = new StringBuffer();
for(int i = 0;i < n; i++)
sb.append(str[i]);
return sb.toString();
对于一个字符串，请设计一个算法，判断其是否为一个合法的括号串。
给定一个字符串A和它的长度n，请返回一个bool值代表它是否为一个合法的括号串。
测试样例：
"(()())",6
返回：true
测试样例：
"()a()()",7
返回：false
测试样例：
"()(()()",7
返回：false
核心代码：
public boolean chkParenthesis(String A, int n) {
// write code here
int num = 0;
for(int i = 0;i < A.length(); i++){
if(A.charAt(i)=='(')
num++;
else if(A.charAt(i)==')')
num--;
if(num<0)
return false;
}
if(num!=0)
return false;
return true;
}
对于一个字符串，请设计一个算法，将字符串的长度为len的前缀平移到字符串的最后。
给定一个字符串A和它的长度，同时给定len，请返回平移后的字符串。
测试样例：
"ABCDE",5,3
返回："DEABC"
public static String stringTranslation(String A, int n, int len) {
// write code here
char[] data = A.toCharArray();
for(int i = 0;i < len/2; i++){
char temp = data[i];
data[i] = data[len-1-i];
data[len-1-i] = temp;
}
// System.out.println(len/2);
// for(int i = 0;i < n; i++)
// System.out.print(data[i]);
// System.out.println();
for(int i = len;i < len+(n-len)/2; i++){
char temp = data[i];
data[i] = data[n-(i-len)-1];
data[n-(i-len)-1] = temp;
}
// System.out.println(len+" "+(n)/2);
// for(int i = 0;i < n; i++)
// System.out.print(data[i]);
// System.out.println();
for(int i = 0;i < n/2; i++){
char temp = data[i];
data[i] = data[n-1-i];
data[n-1-i] = temp;
}
// for(int i = 0;i < n; i++)
// System.out.print(data[i]);
// System.out.println();
StringBuffer sb = new StringBuffer();
for(int i = 0;i < n; i++)
sb.append(data[i]);
//System.out.println(sb.toString()+" "+n);
return sb.toString();
}
如果对于一个字符串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
public class Rotation {
public boolean chkRotation(String A,int lena,String B,int lenb){
if(lena!=lenb)
return false;
String temp = A+A;
if(temp.contains(B))
return true;
else
return false;
}
}
对于一个给定的字符串数组，请找到一种拼接顺序，使所有小字符串拼接成的大字符串是所有可能的拼接中字典序最小的。
给定一个字符串数组strs，同时给定它的大小，请返回拼接成的串。
测试样例：
["abc","de"],2
"abcde"
import java.util.*;
public class Prior {
public class MyComparator implements Comparator<String> {
@Override
public int compare(String a,String b){
return (a+b).compareTo(b+a);
}
}
public String findSmallest(String[] strs, int n) {
// write code here
if(strs==null || n==0){
return "";
}
Arrays.sort(strs,new MyComparator());
String res = "";
for(int i=0;i<n;i++)
res += strs[i];
return res;
}
}
对于一个字符串,请设计一个高效算法，找到字符串的最长无重复字符的子串长度。
给定一个字符串A及它的长度n，请返回它的最长无重复字符子串长度。保证A中字符全部为小写英文字符，且长度小于等于500。
测试样例：
"aabcb",5
返回：3
import java.util.*;
public class DistinctSubstring {
public static int longestSubstring(String A, int n) {
// write code here
Map<Character,Integer> posMap = new HashMap<Character,Integer>();
int[] strlen = new int[n];
int pre = 0;
strlen[0] = 1;
posMap.put(A.charAt(0), 0);
for(int i = 1;i < A.length(); i++){
int pos = posMap.get(A.charAt(i))==null?-1:(posMap.get(A.charAt(i))+1);
if(pos<pre)
strlen[i] = i-pre+1;
else
strlen[i] = i-pos+1;
//pre = strlen[i];
pre = i+1-strlen[i];
posMap.put(A.charAt(i), i);
}
int max = Integer.MIN_VALUE;
for(int i = 0;i < n; i++)
if(strlen[i]>max)
max = strlen[i];
return max;
}
}