面试算法题 专题（一） —— 字符串

面试题 01.09. 字符串轮转

【题目描述】

面试题 01.09. 字符串轮转

解法一 模拟旋转

【思路】
指向s1的指针从前往后遍历逐一与s2的头一个字符比较 ，相等位置即为可能的旋转位置。旋转词极可能为： c[i + 1: n -1] + c[0：i]

class Solution {
    public boolean isFlipedString(String s1, String s2) {
        if( s1 == null || s2 == null) return false;
        if( s1.equals(s2) ) return true;
        char c [] = s1.toCharArray();
        char g [] = s2.toCharArray();
        int n = c.length, m = g.length;
        if( n != m ) return false;
        

        for(int i = 0, j = 0; i < n; i ++){
            if( c[i] == g[j]){
                String s = s1.substring(i) + s1.substring(0, i) ;
                if( s.equals(s2)) return true;
               
            }
        }
        return false;
       

    }
}

解法二 ： s1一定是 s2 + s2的子串

【思路】
如果s2是s1旋转得到的 那么s1一定是s的子串

class Solution {
    public boolean isFlipedString(String s1, String s2) {
        if( s1 == null || s2 == null) return false;
        if( s1.length() != s2.length() ) return false; 
        String s = s2 + s2; //如果s2是s1旋转得到的 那么s1一定是s的子串
        if( s.contains(s1)) return true;
        return false;

    }
}

572. 另一个树的子树

【题目描述】

572. 另一个树的子树

解法一 ： 递归判断

【思路】
层次遍历以s为根节点的树，也就是枚举出s的每一棵子树。判断以s为根的树与 以t为根的是否完全相同

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
        
        /**
            判断判断以root为根的树 和 以t为根的树是否相同
        */
	    public boolean sameTree(TreeNode root, TreeNode t ){
            
            //t和root 都为null 已经匹配到叶子结点了 说明被被完全匹配上
            if( t == null && root == null) return true;
            //root和t中有一棵没被遍完，另一棵树被遍历完了
            //或该两棵树对应节点值不相同。说明没匹配上
            if( root == null || t == null ) return false;
            if( root.val != t.val ) return false;
            return sameTree(root.left, t.left) && sameTree(root.right, t.right);

	        
	    }
	    public boolean isSubtree(TreeNode s, TreeNode t) {
            //t为null 则一定匹配
	        if( t == null ) return true;
            //s为null 则一定不匹配
            if( s == null ) return false;
            //判断以s为根的树与 以t为根的是否完全相同
            if(  sameTree(s, t) ) return true;
            return isSubtree(s.left, t) || isSubtree(s.right, t);
            
	        
	    }
}

解法二 ： 序列化二叉树

【思路】
使用后序遍历序列化二叉树。
空节点对应字符串： !#
非空节点对应对应字符串 ： 值!
这样才能保证序列化后的字符串唯一对应一棵二叉树。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSubtree(TreeNode s, TreeNode t) {
        if( s == null || t == null)  return false;

        return postSerialize(s).contains( postSerialize(t) );
    }
    
    public String postSerialize(TreeNode s){
        StringBuilder sb = new StringBuilder();
        post(s, sb);
        return sb.toString();
    }
    //后序遍历二叉树 
    public void post(TreeNode s, StringBuilder sb){
        //左孩子为空节点  
        if( s.left == null) sb.append("#!");
        else post(s.left, sb);
        
        //右孩子为空节点
        if( s.right == null) sb.append("#!");
        else post(s.right, sb);
        
        //添加根节点
        sb.append(s.val).append("!");
        
    }
}

二叉树序列化与反序列化

【题目描述】

