二叉树的非递归遍历 （leetcode-重点掌握不使用栈的非递归）

已于 2022-05-03 08:29:00 修改
阅读量1.8k 收藏 5
点赞数
分类专栏： C C++ 数据结构 # 各种二叉树 Java 文章标签： 二叉树 递归 遍历
于 2015-09-03 20:37:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26437925/article/details/48197859
版权

文章目录

利用数据结构-栈，队列, 加上相应思路等完成。

2019-06-09 补充 二叉树 不使用栈 进行 先序/中序 非递归遍历（摘自leetcode上某个大神）视频讲解：https://www.youtube.com/watch?v=wGXB9OWhPTg，即Morris 遍历

leetcode题目地址

leetcode练习，隔段时间敲几次代码

144 . Binary Tree Preorder Traversal
https://leetcode.com/problems/binary-tree-preorder-traversal/

https://leetcode-cn.com/problems/binary-tree-preorder-traversal/

94 . Binary Tree Inorder Traversal
https://leetcode.com/problems/binary-tree-inorder-traversal/

https://leetcode-cn.com/problems/binary-tree-inorder-traversal/

145 . Binary Tree Postorder Traversal
https://leetcode.com/problems/binary-tree-postorder-traversal/

https://leetcode-cn.com/problems/binary-tree-postorder-traversal/

非递归先/前序(根-左-右)

非递归，使用栈

利用栈，根节点先pop, 然后先push right节点，再push left节点，pop则是先左再右

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        if(root == null){
            return ans;
        }
        Stack<TreeNode> sta = new Stack();
        sta.push(root);
        while(!sta.isEmpty()){
            TreeNode node = sta.pop();
            ans.add(node.val);
            if(node.right != null){
                sta.push(node.right);
            }
            if(node.left != null){
                sta.push(node.left);
            }
        }
        return ans;
    }
}

非递归，不使用栈

主要是链接前序节点到根，每个根访问两次：一次打印并建立链接，一次是取消链接转向右子树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> preOrderList = new ArrayList<>(512);
        TreeNode current = root;
        while(current != null) {
            // 左子树是null, 则 打印该节点，转向该节点的右子树
            if (current.left == null) {
                preOrderList.add(current.val);
                current = current.right; // 靠right 设置current
            }else {
                // find the predecessor（该节点的左子树 的 最右节点，不能等于该节点）
                TreeNode predecessor = current.left;
                while(predecessor.right != current && predecessor.right != null) {
                    predecessor = predecessor.right;
                }
                // 该节点第一次遍历 建立 predecessor.right = 自己
                if(predecessor.right == null) {
                    preOrderList.add(current.val);
                    predecessor.right = current;
                    current = current.left;
                }else { // 该节点第二次被访问到, predecessor.right不是null，是自己了，并消除这种link
                    predecessor.right = null;
                    current = current.right;
                }
            }
        }
        return preOrderList;
    }
}

非递归中序(左-根-右)

非递归，使用栈

每次取栈顶，而栈的顺序是 从根到最左，取出该节点打印并出栈
如果取出的节点没有右子树
则cur = cur->right;为null,下一次取出其父节点
如果右子树不为空
则 cur = cur->right;后下一次会往栈中添加右子树，但是根是在这之前入栈的

即操作确保了一定是 左 根 右 的顺序

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        if(root == null){
            return ans;
        }
        Stack<TreeNode> sta = new Stack<>();

        TreeNode cur = root;
        while(!sta.isEmpty() || cur != null){
            if(cur != null){ // 不断的左，直到左节点为空
                sta.push(cur);
                cur = cur.left;
            }else{
                TreeNode node = sta.pop();
                ans.add(node.val);
                
                if(node.right == null){
                    // do nothing; 即继续弹出栈中元素
                }else{
                    // 左子树为空，根打印了，那么转向右子树
                    cur = node.right;
                }
            }
        }
        return ans;
    }
}

非递归，不使用栈

主要是链接前序节点到根，每个根访问两次：第一次建立链接，另一次是取消链接 并打印，即后打印根，然后在转向右子树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList(16);
        if(root == null){
            return ans;
        }
        TreeNode cur = root;
        while(cur != null){
            if(cur.left == null){
                ans.add(cur.val);
                cur = cur.right; // 右子树建立遍历关联
            }else{
                // 不断的找到最右节点
                TreeNode pre = cur.left;
                while(pre.right != null && pre.right != cur){
                    pre = pre.right;
                }
                if(pre.right == null){ // 第一次访问
                    pre.right = cur;
                    cur = cur.left;
                }else{	// 第二次访问
                    ans.add(cur.val);
                    pre.right = null;
                    cur = cur.right;
                }
            }
        }
        return ans;
    }
}

