全排列

给定一个没有重复数字的序列，返回其所有可能的全排列。

回溯法

回溯法：一种通过探索所有可能的候选解来找出所有的解的算法。如果候选解被确认不是一个解（或者至少不是最后一个解），回溯算法会通过在上一步进行一些变化抛弃该解，即回溯并且再次尝试。递归函数分为两个情况：

如果 $\textit{first}==n$ ，说明我们已经填完了 $n$ 个位置（注意下标从 0 开始），找到了一个可行的解，我们将 $\textit{output}$ 放入答案数组中，递归结束。

如果 $\textit{first}<n$ ，我们要考虑这第 $\textit{first}$ 个位置我们要填哪个数。根据题目要求我们肯定不能填已经填过的数，因此很容易想到的一个处理手段是我们定义一个标记数组 $\textit{vis}[]$ 来标记已经填过的数，那么在填第 $\textit{first}$ 个数的时候我们遍历题目给定的 nn 个数，如果这个数没有被标记过，我们就尝试填入，并将其标记，继续尝试填下一个位置，即调用函数 $backtrack(first + 1, output)$ 。回溯的时候要撤销这一个位置填的数以及标记，并继续尝试其他没被标记过的数。

我们可以将题目给定的 n 个数的数组 $\textit{nums}$ 划分成左右两个部分，左边的表示已经填过的数，右边表示待填的数，我们在回溯的时候只要动态维护这个数组即可。

具体来说，假设我们已经填到第 $\textit{first}$ 个位置，那么 $\textit{nums}$ 数组中 $[0,\textit{first}-1]$ 是已填过的数的集合， $[\textit{first},n-1]$ 是待填的数的集合。我们肯定是尝试用 $[\textit{first},n-1]$ 里的数去填第 $\textit{first}$ 个数，假设待填的数的下标为 $i$ ，那么填完以后我们将第 $i$ 个数和第 $\textit{first}$ 个数交换，即能使得在填第 $\textit{first}+1$ 个数的时候 $\textit{nums}$ 数组的 $[0,first]$ 部分为已填过的数， $[\textit{first}+1,n-1]$ 为待填的数，回溯的时候交换回来即能完成撤销操作。

class Solution{
	public List<List<Integer>> permute(int[] nums){
		List<List<Integer>> res = new ArrayList<List<Integer>>();

		List<Integer> output = new ArrayList<Integer>():
		for(int num : nums){
			output.add(num);
		}

		int n = nums.length;
		backtrack(n,output,res,0);
		return res;
	}
	public void backtrack(int n, List<Integer> output,List<List<Integer>> res,int first){
		if(first == n){
			res.add(new ArrayList<Integer>(output));
		}
		for(int i = first; i<n;i++){
			Collection.swap(output,first,i);
			backtrack(n,output,res,first+1);
			Collection.swap(output,first,i);
		}
	}
}

时间复杂度： $O(n \times n!)$ ，其中 n 为序列的长度。算法的复杂度首先受 backtrack 的调用次数制约，backtrack 的调用次数为 $\sum_{k = 1}^{n}{P(n, k)}$ 次，其中 $P(n, k) = \frac{n!}{(n - k)!} = n (n - 1) ... (n - k + 1)$ ，该式被称作 n 的 k - 排列，或者部分排列。

而 $\sum_{k = 1}^{n}{P(n, k)} = n! + \frac{n!}{1!} + \frac{n!}{2!} + \frac{n!}{3!} + ... + \frac{n!}{(n-1)!} < 2n! + \frac{n!}{2} + \frac{n!}{2^2} + \frac{n!}{2^{n-2}} < 3n!$ 这说明 backtrack 的调用次数是 O(n!) 的。

而对于 backtrack 调用的每个叶结点（共 n! 个），我们需要将当前答案使用 O(n) 的时间复制到答案数组中，相乘得时间复杂度为 $O(n \times n!)$ 。

因此时间复杂度为 $O(n \times n!)$ 。

空间复杂度：O(n)，其中 n 为序列的长度。除答案数组以外，递归函数在递归过程中需要为每一层递归函数分配栈空间，所以这里需要额外的空间且该空间取决于递归的深度，这里可知递归调用深度为 O(n)。

二叉树的中序遍历

给定一个二叉树的根节点 root ，返回它的中序遍历。

方法一：递归

定义 $inorder(root)$ 表示当前遍历到 $\textit{root}$ 节点的答案，那么按照定义，我们只要递归调用 $inorder(root.left)$ 来遍历 $\textit{root}$ 节点的左子树，然后将 $\textit{root}$ 节点的值加入答案，再递归调用 $inorder(root.right)$ 来遍历 $\textit{root}$ 节点的右子树即可，递归终止的条件为碰到空节点。

var inorderTraversal = function(root){
	const res = [];
	const inorder = (root) =>{
		if(!root){
			return;
		}
		inorder(root.left);
		res.push(root.val);
		inorder(root.right);
	}
	inorder(root);
	return res;
};

