算法 10 leetcode344. 反转字符串

目录

• 题目
• 代码
  • 我的代码
  • 2参考
  • 3参考
    • 1，双指针
    • 2，递归方式解决

题目

：链接

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 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"]

提示：
(1 <= s.length <= 105)
s[i] 都是 ASCII 码表中的可打印字符

代码

我的代码

简单，但是优化方法很多

class Solution {
    public void reverseString(char[] s) {
        int l=s.length;
        char m=s[s.length-1];
        if(l%2==0){                  ///////////////不用考虑！直接<l/2因为是小于号奇数可以取到偶数取不到
            for(int i=0;i<=(l-2)/2;i++){
                m=s[s.length-1-i];
                s[s.length-1-i]=s[i];
                s[i]=m;
            }
        }
        else{
            for(int i=0;i<=(l-1)/2;i++){
                m=s[s.length-1-i];
                s[s.length-1-i]=s[i];
                s[i]=m;
            }

        }
    }
}

2参考

对称交换即可

class Solution {
    public void reverseString(char[] s) {
        int length = s.length;
        char temp;
        for (int i = 0; i < length/2; i++) {
            temp = s[i];
            s[i] = s[length-1-i];
            s[length-1-i] = temp;
        }
    }
}

作者：桂继宏

3参考

1，双指针

使用两个指针，一个从第一个开始，一个从数组的最后一个开始，两两交换，可以看下视频演示

两个数字交换的时候，最常见的就是使用一个临时变量temp，除了这种以外还有其他实现方式，具体可以看下《交换两个数字的值》，下面的4种交换两个数字的实现方式都是可以的

public void reverseString(char[] s) {
        int length = s.length;
        //两个指针一个从第1个，一个从最后一个开始，
        //两两交换
        int left = 0;
        int right = length - 1;
        while (left < right) {
            swap(s, left++, right--);
        }
    }

    private void swap(char[] array, int i, int j) {
        //第1种交换方式
        char temp = array[i];
        array[i] = array[j];
        array[j] = temp;

        //第2种交换方式
//        array[i] = (char) (array[i] + array[j]);
//        array[j] = (char) (array[i] - array[j]);
//        array[i] = (char) (array[i] - array[j]);

        //第3种交换方式
//        array[i] = (char) (array[i] - array[j]);
//        array[j] = (char) (array[i] + array[j]);
//        array[i] = (char) (array[j] - array[i]);

        //第4种交换方式
//        array[i] ^= array[j];
//        array[j] ^= array[i];
//        array[i] ^= array[j];
    }

来看一下运行结果

2，递归方式解决

上面的代码，我们还可以把它改为递归方式实现

 public void reverseString(char[] s) {
        if (s == null || s.length == 0)
            return;
        reverseStringHelper(s, 0, s.length - 1);
    }

    public void reverseStringHelper(char[] s, int left, int right) {
        if (left >= right)
            return;
        swap(s, left, right);
        reverseStringHelper(s, ++left, --right);
    }

    private void swap(char[] array, int i, int j) {
        char temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

我们还可以换种写法，先递归在交换

public void reverseString(char[] s) {
        if (s == null || s.length == 0)
            return;
        reverseStringHelper(s, 0, s.length - 1);
    }

    public void reverseStringHelper(char[] s, int left, int right) {
        if (left >= right)
            return;
        //注意，这里的顺序调换了
        reverseStringHelper(s, left + 1, right - 1);
        swap(s, left, right);
    }

    private void swap(char[] array, int i, int j) {
        char temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

作者：数据结构和算法