非递归后序（左-右-根）

非递归，使用栈

需要记录是否右子树访问完成，然后再访问根(对比下中序非递归使用栈)

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        if(root == null){
            return ans;
        }
        TreeNode preVisit = null;
        TreeNode cur = root;
        Stack<TreeNode> sta = new Stack();
        while(!sta.isEmpty() || cur != null){
            if(cur != null){
                sta.push(cur);
                cur = cur.left;
            }else{
                TreeNode node = sta.peek();

                if(node.right == null || node.right == preVisit){
                    sta.pop();
                    ans.add(node.val);
                    preVisit = node;
                }else{
                    cur = node.right;
                }
            }
        }
        return ans;
    }
}

非递归，不使用栈

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {

     public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> preOrderList = new ArrayList<>(512);
        TreeNode current = root;
        while(current != null) {
            if (current.left == null) {
                current = current.right;
            }else {
                TreeNode predecessor = current.left;
                while(predecessor.right != current && predecessor.right != null) {
                    predecessor = predecessor.right;
                }
                if(predecessor.right == null) {
                    predecessor.right = current;
                    current = current.left;
                }else {
                    // 先消除链接
                    predecessor.right = null;
                    //  current.left 右子树靠right链接起来了，需要逆序全部访问到
                    addPath(preOrderList, current.left);
                    current = current.right;// 继续转向右子树，如果为空则退出
                }
            }
        }
        // 前面操作确保了，左子树先全部完成了，然后右子树的左子树也全部完成了，且右子树的右节点为null
        // 那么只需要再来一次逆序访问即可
        addPath(preOrderList, root);
        return preOrderList;
    }
    
    public void addPath(List<Integer> res, TreeNode node) {
        // 添加元素
        int count = 0;
        while (node != null) {
            ++count;
            res.add(node.val);
            node = node.right;
        }
        // 逆序
        int left = res.size() - count;
        int right = res.size() - 1;
        while (left < right) {
            int temp = res.get(left);
            res.set(left, res.get(right));
            res.set(right, temp);
            left++;
            right--;
        }
    }

}

使用二叉树非递归遍历的一些题目

230. Kth Smallest Element in a BST

题目地址
https://leetcode.com/problems/kth-smallest-element-in-a-bst/

ac代码如下;

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
	int kthSmallest(TreeNode* root, int k) {
		
		if (root == NULL)
			return 0;

		stack<TreeNode*> sta;
		sta.push(root);
		TreeNode* pLeft = root->left;

		int outTh = 1;

		while (!sta.empty() || pLeft != NULL)
		{
			while (pLeft != NULL)
			{
				sta.push(pLeft);
				pLeft = pLeft->left;
			}

			TreeNode* top = sta.top();
			sta.pop();

			if (outTh == k)
			{
				return top->val;
			}
			outTh++;
			//cout << top->val;

			if (top->right != NULL) 
				pLeft = top->right;
		}

		return 0;
	}
};

114. Flatten Binary Tree to Linked List

题目地址
https://leetcode.com/problems/flatten-binary-tree-to-linked-list/
题目描述
Given a binary tree, flatten it to a linked list in-place.

For example,
Given

     1
    / \
   2   5
  / \   \
 3   4   6

The flattened tree should look like:

  1
    \
     2
      \
       3
        \
         4
          \
           5
            \
             6

采用非递归，使用堆栈的先序遍历

ac代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
	
	void flatten(TreeNode* root) {
		if (root == NULL)
			return;

		stack<TreeNode*> sta;
		sta.push(root);

		TreeNode* lastNode = NULL;
		while (!sta.empty())
		{
			TreeNode* top = sta.top();
			sta.pop();
			
			if (top->right != NULL)
				sta.push(top->right);

			if (top->left != NULL)
				sta.push(top->left);

			if (lastNode != NULL){
				lastNode->left = NULL;
				lastNode->right = top;
			}
			lastNode = top;
		}
		return;
	}
};

采用递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:

	void dfs(TreeNode* root)
	{
		if (root == NULL)
			return;
		else if (root->left == NULL && root->right == NULL)
			return;
		else if (root->left != NULL && root->right == NULL){
			TreeNode* rootL = root->left;
			dfs(rootL);
			root->left = NULL;
			root->right = rootL;
			return;
		}
		else if (root->left == NULL && root->right != NULL)
		{
			TreeNode* rootR = root->right;
			dfs(rootR);
			root->right = rootR;
			return ;
		}
		else{
			TreeNode* rootL = root->left;
			TreeNode* rootR = root->right;

			dfs(rootL);
			dfs(rootR);

			root->right = rootL;
			root->left = NULL;

			TreeNode* pre = NULL;
			TreeNode* t = rootL;
			while (t != NULL){
				pre = t;
				t = t->right;
			}
			pre->right = rootR;
		}
	}

	void flatten(TreeNode* root) {
		if (root == NULL)
			return;

		dfs(root);

		return;
	}
};

