剑指offer--面试题4：替换空格--Java实现

题目描述：
请实现一个函数，把字符串中的每个空格替换成”%20”。例如输入“We are happy”，输出“We%20are%20happy”。

解题思路：
在Java中有函数replace可以完成这个功能，我们先看一下源码中是怎么样实现的。

/**
     * Returns a string resulting from replacing all occurrences of
     * {@code oldChar} in this string with {@code newChar}.
     * <p>
     * If the character {@code oldChar} does not occur in the
     * character sequence represented by this {@code String} object,
     * then a reference to this {@code String} object is returned.
     * Otherwise, a {@code String} object is returned that
     * represents a character sequence identical to the character sequence
     * represented by this {@code String} object, except that every
     * occurrence of {@code oldChar} is replaced by an occurrence
     * of {@code newChar}.
     * <p>
     * Examples:
     * <blockquote><pre>
     * "mesquite in your cellar".replace('e', 'o')
     *         returns "mosquito in your collar"
     * "the war of baronets".replace('r', 'y')
     *         returns "the way of bayonets"
     * "sparring with a purple porpoise".replace('p', 't')
     *         returns "starring with a turtle tortoise"
     * "JonL".replace('q', 'x') returns "JonL" (no change)
     * </pre></blockquote>
     *
     * @param   oldChar   the old character.
     * @param   newChar   the new character.
     * @return  a string derived from this string by replacing every
     *          occurrence of {@code oldChar} with {@code newChar}.
     */
    public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value; /* avoid getfield opcode */

            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }
            if (i < len) {
                char buf[] = new char[len];
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                return new String(buf, true);
            }
        }
        return this;
    }

从jdk实现的源码中可以看到最后两个return语句，如果被替换的字符出现在了源字符串中，返回一个new String()，如果没有出现，则是返回了源字符串本身。

如果要求在源字符串上操作，前提是要求空间足够，可以采用这种思路：
1.暴力解法 从前向后遍历，每遇到空格，将后续的所有字符都向后移动，这样，对于前面有多个空格的字符，要移动多次，时间复杂度达到平方级别
2.首先找出空格的数量，然后就可以计算出后续的字符最终将移动到哪个位置，从后向前遍历移动。
这里只实现后者：

public class ReplcaceSapce {

    public static void replace(char[] str, int allLength){

        if(str == null && allLength <= 0){
            return;
        }

        //str中有效字符的个数，要减去最后一个'\0'
        System.out.println(str.length);
        int originalLength = 0;
        int i = 0;
        int blankCount = 0;
        while(str[i] != '\0'){
            originalLength++; 
            if(str[i] == ' '){
                blankCount++;
            }
            i++;
        }

        System.out.println("originalLength = " + originalLength);
        System.out.println("blankCount = " + blankCount);


        //从后往前复制
        int desLength = originalLength + blankCount * 2;
        if(desLength > allLength){
            return;
        }
        int indexOfOriginal = originalLength;
        int indexOfDes = desLength;

        while(indexOfOriginal >= 0 && indexOfDes > indexOfOriginal){
            if(str[indexOfOriginal] == ' '){
                str[indexOfDes--] = '0';
                str[indexOfDes--] = '2';
                str[indexOfDes--] = '%';
            }
            else{
                str[indexOfDes--] = str[indexOfOriginal];
            }
            indexOfOriginal--;
        }


    }

    public static void main(String[] args) {
        char[] string = new char[1024];
        //System.out.println("length = " + string);
        String s = "We are happy";
        for(int i = 0; i < s.length(); i ++){
            string[i] = s.charAt(i);

        }
        string[s.length()] = '\0';

        replace(string, 1024);
        for(int i = 0 ; i < 1024; i++){
            System.out.print(string[i]);
        }


    }

}