Morris 中序遍历、递归 、迭代中序遍历代码

Morris 中序遍历

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

1. 如果 x 无左孩子，先将 x 的值加入答案数组，再访问 x 的右孩子，即x=x.right
2. 如果 x 有左孩子，则找到 x 左子树上最右的节点（即左子树中序遍历的最后一个节点，x 在中序遍历中的前驱节点），我们记为 predecessor。根据 predecessor
   的右孩子是否为空，进行如下操作。
   2.1 如果 predecessor 的右孩子为空，则将其右孩子指向 x，然后访问 x 的左孩子，即 x=x.left
   2.2 如果predecessor 的右孩子不为空，则此时其右孩子指向 x，说明我们已经遍历完 x 的左子树，我们将 predecessor 的右孩子置空，将 x 的值加入答案数组，然后访问 x 的右孩子，即 x=x.right
3. 重复上述操作，直至访问完整棵树

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

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

 
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        TreeNode *predecessor = nullptr;

        while (root != nullptr) {
            if (root->left != nullptr) {
                // predecessor 节点就是当前 root 节点向左走一步，然后一直向右走至无法走为止
                predecessor = root->left;
                while (predecessor->right != nullptr && predecessor->right != root) {
                    predecessor = predecessor->right;
                }
                
                // 让 predecessor 的右指针指向 root，继续遍历左子树
                if (predecessor->right == nullptr) {
                    predecessor->right = root;
                    root = root->left;
                }
                // 说明左子树已经访问完了，我们需要断开链接
                else {
                    res.push_back(root->val);
                    predecessor->right = nullptr;
                    root = root->right;
                }
            }
            // 如果没有左孩子，则直接访问右孩子
            else {
                res.push_back(root->val);
                root = root->right;
            }
        }
        return res;
    }
 

递归实现代码：

 //中序遍历 左根右
//方法1：递归
void  inOrder(TreeNode* root , vector<int>& nums)
{
	if (!root)
		return;
	inOrder(root->left, nums);
	nums.push_back(root->val);
	inOrder(root->right, nums);	
}
vector<int> inorderTraversal(TreeNode* root) {
	vector<int> nums;
	inOrder(root, nums);

借助栈实现递归 ，迭代实现

//方法二:迭代，借助栈实现递归 
vector<int> inorderTraversalWithStack(TreeNode* root) {
	 
	vector<int> nums;
	stack<TreeNode*>  stk;
	while (root|| !stk.empty())
		//stk存的是左子树  当前节点没有左子树会导致栈空
		//没有右叶子时 root = root->right; 会导致root为空
	{
		while (root)
		{
			stk.push(root);
			root = root->left;
		}
		root = stk.top();//最左节点
		stk.pop();//这个节点遍历过 出栈
		nums.push_back(root->val);
		root = root->right;
		
	}
	return nums;
}