采用非递归，不使用栈

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public void flatten(TreeNode root) {
        if(root == null){
            return;
        }
        TreeNode cur = root;
        while(cur != null){
            if(cur.left == null){
                cur = cur.right;
            }else{
                TreeNode preNode = cur.left;
                while(preNode.right != null){
                    preNode = preNode.right;
                }
                // cur.right变成preNode的右子树
                TreeNode curRight = cur.right;
                cur.right = null;
                preNode.right = curRight;

                // 左子树变右子树，顺便就把cur.left设置成right了
                TreeNode curLeft = cur.left;
                cur.left = null;
                cur.right = curLeft;

                cur = cur.right;
            }
        }
    }
}

面试题 17.12. BiNode

https://leetcode-cn.com/problems/binode-lcci/

非递归使用栈

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode convertBiNode(TreeNode root) {
        if(root == null){
            return null;
        }
        Stack<TreeNode> sta = new Stack<>();

        TreeNode dummy = new TreeNode(-1);
        TreeNode tail = dummy;

        TreeNode cur = root;
        while(!sta.isEmpty() || cur != null){
            if(cur != null){
                sta.push(cur);
                cur = cur.left;
            }else{
                TreeNode node = sta.pop();

                if(node.right != null){
                    cur = node.right;
                }

                tail.right = node;
                tail = node;
                tail.left = null;
            }
        }

        TreeNode res = dummy.right;
        dummy.right = null;
        return res;
    }
}