时间复杂度：O(n)，其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。

空间复杂度：O(n)。空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n) 的级别。

方法二：迭代

方法一的递归函数我们也可以用迭代的方式实现，两种方式是等价的，区别在于递归的时候隐式地维护了一个栈，而我们在迭代的时候需要显式地将这个栈模拟出来，其他都相同，具体实现可以看下面的代码。

var inorderTraversal = function(root) {
    const res = [];
    const stk = [];
    while (root || stk.length) {
        while (root) {
            stk.push(root);
            root = root.left;
        }
        root = stk.pop();
        res.push(root.val);
        root = root.right;
    }
    return res;
};

时间复杂度：O(n)，其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。

空间复杂度：O(n)。空间复杂度取决于栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n) 的级别。

方法三：Morris 中序遍历

Morris 遍历算法是另一种遍历二叉树的方法，它能将非递归的中序遍历空间复杂度降为 O(1)。

Morris 遍历算法整体步骤如下（假设当前遍历到的节点为 x）：

1.如果 x 无左孩子，先将 x 的值加入答案数组，再访问 x 的右孩子，即 $x = x.\textit{right}$ 。

2.如果 x 有左孩子，则找到 x 左子树上最右的节点（即左子树中序遍历的最后一个节点，x 在中序遍历中的前驱节点），我们记为 $\textit{predecessor}$ 。根据 $\textit{predecessor}$ 的右孩子是否为空，进行如下操作。

3.如果 $\textit{predecessor}$ 的右孩子为空，则将其右孩子指向 x，然后访问 x 的左孩子，即 $x = x.\textit{left}$ 。

4.如果 $\textit{predecessor}$ 的右孩子不为空，则此时其右孩子指向 x，说明我们已经遍历完 x 的左子树，我们将 $\textit{predecessor}$ 的右孩子置空，将 x 的值加入答案数组，然后访问 x 的右孩子，即 $x = x.\textit{right}$ 。

重复上述操作，直至访问完整棵树。

其实整个过程我们就多做一步：假设当前遍历到的节点为 x，将 x 的左子树中最右边的节点的右孩子指向 x，这样在左子树遍历完成后我们通过这个指向走回了 x，且能通过这个指向知晓我们已经遍历完成了左子树，而不用再通过栈来维护，省去了栈的空间复杂度。

var inorderTraversal = function(root) {
    const res = [];
    let predecessor = null;

    while (root) {
        if (root.left) {
            // predecessor 节点就是当前 root 节点向左走一步，然后一直向右走至无法走为止
            predecessor = root.left;
            while (predecessor.right && predecessor.right !== root) {
                predecessor = predecessor.right;
            }

            // 让 predecessor 的右指针指向 root，继续遍历左子树
            if (!predecessor.right) {
                predecessor.right = root;
                root = root.left;
            }
            // 说明左子树已经访问完了，我们需要断开链接
            else {
                res.push(root.val);
                predecessor.right = null;
                root = root.right;
            }
        }
        // 如果没有左孩子，则直接访问右孩子
        else {
            res.push(root.val);
            root = root.right;
        }
    }

    return res;
};

时间复杂度：O(n)，其中 nn 为二叉搜索树的节点个数。Morris 遍历中每个节点会被访问两次，因此总时间复杂度为 O(2n)=O(n)。

空间复杂度：O(1)。

有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。

栈

我们遍历给定的字符串 s。当我们遇到一个左括号时，我们会期望在后续的遍历中，有一个相同类型的右括号将其闭合。由于后遇到的左括号要先闭合，因此我们可以将这个左括号放入栈顶。

当我们遇到一个右括号时，我们需要将一个相同类型的左括号闭合。此时，我们可以取出栈顶的左括号并判断它们是否是相同类型的括号。如果不是相同的类型，或者栈中并没有左括号，那么字符串 s 无效，返回 False。为了快速判断括号的类型，我们可以使用哈希表存储每一种括号。哈希表的键为右括号，值为相同类型的左括号。

在遍历结束后，如果栈中没有左括号，说明我们将字符串 s 中的所有左括号闭合，返回 True，否则返回 False。

注意到有效字符串的长度一定为偶数，因此如果字符串的长度为奇数，我们可以直接返回 False，省去后续的遍历判断过程。

var isValid = function(s) {
    const n = s.length;
    if (n % 2 === 1) {
        return false;
    }
    const pairs = new Map([
        [')', '('],
        [']', '['],
        ['}', '{']
    ]);
    const stk = [];
    s.split('').forEach(ch => {
        if (pairs.has(ch)) {
            if (!stk.length || stk[stk.length - 1] !== pairs.get(ch)) {
                return false;
            }
            stk.pop();
        } 
        else {
            stk.push(ch);
        }
    });
    return !stk.length;
};

时间复杂度：O(n)，其中 n 是字符串 s 的长度。

428.LeetCode

全排列

回溯法

二叉树的中序遍历

方法一：递归

方法二：迭代

方法三：Morris 中序遍历

有效的括号

栈