LeetCodeday07

344.反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例 1：
输入：s = [“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]
示例 2：
输入：s = [“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

public class Leetcode344 {
    public static void main(String[] args) {
        char[] chars = "abcd".toCharArray();
        reverseString(chars);
        for (char aChar : chars) {
            System.out.print(aChar + " ");
        }

    }

    /**
     * 双指针
     *
     * @param s s
     */
    public static void reverseString(char[] s) {
        int left = 0;
        int right = s.length - 1;
        while (left < right) {
            char temp = s[left];
            s[left] = s[right];
            s[right] = temp;
            left++;
            right--;
        }
    }
}

541. 反转字符串II

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

示例 1：
输入：s = “abcdefg”, k = 2
输出：“bacdfeg”
示例 2：
输入：s = “abcd”, k = 2
输出：“bacd”

public class Leetcode541 {
    public static void main(String[] args) {
        String str = reverseStr("abcdav", 2);
        System.out.println(str);
    }

    public static String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        // 1. 每隔 2k 个字符的前 k 个字符进行反转
        for (int i = 0; i < ch.length; i += 2 * k) {
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= ch.length) {
                reverse(ch, i, i + k - 1);
                continue;
            }
            // 3. 剩余字符少于 k 个，则将剩余字符全部反转
            reverse(ch, i, ch.length - 1);
        }
        return new String(ch);
    }

    // 定义翻转函数
    public static void reverse(char[] ch, int i, int j) {
        for (; i < j; i++, j--) {
            char temp = ch[i];
            ch[i] = ch[j];
            ch[j] = temp;
        }

    }
}

剑指Offer 05.替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：
输入：s = “We are happy.”
输出：“We%20are%20happy.”

public class LeetCode05 {
    public static void main(String[] args) {
        String s = "We are happy.";
        System.out.println(replaceSpace(s));
    }
    public static String replaceSpace(String s) {
        char[] chars = s.toCharArray();
        StringBuilder s1 = new StringBuilder();
        for (char aChar : chars) {
            if(aChar==' '){
                s1.append("%20");
            }else {
                s1.append(aChar);
            }
        }
        return s1.toString();
    }
}

151.翻转字符串里的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：
输入：s = "the sky is blue"
输出："blue is sky the"
示例 2：

输入：s = "  hello world  "
输出："world hello"
解释：反转后的字符串中不能存在前导空格和尾随空格。
示例 3：

输入：s = "a good   example"
输出："example good a"
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。

public class Leetcode151 {
    public static void main(String[] args) {
        String s = "the sky is  blue  ";
        System.out.println(reverseWords(s));
    }

    public static String reverseWords(String s) {
        // 移除空格
        String str = removeSpace(s);
        // 反转所有字母
        String str1 = reverseAll(str);
        // 反转单词
        return reverseWord(str1);

    }

    public static String removeSpace(String s) {
        char[] chars = s.toCharArray();
        int slow = 0;
        // 快慢指针 移除空格
        for (int fast = 0; fast < chars.length; fast++) {
            // 扫到了一个单词
            if (chars[fast] != ' ') {
                // 每个单词后添加一个空格
                if (slow != 0) {
                    chars[slow++] = ' ';
                }
                // 复制元素
                while (fast < chars.length && chars[fast] != ' ') {
                    chars[slow] = chars[fast];
                    slow++;
                    fast++;
                }
            }
        }
        char[] ch = new char[slow];
        System.arraycopy(chars, 0, ch, 0, slow);
        return new String(ch);
    }

    public static String reverseAll(String s) {
        char[] chars = s.toCharArray();
        int left = 0;
        int right = s.length() - 1;
        while (left < right) {
            char temp = chars[left];
            chars[left] = chars[right];
            chars[right] = temp;
            left++;
            right--;
        }
        return new String(chars);
    }

    public static String reverseWord(String s) {
        char[] chars = s.toCharArray();
        // 遍历字符
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] != ' ') {
                // 记录单词开始位置
                int start = i;
                while (i < chars.length && chars[i] != ' ') {
                    i++;
                }
                // 退出while 循环时 i指向空格 所以结束边界要减一
                reverse(chars,start,i-1);
            }
        }
        return new String(chars);
    }

    public static void reverse(char[] ch, int start, int end) {
        while (start < end) {
            char temp = ch[start];
            ch[start] = ch[end];
            ch[end] = temp;
            start++;
            end--;
        }
    }
}

剑指Offer58-II.左旋转字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

示例 1：

输入: s = "abcdefg", k = 2
输出: "cdefgab"
示例 2：

输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"

public class Leetcode57 {
    public static void main(String[] args) {
        String str = "123456";
        System.out.println(reverseLeftWords(str, 2));
    }


    public static String reverseLeftWords(String s, int n) {
        char[] chars = s.toCharArray();
        reverse(chars, 0, n - 1);
        reverse(chars, n, chars.length - 1);
        reverse(chars,0, chars.length-1);
        return new String(chars);
    }

    public static void reverse(char[] ch, int start, int end) {
        while (start < end) {
            char temp = ch[start];
            ch[start] = ch[end];
            ch[end] = temp;
            start++;
            end--;
        }
    }

}