ACWing 50. 序列化二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {

    // Encodes a tree to a single string.
    
    int u = 0;
    String serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        dfs_s(root, sb);
        return sb.toString();
    }
    /**
     * 前序遍历方式序列化二叉树 每个节点值以空格隔开
     * 根左右
    */
    void dfs_s(TreeNode root, StringBuilder res){
        if( root == null ){
            res.append("null").append(' ');
            return;
        }
        res.append(root.val).append(' ');
        dfs_s(root.left, res);
        dfs_s(root.right, res);
    }
    /**
     *反序列化 
     */
    // Decodes your encoded data to tree.
    TreeNode deserialize(String data) {
        
        char c[] = data.toCharArray();
        TreeNode root = dfs_d(c);
        return root;
    }
    
    TreeNode dfs_d(char c[]){
        //u 是全局变量 
        if( u == c.length ) return null;
        int k = u;
        //寻找节点（有值节点和空节点）
        while( c[k] != ' ') k ++;
        //空节点
        if(c[u] == 'n'){
            u = k + 1;  //指向下一个节点
            return null;
        }
        //有值节点值为c[u : k)
        int val = 0, sign = 1;
        if( u < k && c[u] == '-'){
            sign = -1;
            u ++; //跳过 符号位
        }
        for(int i = u; i < k ; i ++) 
            val = val * 10 + (c[i] - '0');
        val *= sign;
        u = k + 1;
        //构建二叉树
        TreeNode root =  new TreeNode(val);
        root.left = dfs_d(c);
        root.right = dfs_d  (c);
        return root;
    }
}

有效的字母异位词

【题目描述】

Leetcode 242. 有效的字母异位词

【思路】
互为异位词的单词，只有字母放置的位置不同，两个字符串中字母出现的次数及种类都是相同的。
题目中 说明了，单词全是小写字母，所以只需开个长度为26的数组，统计在s中出现字母的次数。然后再遍历t，t中出现的字符对应数组位置元素减1，如果最后数组不全为0说明不是异位词。

class Solution {
    public boolean isAnagram(String s, String t) {
        //注意题目说明只包含小写字母
        if( s == null && t == null ) return true;
        if( s == null || t == null ) return false;
        int  n = s.length(), m =  t.length();
        if( n != m ) return false;
        //异位词 即只有位置不同 字母出现的个数和出现的字母都相同
        int [] cnt = new int[26];
        for(int i = 0; i < n; i ++) {
            cnt[ s.charAt(i) - 'a'] ++;
            cnt[ t.charAt(i) - 'a'] --;
        }

        //判断是否有剩余
        for(int i = 0; i < 26; i ++)
            if( cnt[i] != 0) return false;
        return true;

    }
}

翻转字符串里的单词

解法一： 使用API

class Solution {
    //使用API方法
    public String reverseWords(String data) {
        //trim去除字符串首尾的空格
        String [] s = data.trim().split("\\s+");
        // \\s 是匹配多个空格
        int n = s.length;
        //然后从后往前逐一将字符串加入新的字符串中
        StringBuilder sb = new StringBuilder();
        for(int i = n -1; i > 0; i --)
            sb.append(s[i]).append(" ");
        sb.append(s[0]);
        return sb.toString();

    }
}

解法二 ：原地翻转

class Solution {
    
    /**
    翻转[l,r)区间的字符
    */
    public void reverse(char c[], int l, int r){
        //r--至右边第一个字符
        r --;
        while( l < r){
            char t = c[l];
            c[l] = c[r];
            c[r] = t;
            l ++;
            r --;
        }
        
    }
    public String reverseWords(String s) {
        
        if( s == null) return null;
        //s.trim去除首尾空格
        char c[] = s.trim().toCharArray();
        
        //消除多余空格
        boolean isSpace = true; //标记前一个字符是否为空格字符
        int cur = 0;
        for(int i = 0; i < c.length; i ++){
            if( c[i] != ' '){//非空格
                c[cur ++ ] = c[i];
                isSpace = false;
            }else if( !isSpace){//前一个字符非空格 且当前字符为空格字符
                c[cur ++] = ' ';
                isSpace = true;
            }
        }
        //字符串实际有效长度
        int len = cur;
        //翻转整个字符串
        reverse(c, 0, len);
        
        
        //翻转字符串的单词
        int preSpaceIdx = -1;
        for(int i = 0; i < len; i ++){
            if( c[i] != ' ') continue;
            //i为空格位置
            reverse(c, preSpaceIdx + 1, i);
            preSpaceIdx = i;
        }
        reverse( c, preSpaceIdx + 1, len);
        return new String(c, 0, len);

    }
}

总结

字符串类算法题，在测试时尽可能考虑空字符串和null的边界情况。