剑指 Offer 05. 替换空格

剑指 Offer 05. 替换空格

函数搞定

用String的replaceAll函数

class Solution {
    public String replaceSpace(String s) {
        return s.replaceAll(" ", "%20");
    }
}

基于字符串加法的解

粗暴的解法

• 直接初始化一个空的目标串res,遍历源串每个元素s
• 若s不为空格直接复制,$res+=s$
• 否则,$res+="\%20"$

// 粗暴的解法,直接初始化一个空的目标串,遍历源串每个元素,
// 不为空格直接复制,为空格则加上"%20".
// 但是这么做一个很大的问题在于Java中字符串的加法a += b;
// 会新建一个字符串c,c = a + b.然后把c赋值给a.这样原本a指向的字符串
// 不会被释放,造成空间浪费.
class Solution {
    public String replaceSpace(String s) {
        if(s == null)
            return "";
        String res = "";
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == ' ')
                res += "%20";
            else
                res += s.charAt(i);
        }
        return res;
    }

算法复杂度

• 时间复杂度：$O(n)$，遍历一遍字符串
• 空间复杂度：$O(n)$，目标串的大小不会超过$3n$

实际上，这样效率是比较慢的。Java的字符串加法机制导致的。Java的字符串是不可修改的。因此做加法的本质不是在对象上进行加减，而是建立一个新的字符串，存储字符串加法的结果，再复制给该对象。例如a += b;会新建一个字符串c,c = a + b.然后把c赋值给a.这样原本a指向的字符串,不会被释放,造成空间浪费.
这里有个小实验

public class HelloWorld {
    public static void main(String []args) {
    	String s1 = "hello world";
		String s2 = s1;
		System.out.println("s1 = " + s1);
		System.out.println("s2 = " + s2);
		s1 += " stupid";
		System.out.println("s1 = " + s1);
		System.out.println("s2 = " + s2);
		return 0;
    }
}

输出结果

s1 = hello world
s2 = hello world
s1 = hello world stupid
s2 = hello world

我们可以看到s1和s2指向的是同一个字符串，然而在s2做加法的后，s1所指向的对象却没有改变。证明s2是指向了一个新建的字符串。

静态分配的方法

相比于上一种基于字符串加法，动态地确认目标串的大小，先遍历一遍源串，根据空格个数确认静态分配空间，用一个字符数组临时存储结果，最后转化为字符串返回。

// 这种解法先遍历字符串一遍，根据字符串的大小，静态分配一个字符数组
// 用于记录转化结果，最后再将其转换为字符串返回
class Solution {
    public String replaceSpace(String s) {
        if(s == null)
            return "";
        
        int numOfSpace = 0;
        // 记录空格数目
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == ' ')
                numOfSpace++;
        }

        char[] charArray = new char[s.length() + 2 * numOfSpace];
        // 用于存储返回的字符串

        for(int i = 0, j = 0; i < s.length(); i++){
            if(s.charAt(i) == ' '){
                charArray[j++] = '%';
                charArray[j++] = '2';
                charArray[j++] = '0';
            }else
                charArray[j++] = s.charAt(i);
        }
        String newStr = new String(charArray, 0, charArray.length);
        // 将字符数组转化为字符串,这种构造函数构造的方法真没有见过
        return newStr;
    }
}

算法复杂度

• 时间复杂度：$O(n)$，遍历两遍字符串
• 空间复杂度：$O(n)$，目标串的大小不会超过$3n$

基于StringBuffer的解

静态的数组分配虽然可以修改字符达到修改字符串的目的，但是需要遍历两边源串，比较麻烦。而String虽然能够动态调整大小却不能直接修改字符串。用StringBuffer可以解决这个问题，StringBuffer可以直接在源对象上面进行修改。

//用StringBuffer建立目标串，动态地在目标串的对象上进行修改
class Solution {
    public String replaceSpace(String s) {
        if(s == null)
            return "";
        StringBuffer res = new StringBuffer("");
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == ' ')
                res.append("%20");
            else
                res.append(s.charAt(i));
        }
        return res.toString();
        
    }
}

• 时间复杂度：$O(n)$，遍历一遍字符串
• 空间复杂度：$O(n)$，目标串的大小不会超过$3n$