每日两题leetcode - 344.反转字符串 & 22.括号生成

题一. 反转字符串-344

1. 题目描述

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：

输入：[“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

示例 2：

输入：[“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2. 提交代码

/**
 * @param {character[]} s
 * @return {void} Do not return anything, modify s in-place instead.
 */
var reverseString = function(s) {
    //做题用时4min
    if(s.length < 2){
        return;
    }
    for(let i = 0; i < Math.floor(s.length/2); i++){
        let temp = s[i];
        s[i] = s[s.length-i-1];
        s[s.length-i-1] = temp;
    }

};

时间复杂度：O(n)，
空间复杂度：O(1)。

题二. 括号生成-22

1. 题目描述

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例 1：

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

示例 2：

输入：n = 1
输出：["()"]

提示：

1 <= n <= 8

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/generate-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2. 提交代码

思路：
使用回溯，在生成括号组的过程中一边生成一边判断，这样可以提高时间效率并能保证生成的是有效括号组；
判断是不是合法括号组的依据是“当前括号组里左括号个数一定是大于等于右括号个数的”，在代码里体现为“当前剩余的/待使用的左括号个数一定是小于右括号个数的”。

/**
 * @param {number} n
 * @return {string[]}
 */
var generateParenthesis = function(n) {
    const res = [];
    let str = "";
    generateParenthesisCore(n, n, str, res);
    return res;
};
//回溯，参数1：当前可使用左括号个数、参数2：当前可使用右括号个数
function generateParenthesisCore(left, right, path, res){
    if(left === 0 && right === 0){
        res.push(path);
        return;
    }
    //放入左括号
    if(left > 0){
        path += "(";
        generateParenthesisCore(left-1, right, path, res);
        path = path.substring(0, path.length-1); //当前位置也可以放右括号，所以释放对当前位置的占用
    }
    //剩余右括号大于剩余的左括号，所以放置右括号
    if(right > left){
        path += ")";
        generateParenthesisCore(left, right-1, path, res);
    }
}

• 时间复杂度：
  ，在回溯过程中，每个答案需要 O(n)的时间复制到答案数组中。
• 空间复杂度：O(n)，除了答案数组之外，我们所需要的空间取决于递归栈的深度，每一层递归函数需要 O(1)的空间，最多递归 2n层，因此空间复杂度为 O(n)。