LeetCode 中序遍历二叉树

AI-剁椒鱼头

已于 2022-10-14 16:00:10 修改

阅读量507

点赞数 1

分类专栏： LeetCode C# 算法文章标签： LeetCode 中序遍历二叉树 C# 算法

于 2018-09-26 01:03:05 首次发布

本文链接：https://blog.csdn.net/weixin_43251547/article/details/82847748

版权

C# 同时被 3 个专栏收录

74 篇文章 2 订阅

订阅专栏

算法

52 篇文章 1 订阅

订阅专栏

LeetCode

51 篇文章 1 订阅

订阅专栏

在线工具
在这里插入图片描述
中序遍历是指将二叉树转换成 [左边节点],[中间节点],[右边节点] 格式的一维数组，以下为实现

        #region 使用后进先出集合实现【不使用额外对象封装实现】
        
        public IList<int> InorderTraversal(TreeNode root)
        {
            var rets = new List<int>();

            var stack = new Stack<TreeNode>();
            if (root != null)
                stack.Push(root);
            while (stack.Count > 0)
            {
                var node = stack.Peek();
                if (node.left != null)
                {
                    stack.Push(node.left);
                    node.left = null;
                }
                else
                {
                    rets.Add(node.val);
                    stack.Pop();
                    if (node.right != null)
                    {
                        stack.Push(node.right);
                    }
                }
            }
            return rets;
        }

        #endregion

        #region 使用后进先出集合实现【不更改输入元素实现】

        public class Node
        {
            public Node(TreeNode treeNode)
            {
                TreeNode = treeNode;
                Left = true;
            }
            public TreeNode TreeNode { get; set; }
            public bool Left { get; set; }
        }
        public IList<int> InorderTraversal(TreeNode root)
        {
            var rets = new List<int>();

            var stack = new Stack<Node>();
            if (root != null)
                stack.Push(new Node(root));
            while (stack.Count > 0)
            {
                var node = stack.Peek();
                if (node.Left)
                {
                    node.Left = false;
                    if (node.TreeNode.left != null)
                    {
                        stack.Push(new Node(node.TreeNode.left)); //将最左边节点存入队列
                    }
                }
                else
                {
                    rets.Add(node.TreeNode.val);
                    stack.Pop(); //移除当前项
                    if (node.TreeNode.right != null)
                    {
                        stack.Push(new Node(node.TreeNode.right)); //将最右边节点存入队列
                    }
                }
            }

            return rets;
        }

        #endregion

        #region 递归解法
        public IList<int> InorderTraversal(TreeNode root)
        {
            var rets = new List<int>();
            if (root != null)
                InorderTraversal(root, rets);
            return rets;
        }

        private static void InorderTraversal(TreeNode root, List<int> rets)
        {
            if (root.left != null)
                InorderTraversal(root.left, rets);
            rets.Add(root.val);
            if (root.right != null)
                InorderTraversal(root.right, rets);
        }
        #endregion