精华内容
下载资源
问答
  • 时间复杂度5.结论 1.题目 二叉树中序遍历 2.数据结构与算法 递归: 迭代:引入辅助栈,处理递归嵌套问题。 3.源代码 模板类定义,参考我的文章:《二叉树BT 模板类实现》 这里只给出实现各版本中序遍历的代码。 ...

    1.题目

    二叉树中序遍历
    

    2.数据结构与算法

    递归:
    迭代:引入辅助栈,处理递归嵌套问题。

    3.源代码

    模板类定义,参考我的文章:《二叉树BT 模板类实现》
    这里只给出实现各版本中序遍历的代码。

    template<typename T1> 
    template<typename T, typename VST> 
    static void BinNode<T1>::goAlongLeftBranch(stack<BinNodePosi(T)> &s, BinNodePosi(T) x, VST &visit){
    	while(x){
    		s.push(x);
    		if(HasLChild(x)) x = x->lChild;
    	}
    }
    //中序遍历
    template<typename T> 
    template<typename VST> 
    void BinNode<T>::travIn(VST &visit){
    	switch(rand()%2){
    	case 1: travIn_R(this, visit);break;
    	case 2: travIn_I(this, visit);break;
    	}
    }
    //中序遍历各版本
    template<typename T1> 
    template<typename T, typename VST> 
    void BinNode<T1>::travIn_R(BinNodePosi(T) x, VST &visit){
    	if(!x) return;
    	travIn_R(x->lChild, visit);
    	visit(x->data);
    	travIn_R(x->rChild, visit);
    }
    template<typename T1> 
    template<typename T, typename VST> 
    void BinNode<T1>::travIn_I(BinNodePosi(T) x, VST &visit){
    	stack<BinNodePosi(T)> s;
    	while(true){
    		goAlongLeftBranch(x);
    		if(s.empty()) break;
    		x = s.top(); s.pop();
    		visit(x);
    		x = x->rChild;
    	}
    }
    

    4.时间复杂度

    与先序遍历情况相同。
    时间复杂度都是ο(n)\omicron(n),但是其系数是大有不同的。
    递归:每个递归实例有通用的格式,并不能做到足够的小。
    迭代1:引入辅助栈处理递归嵌套问题,使每一帧保存的数据足够小。
    左侧链访问入栈,访问栈顶。
    嵌套访问右节点左侧链。
    其他迭代版本:使用了succ()函数,时间效率降低。
    在这里插入图片描述

    5.结论

    如有错误,请您批评指正。
    参考书籍:清华大学《数据结构(C++语言版)》(第三版) 邓俊辉

    展开全文
  • 再比方树的前序、中序、兴许遍历算法。 递归算法尽管是有代码简洁这个长处,可是其缺点显著。由于递归函数是在运行过程中调用其自身,所以会占用大量的栈上空间,而且压栈和出栈都是有时间消耗的。所以从这一点上...

    递归算法大家都不陌生,当须要反复计算同样问题时,一般能够选择递归和循环两种算法。

    又由于递归实现起来代码比較简洁。所以通常都会使用递归来解决上述问题。比方斐波那契数列。再比方树的前序、中序、兴许遍历算法。

    递归算法尽管是有代码简洁这个长处,可是其缺点显著。

    由于递归函数是在运行过程中调用其自身,所以会占用大量的栈上空间,而且压栈和出栈都是有时间消耗的。

    所以从这一点上来看,递归的效率是不如循环。除了效率之外,递归另一个相当明显的问题:可能会导致栈溢出。当递归调用的次数过大时,非常有可能会出现栈溢出的情况。

    我们这里暂不考虑空间复杂度,仅讨论其时间复杂度以及改善方法。

    还是以经典的Fibonacci数列为例。其定义例如以下:

                                   

    1. 递归解法

    对于这个题目,大家对于其算法已经十分熟悉。非常快就能写出以下的代码:

    long long Fibonacci(unsigned int n)
    {
        if (n <= 0) {
            return 0;
        }
    
        if (n == 1) {
            return 1;
        }
    
        return Fibonacci(n-1) + Fibonacci(n-2);
    }
    我们以f(10)为例分析来分析递归的计算过程。f(10)=f(9)+f(8), f(9)=f(8)+f(7), f(8)=f(7)+f(6)。。

    。。

    能够用树形结构来表示整个计算过程


                                       

    我们能够看出来,上面的树中,非常多结点都是反复计算的。其实,递归算法的时间复杂度是n的指数级的。这种复杂度。一般来说是不可接受的。


    2. 递归算法改善

    上述的递归算法中。时间复杂度高的原因是过程中存在大量的反复计算。因此,假设能想办法避免反复计算,那么其时间复杂度便能够降下来。

    比較简单的方法是採用逆序的递归算法:f(0)+f(1)=f(2), f(1)+f(2)=f(3),以此类推便能够计算出f(n)。

    而且这个算法的时间复杂度非常明显,就是O(n)。代码例如以下:

    long long Fibonacci(unsigned int n)
    {
        long long fibNMinusOne = 1;
        long long fibNMinusTwo = 0;
        long long fibN = 0;
        int result[2] = {0, 1};
        int i;
    
        if (n < 2) {
            return result[n];
        }
        
        for (i = 2; i < n; i++) {
            fibN = fibNMinusTwo + fibNMinusOne;
            fibNMinusTwo = fibNMinusOne;
            fibNMinusOne = fibN;
        }
    
        return fibN;
    }

    转载于:https://www.cnblogs.com/yxysuanfa/p/7001285.html

    展开全文
  • 二叉树的中序遍历 题目描述: 解题思路: 第一种:递归。又是递归,可以发现很多题都可以用到递归的思路…。二叉树的中序遍历,这里不太了解的可以看看这个博客:二叉树遍历...时间复杂度:O(N) class TreeNode: def
  • 题目描述: 给定一个二叉树,返回...进阶: 递归算法很简单,你可以通过迭代算法完成吗? 解法一 通过递归实现。时间复杂度:O(N),空间复杂度:平均是O(logn)(树的高度)。最坏是O(n)(当树退化成链表时)。 /** * D

    题目链接:https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
    题目描述:
    给定一个二叉树,返回它的中序 遍历。

    示例:

    输入: [1,null,2,3]
       1
        \
         2
        /
       3
    
    输出: [1,3,2]
    

    进阶: 递归算法很简单,你可以通过迭代算法完成吗?

    解法一

    通过递归实现。时间复杂度:O(N),空间复杂度:平均是O(logn)(树的高度)。最坏是O(n)(当树退化成链表时)。

    /**
     * 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<>();
            //调用中序遍历方法
            inorder(root,ans);
            return ans;
        }
        private void inorder(TreeNode root,List<Integer> ans) {
            if(root != null) {
                //左结点不为空,遍历左子树
                if(root.left != null) {
                    inorder(root.left , ans);
                }
                //访问根结点
                ans.add(root.val);
                //右节点不为空,访问右子树
                if(root.right != null) {
                    inorder(root.right , ans);
                }
            }
        }
    }
    

    解法二

    利用栈,使用迭代。时间复杂度:O(N)。空间复杂度:O(n)。

    /**
     * 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<>();
            Deque<TreeNode> stack = new LinkedList<>();
            TreeNode current = root;
    
            while(current != null || !stack.isEmpty()) {
                //将当前节点的左孩子入栈,直到没有左孩子
                while(current != null) {
                    stack.offerFirst(current);
                    current = current.left;
                }
                //当左孩子都入栈之后,将之出栈,并将其值加入ans,将其右孩子入栈
                current = stack.pollFirst();
                ans.add(current.val);
                //如果当前节点没有右孩子,则进入下一次循环,将其父节点出栈返回。
                current = current.right;
            }
            return ans;
        }
    }
    

    解法三

    使用栈、迭代。但是将先序、中序和后序遍历的迭代式代码统一了。
    只需更改右孩子、当前节点、左孩子的入栈顺序,就可以实现三种遍历方式。

    /**
     * Definition for a binary tree node.
     * public class TreeNode {
     *     int val;
     *     TreeNode left;
     *     TreeNode right;
     *     TreeNode(int x) { val = x; }
     * }
     */
     //定义一个类,表示结点与其对应颜色
    public class ColorNode {
        TreeNode node;
        String color;
        public ColorNode(TreeNode node,String color) {
            this.node = node;
            this.color = color;
        }
    }
    //第一次遍历到的结点都设置为白色“white”
    //第二次遍历到的结点设置为灰色“gray”
    //如果遇到白色的结点,更改其颜色为灰色,并将其右孩子、自身、左孩子分别入栈
    //如果遇到灰色结点,将其值加入ans中
    class Solution {
        public List<Integer> inorderTraversal(TreeNode root) {
            if(root == null){
                return new ArrayList<Integer>(0);
            }
            List<Integer> ans = new ArrayList<>();
            Deque<ColorNode> stack = new LinkedList<>();
            //把根结点设置为白色,放入栈中
            stack.offerFirst(new ColorNode(root,"white"));
    
            while(!stack.isEmpty()) {
                //将栈顶元素出栈
                ColorNode cn = stack.pollFirst();
                //遇到白色结点
                if(cn.color.equals("white")) {
                    //当前节点有右孩子,将右孩子设置为白色,入栈
                    if(cn.node.right != null) {
                        stack.offerFirst(new ColorNode(cn.node.right,"white"));
                    }
                    //将当前结点更改为灰色,入栈
                    stack.offerFirst(new ColorNode(cn.node,"gray"));
                    //如果当前结点有左孩子,将左孩子设置为白色,入栈
                    if(cn.node.left != null) {
                        stack.offerFirst(new ColorNode(cn.node.left,"white"));
                    }
                }
                //遇到灰色结点,将其值加入ans中
                else {
                    ans.add(cn.node.val);
                }
            }
            return ans;
        }
    }
    
    展开全文
  • 二叉搜索树与双向链表 个人博客 题解 中序遍历 ...算法思想 ...二叉搜索树的中序遍历序列是节点从小到大的顺序 ...在遍历的过程中记录上一次遍历的节点,...时间复杂度 O(n) 空间复杂度 O(n):最坏情况下,树退化为链表

    二叉搜索树与双向链表

    个人博客


    wvE2LQ

    7bSsZa

    题解

    • 中序遍历

      • 算法思想

        • 二叉搜索树的中序遍历序列是节点从小到大的顺序

        • 在遍历的过程中记录上一次遍历的节点,此次遍历将本节点的左子节点指向上一个节点,将上一个节点的右子节点指向本节点,这样就完成了连接

        • 特殊情况:

          • 遍历第一个节点的时候,pre 是 null,所以需要判断 pre 是否为 null
            • 如果为 null,则将此节点记录为 head 节点
      • 复杂度分析

        • 时间复杂度 O(n)
        • 空间复杂度 O(n):最坏情况下,树退化为链表,队规深度达到 N,使用 O(n)的额外空间
      /*
      // Definition for a Node.
      class Node {
          public int val;
          public Node left;
          public Node right;
      
          public Node() {}
      
          public Node(int _val) {
              val = _val;
          }
      
          public Node(int _val,Node _left,Node _right) {
              val = _val;
              left = _left;
              right = _right;
          }
      };
      */
      class Solution {
          Node pre,head;
          public Node treeToDoublyList(Node root) {
              if(root == null)return null;
              dfs(root);
              head.left = pre;
              pre.right = head;
              return head;
          }
          void dfs(Node cur){
              if(cur == null)return;
              dfs(cur.left);
              if(pre == null)head = cur;
              else pre.right = cur;
              cur.left = pre;
              pre = cur;
              dfs(cur.right);
          }
          
      }
      

      f5wrhY

    总结

    • 中序遍历序列是从小到大的顺序排列的,但是我没有办法想到可以通过这个性质将节点按照排序连接起来。为什么自己的联想能力不足?是因为性质还不够内化?对递归还不够熟悉吗?(这里比较重要的一个点是这些中序遍历的序列中的每一个节点都是可以操作的,而不仅仅是个数字
    • 为什么可以想到用一个变量记录之前遍历的节点?巧妙的完成了连接。
    展开全文
  • ##给定一个二叉树,返回它的中序遍历。 示例: 输入: [1,null,2,3] 1 2 / 3 输出: [1,3,2] 进阶:递归算法很简单,你可以通过迭代算法完成吗? 栈。 思路 时间复杂度O(n),空间复杂度O(lgn)。 递归代码 /** * ...
  • 递归算法很简单,你可以通过迭代算法完成吗? 解答 解法一:递归 递归遍历没什么难度,这里不细说了。 复杂度:O(n) 时间,O(n) 空间。 代码 /** * Definition for a binary tree node. * public class Tree...
  • 题目: 给定一个二叉树,返回它的中序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] ...进阶: 递归算法很简单,你可以通过迭代算法完成吗?...时间复杂度: O(n) //二叉树有n个结点,每个结点会被
  • 给定一个二叉树,返回它的中序遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] 进阶:递归算法很简单,你可以通过迭代算法完成吗? 时间复杂度:O(n) 空间复杂度:O(n) 思路: 方法1 非...
  • o(n)时间复杂度,o(1)空间复杂度中序遍历二叉树做法:用一个last指针和一个cur指针。主要是查看是0.是否已经回到访问完的根节点1.从子节点回溯到当前节点 1.1 从左孩子回溯的:访问当前节点 1.2 从右孩子回溯的:...
  • 常见的二叉树非递归算法都是用栈保存访问路径上的结点,这样使空间复杂为o(n),其中n为树最大深度。空间复杂度为o(1)的算法并没有以牺牲时间复杂度为代价,它只是巧妙的运用叶子结点左右孩子指针为空这一事实,将...
  • 前序中序遍历问题

    2009-11-29 09:18:00
    给定一棵二叉树,已知二叉树的前序中序遍历序列,设计一个算法,确定该二叉树的后序遍历的序列。 数据结构: 采用STL中的string实现。 算法分析: 在中序序列中查找前序序列中的首元素,作为根节点,根节点...
  • 94. 二叉树的中序遍历

    2020-08-26 14:59:02
    时间复杂度:O(n) 空间复杂度:O(n) 边界条件: 补充知识: /** *Definitionforabinarytreenode. *publicclassTreeNode{ *intval; *TreeNodeleft; *TreeNoderight; *TreeNode(intx){val=x;} *} */ class...
  • 二叉树的递归算法虽然简单,但是会导致时间复杂度比较高,下面给大家带来用栈实现的二叉树非递归算法首先定义好二叉树,和元素类型为二叉树的栈typedef struct BiTNode{ TElemType data; struct BiTNode *lchild, ...
  • 时间复杂度 表示 O(1) O(log n) O(n) O(n^2) O(2^n) O(n!) 时间 常数 对数 线性 幂次 指数 阶乘 例子 二分查找/简单递归 简单查找 选择排序 旅行商问题 算法运行时间是从其增速的角度度量的,大O...
  • 二叉树的先序、中序、后序遍历,包括递归方式和非递归方式 1、二叉树的前序遍历 1.1 思路: 二叉树是一个由left子节点和right子节点 以及val组成的数据结果。...时间复杂度:二叉树的遍历需要花费O(n) 如果不
  • 文章目录彩蛋题Morris遍历它的意义步骤(对于当前节点cur,可以结合eg理解)eg(利用底层空闲指针回到上层)时间复杂度O(N)的证明morris代码MORRIS转成先序MORRIS转成中序MORRIS转成后序逆序输出右边界时如何保持...
  • 一,递归算法 二叉树的前、中、后序遍历的思路和程序都非常简单。 前中后序遍历的算法结构相同,只需要调整打印的位置。 前序遍历:打印根-访问左子树-访问右子树 中序遍历:访问左子树-打印根-访问右子树 后序遍历...
  • 遍历二叉树算法基本操作是访问结点,不论按哪一种次序进行遍历,对含n个结点的二叉树时间复杂度都为O(n)。   前序遍历: 递归方式:  void preorder_recursive(Bitree T) /* 先序遍历二叉树的递归算法 */...
  • 树的遍历

    2018-11-06 18:55:33
    文章目录普通遍历递归遍历先序遍历中序遍历后序遍历递归总结层次遍历非递归遍历先序遍历中序遍历后序遍历 普通遍历 普通遍历的意思是时间复杂度为O(N),空间复杂度为O(h)的遍历算法,区别于后边学习的Morris遍历 ...
  • 目 录: 1、Morris 遍历的基本概念 2、Morris 的前序遍历 3、Morris 的中序遍历 4、Morris 的后序遍历 其实之前的文章里已经记录了二叉树的递归/非递归遍历...Morris 遍历:时间复杂度 O(N)、额外空间复杂度 ...
  • 中序遍历六. 后序遍历 一. 传统做法与时间复杂度 遍历到树底后需要返回其上一个节点去遍历其右子树,所以传统是递归或者自己用个栈模拟递归操作。 时间复杂度:O(N),空间复杂度:O(N) 二. morris 时间复杂度 空间...
  • 二叉树遍历的另外一种方法:Morris遍历二叉树 的空间复杂度为O(1),并且还不改变原本的树结构,时间复杂度依然为O(n)。Morris的核心是利用叶子节点的空闲右孩子指针返回到根节点。中序遍历最初Morris是为中序遍历...
  • 二叉树神级遍历算法——Morris遍历(C++版)

    千次阅读 多人点赞 2015-11-27 14:36:57
    设计一个算法实现二叉树的三种遍历(前序遍历 中序遍历 后序遍历)。 要求时间复杂度为O(n) 空间复杂度为O(1)。   思路: 空间复杂度O(1)的要求很严格。常规的递归实现是显然不能满足要求的[其空间复杂度是树的...
  • 经典算法 Morris遍历

    2019-01-29 20:23:00
    内容: 1、什么是morris遍历 2、morris遍历规则与过程 3、先序及中序 4、后序 5、morris遍历时间复杂度分析 ...1、什么是morris遍历 ...关于二叉树先序、中序、后序...明显这6种遍历算法时间复杂度都需要 O(H) (H...
  • 常用的二叉树遍历主要分为...而本文介绍的Morris算法,只需O(1)的空间复杂度,本质上是使用时间换取空间的一种方法。 假设我们要遍历如下二叉树: 如果采用中序遍历,那么遍历顺序应该为1 2 3 4 5 6 7 8 9 10,...

空空如也

空空如也

1 2 3 4 5 6
收藏数 102
精华内容 40
关键字:

中序遍历递归算法时间复杂度