非递归，不使用栈

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode convertBiNode(TreeNode root) {
        if(root == null){
            return null;
        }

        TreeNode dummy = new TreeNode(-1);
        TreeNode tail = dummy;

        TreeNode cur = root;
        while(cur != null){
            if(cur.left == null){
                TreeNode node = cur;
                cur = cur.right;
                
                tail.right = node;
                tail = node;
                tail.left = null;
            }else{
                TreeNode pre = cur.left;
                while(pre.right != null && pre.right != cur){
                    pre = pre.right;
                }
                // 第一次访问
                if(pre.right == null){
                    pre.right = cur;
                    cur = cur.left;
                }else{
                    pre.right = null;

                    TreeNode node = cur;
                    //  转向右子树
                    cur = cur.right;

                    tail.right = node;
                    tail = node;
                    tail.left = null;
                }
            }
        }

        TreeNode res = dummy.right;
        dummy.right = null;
        return res;
    }
}
master-dragon
关注
专栏目录
二叉树非递归遍历,不使用栈(前序,中序,后续)
YLMF_yyz的专栏
04-02 3014
二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，它们都有使用栈和不使用栈的方法,其中不使用栈的非递归遍历又是找工作面试中经常被问的问题,所以在这里做一总结
二叉树的递归遍历与非递归遍历及Python实现--力扣94/144/145
weixin_37176244的博客
05-12 317
前言 昨天在看Leetcode上《二叉树》部分的书籍，做了四道关于二叉树的遍历的题目，在此总结一下二叉树的三种遍历方式及其实现。 二叉树的遍历 二叉树的遍历可以分为：前序遍历、中序遍历、后序遍历、层次遍历四种。以下面这一个二叉树为例： 前序遍历：首先访问二叉树的根节点，再访问左子树，最后访问右子树。前序遍历的结果为：F-C-A-D-B-E-H-G-M 中序遍历：首先访问二叉树的左子树，再访问根节点，最后访问右子树。中序遍历的结果为：A-C-B-D-F-H-E-M-G 后序遍历：首先访问二叉树的左子树，
不使用递归和栈遍历二叉树
半壶老酒
03-07 2847
二叉树遍历一共三种方式（暂且不把层次遍历算在内），前序，中序和后序，而每种遍历又分为递归和非递归版本。不管是递归还是非递归，都用到了栈。为什么要用栈？那是因为其他的方式没法记录当前节点的parent,而如果在每个节点的结构里面加个parent 分量显然是不现实的，那么今天的题目主旨是不使用栈，这该如何实现？该方法是Morris提出的。他用得很巧妙，实际上是用叶子节点的空指针来记录当前节点的位置，然
二叉树的非递归遍历
我的梦
07-11 3032
本文全部参考自：https://blog.csdn.net/gogogo_sky/article/details/70145550 特别感谢，大家一起学习吧。 在我们了解了最简单的递归遍历以后，现在来说说用栈辅助，非递归实现二叉树的前序，中序，后序遍历打印 一、非递归实现前序遍历打印 前序遍历，访问的顺序为根-&gt;左-&gt;右； 前序遍历的思想： （1）首先定义...
二叉树的非递归遍历（不用栈、O(1)空间）
热门推荐
小僧Coding
06-09 1万+
本文主要解决一个问题，如何实现二叉树的前中后序遍历，有两个要求： O(1)空间复杂度，即只能使用常数空间； 二叉树的形状不能被破坏（中间过程允许改变其形状）。 通常，实现二叉树的前序（preorder）、中序（inorder）、后序（postorder）遍历有两个常用的方法：一是递归(recursive)，二是使用栈实现的迭代版本(stack+iterative)。这两种方法都是O(n)的空间复杂度
二叉树的非递归遍历（非递归使用栈、非递归不使用栈）
weixin_33976072的博客
11-27 354
先序遍历：http://www.cnblogs.com/TenosDoIt/p/3416824.html 中序遍历：http://www.cnblogs.com/TenosDoIt/p/3445449.html 后序遍历：http://www.cnblogs.com/TenosDoIt/p/3416835.html 层序遍历：http://www.cnblogs.com/TenosDoIt/...
python-leetcode面试题解之第94题二叉树的中序遍历-题解.zip
最新发布
04-23
本压缩包提供的题解针对的是LeetCode第94题——二叉树的中序遍历，通过Python代码展示了递归和非递归两种解法。对于正在准备Python相关的求职面试者，深入理解并熟练应用这些解法将极大地提升面试表现和编程能力。
PHP基于非递归算法实现先序、中序及后序遍历二叉树操作示例
10-18
在中序遍历的非递归实现中，同样使用栈来保存节点。不同于先序遍历，中序遍历需要从下向上遍历。我们首先将左子树的所有节点压入栈中，然后访问当前节点，并转向其右子树。这个过程中，我们一直重复“将左子树压栈”...
leetcode：二叉树层序遍历（C实现，递归与非递归）
ms1003的博客
03-14 497
1.递归法 int depth(struct TreeNode *root) { int ld=0,rd=0; if(root) { ld=depth(root->left)+1; rd=depth(root->right)+1; } return ld>=rd?ld:rd; } void level_ord...
详细图解二叉树中序遍历（非递归C++）LeetCode94
m0_55864612的博客
09-27 2555
详细图解二叉树中序遍历（非递归）二叉树中序递归含义LeetCode题目94详细图解源代码运行结果 二叉树中序递归含义 中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。若二叉树为空则结束返回，否则： （1）中序遍历左子树 （2）访问根结点 （3）中序遍历右子树 如图1所示二叉树，中序遍历结果：DBEAFC LeetCode题目94 给定一个二叉树的根节点 root ，返回它的 中序 遍历。 输入：root = [1,null,2,3] 输出：[1,3,2] 输入：root = [1,2] 输出：
二叉树非递归遍历
10-23
数据结构的代码实现，非递归算法，。
Morris方法遍历二叉树 Binary Tree Morris Traversal
KAIKAI_ING的博客
10-09 344
Morris方法遍历二叉树 Binary Tree Morris Traversal 通常，实现二叉树的前序（preorder）、中序（inorder）、后序（postorder）遍历有两个常用的方法：一是递归(recursive)，二是使用栈实现的迭代版本(stack+iterative)。这两种方法都是O(n)的空间复杂度（递归本身占用stack空间或者用户自定义的stack），我在其他博客...
二叉搜索树(遍历不递归,不用栈)
jun2016425的博客
07-03 1527
什么是二叉搜索树一棵二叉搜索树是以一棵二叉树来组织的，如下图： 这样的一棵树可以使用一个链表数据结构来表示，其中每个结点就是一个对象。除了key和卫星数据之外,每个结点还包含属性left, right 和 parent, 它们分别指向左孩子，右孩子和双亲。比如：typeof struct node{ int key; // other data... 即卫星数据 str
第4章第1节练习题2 二叉树的基本操作（非递归实现）
法海你懂不?
05-29 2864
二叉树的基本操作，使用非递归方式实现...
非递归遍历二叉树：中序、前序与后序算法详解
本资源主要讨论了非递归遍历二叉树的方法，包括中序、前序和后序遍历。以下是详细解读： 1. **二叉树的中序遍历非递归**: - 中序遍历遵循"左-根-右"的顺序。非递归实现的关键在于使用栈。首先将所有左孩子入栈，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值