精华内容
下载资源
问答
  • 后序遍历非递归 Java

    2020-04-04 16:05:13
    思路:借助先序遍历交换子树。...观察发现:交换左右子树的二叉树先序遍历=二叉树逆后序遍历=后序遍历反着来 因此,我们的目标是,想办法吧二叉树变成交换左右子树的二叉树,然后push进一个stack里,最后只要pop出...

    思路:借助先序遍历交换子树。

    创建二叉树

    原二叉树
    交换左右子树的二叉树

     

     得出:

    先序遍历: 1,2,4,5,3,6

    逆后序遍历:1,3,6,2,5,4

    后序遍历:4,5,2,6,3,1

    观察发现:交换左右子树的二叉树先序遍历=二叉树逆后序遍历=后序遍历反着来

    因此,我们的目标是,想办法吧二叉树变成交换左右子树的二叉树,然后push进一个stack里,最后只要pop出来。

    代码实现如下:

       /**
         * 通过后序遍历遍历二叉树
         *
         * @param
         */
        public static void postOrderTraversalWithStack(TreeNode root) {
            Stack<TreeNode> src = new Stack<TreeNode>();
            Stack<TreeNode> re = new Stack<TreeNode>();
            //将节点push进src
            src.push(root);
            while (!src.isEmpty()) {
                TreeNode p = src.pop();
                re.push(p);
                if (p.leftchild != null) {
                    src.push(p.leftchild);
                }
                if (p.rightchild != null) {
                    src.push(p.rightchild);
                }
            }
            //输出最终后序遍历的结果
            while (!re.isEmpty()) {
                System.out.print(re.pop().data + " ");
            }
        }

     

    展开全文
  • 今天刷后序遍历非递归实现时,因为以前看过借助一个栈和队列来实现,但始终模糊不清,不知道如何写,只好自己捋了一遍,然后查了下,发现和很多人写法有差异,故放出来,欢迎指正,如有知道用栈和队列方式实现的朋友...

    今天刷后序遍历非递归实现时,因为以前看过借助一个栈和队列来实现,但始终模糊不清,不知道如何写,只好自己捋了一遍,然后查了下,发现和很多人写法有差异,故放出来,欢迎指正,如有知道用栈和队列方式实现的朋友,也请赐教。

        public ArrayList<Integer> postorderTraversal(TreeNode root) {
            ArrayList<Integer> result = new ArrayList<>();
            if(root==null){
                return result;
            }
            TreeNode node = root;
            Stack<TreeNode> stack = new Stack<>();
            Stack<TreeNode> markStack = new Stack<>();
            while(node!=null||!stack.isEmpty()){
                while(node!=null){
                    stack.push(node);
                    node = node.left;
                }
                
                while(!markStack.isEmpty()&&markStack.peek()==stack.peek()){
                      markStack.pop();;
                      result.add(stack.pop().val);
                }
                if(!stack.isEmpty()){
                    node = stack.peek();
                    markStack.push(node);
                    node = node.right;
                }
            }
            
            
            return result;
        }
    展开全文
  • 难易程度:★★ 重要性:★★★★★ ... * 后序遍历 非递归 * * 后序遍历顺序:左右根 -> 变换:先获得根右左的遍历顺序,再反转( 根右左的顺序可以通过栈即可实现) * * @param root */ priv...

    难易程度:★★

    重要性:★★★★★

    树结构是面试中的考察的重点,而树的遍历又是树结构的基础。非递归的前序遍历算法思路可以借鉴。

    /**
         * 后序遍历 非递归
         * 
         * 后序遍历顺序:左右根 -> 变换:先获得根右左的遍历顺序,再反转( 根右左的顺序可以通过栈即可实现)
         * 
         * @param root
         */
        private static ArrayList<Integer> postOrder(TreeNode root) {
            if(root==null)  return new ArrayList<Integer>();
    
            // 存储:"根右左"的遍历顺序
            Stack<Integer> reverseRes = new Stack<Integer>();
    
            Stack<TreeNode> s = new Stack<TreeNode>();//辅助栈,保存待遍历的节点
            s.add(root);
    
            while (!s.isEmpty()) {
                TreeNode tem = s.pop();
                reverseRes.push(tem.val);//存储:"根右左"的遍历顺序,先入"根"节点
    
             // “右左”的遍历顺序,所以在栈(LIFO)中对应的就是:先进"左",再进"右"
                if (root.left != null)
                    s.push(root.left);
                if (root.right != null)
                    s.push(root.right);
            }
    
            ArrayList<Integer> res = new ArrayList<Integer>();//获得“根左右”的遍历序列
            while (!s.isEmpty()) {
                res.add(reverseRes.pop());
            }
            return res;
        }
    
    /**
         * 后序遍历  递归版本
         * @param root
         * @return
         */
        public static ArrayList<Integer> postOrder(TreeNode root) {
            ArrayList<Integer> res = new ArrayList<Integer>();
    
            preOrder(root, res);
            return res;
        }
    
        private static void postOrder(TreeNode root, ArrayList<Integer> res) {
            if (root == null)
                return;
    
            preOrder(root.left);
            preOrder(root.right);
            res.add(root.val);
        }

     


    扫描下方二维码,及时获取更多互联网求职面经javapython爬虫大数据等技术,和海量资料分享
    公众号菜鸟名企梦后台发送“csdn”即可免费领取【csdn】和【百度文库】下载服务;
    公众号菜鸟名企梦后台发送“资料”:即可领取5T精品学习资料java面试考点java面经总结,以及几十个java、大数据项目资料很全,你想找的几乎都有

    扫码关注,及时获取更多精彩内容。(博主今日头条大数据工程师)

    扫码关注,及时获取更多精彩内容。(博主今日头条大数据工程师)

     

    推荐阅读

     

    展开全文
  • 树的后序遍历(递归和非递归java实现)
                                   树的后序遍历(递归和非递归java实现)
    树的基本遍历是解决树相关问题的基础,所以要很熟悉,理解透彻!




    二叉树的结点定义:
    class BinaryTree{  
    public int value;  
    public BinaryTree leftNode;  
    public BinaryTree rightNode;  
    BinaryTree(int x) { value = x; }  
    }  




    后序遍历:左右根的原则遍历访问树的所有结点;
    void postOrder(BinaryTree root){
    	if(root !=null){	
    	postOrder(root.left);	
    	postOrder(root.right);
    	System.out.println(root.value);
    	}
    }


    后序遍历的非递归实现【java实现】

    package com.mytest.mymain;
    import java.util.Stack;
    class BTree{
    	public int value;  //public static int value;  那么最终输出都为8个8
    	public BTree left;  
    	public BTree right;  
    	BTree(int x) { value = x; }  
    }
    public class PreOrderwithStack {
    	public static void main(String[] args) {
    		BTree root=new BTree(1);
    		BTree Node2=new BTree(2);
    		BTree Node3=new BTree(3);
    		BTree Node4=new BTree(4);
    		BTree Node5=new BTree(5);
    		BTree Node6=new BTree(6);
    		BTree Node7=new BTree(7);
    		BTree Node8=new BTree(8);
    	
    		root.left=Node2;
    		root.right=Node3;
    		
    		Node2.left=Node4;
    		Node2.right=Node5;
    		
    		Node3.left=Node6;
    		Node3.right=Node7;
    		
    		Node4.left=Node8;
    		
    		preorderfun(root);
    		System.out.println();
    		inorderfun(root);
    		System.out.println();
    		postorderfun(root);
    	}
    	public static void postorderfun(BTree root){
    		Stack<BTree> stack =new Stack<BTree>();
    		BTree proot;//标记栈顶元素前一个被访问的元素
    		int flag;//root的左孩子未被访问;
    		if(root!=null){
    			do{
    				while(root!=null){//将root所有左孩子全部入栈
    					stack.push(root);
    					root=root.left;
    				  }
    				
    				//执行到此处,栈顶元素没有左孩子或者左子树已经被访问过;
    				proot=null;//标记栈顶元素前一个被访问的元素,或者此时为最左下边,该元素前一个被访问的元素肯定为空。
    				flag=1;//root的左孩子已经被访问;或者root为null
    				
    				while(!stack.isEmpty() && flag==1){
    					root=stack.peek();       //取到栈顶元素,但是不出栈;
    					if(root.right==proot){
    						root=stack.pop();
    						System.out.print(root.value+"  ");
    						proot=root;
    					}else{
    						root=root.right;
    						flag=0;//root左边孩子未被访问;
    					}
    				}
    			}while(!stack.isEmpty());
    		}
    		
    		
    	}
    
    
    






    展开全文
  • java版的二叉树的先序遍历、中序遍历以及后序遍历(递归以及非递归方式)
  • 二叉树后序遍历(递归+非递归Java

    千次阅读 2019-10-25 08:39:43
    后序遍历递归)代码图解功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个...
  • 二叉树前中后序遍历的递归及非递归实现
  • Java方式实现的二叉树前中后序遍历的递归及非递归方式
  • 概念理解 二叉树所谓的前序遍历、中序遍历、后序遍历中,前中后的意思,其实指的是根节点相...递归方式是最容易实现二叉树的前中后序遍历的,因为递归方式的代码,能非常直观的体现出二叉树三种遍历方式的特点。 前序遍
  • import java.util.ArrayList; import java.util.List; import java.util.Stack; ...public class PostOrder... //后序遍历非递归 public static void postOrderNoR(Node root) { Stack<Node> stack = n...
  • 二叉树后序遍历非递归实现(java)

    千次阅读 2018-09-29 23:42:48
    后序遍历:双栈法,和层次遍历(双队列)很相似,唯一区别在于层次遍历用的是队列,后序遍历用的是栈。 public static void posOrderUnRecur1(Node head){ System.out.print("PosOrder:"); if(head != null){ ...
  • 后序遍历递归定义: 先左子树,后右子树,再根节点。后序遍历的难点在于:需要判断上次访问的节点是位于左子树,还是右子树。若是位于左子树,则需跳过根节点,先进入右子树,再回头访问根节点;若是位于右子树,则...
  • 后序遍历: 对于节点cur可以分情况讨论 1. cur如果是叶子节点,直接输出 2. cur如果有孩子,且孩子没有被访问过,则按照右孩子,左孩子的顺序依次入栈 3. cur如果有孩子,而且孩子都已经访问过,则访问p节点 ...
  • 二叉树的先序、中序、后序遍历(递归 and 非递归)递归好写,非递归需要用栈就难写了。。package lianjia;import java.util.*; public class Main{ // 先序遍历(递归) public static void preOrder(TreeNode root...
  • 二叉树的后序遍历非递归算法

    万次阅读 多人点赞 2019-06-03 11:51:45
    1. 对于树的遍历我们最常用的三种遍历方法分别是前序遍历、中序遍历和后序遍历,使用的方法是深度优先遍历树的每一个节点,这些遍历方法都是使用递归函数来进行实现的,在数据量大的情况下是比较低效的,原因在于...
  • // 构造二叉树 1 / \ 2 3 / / \ 4 5 7 \ / 6 8一、二叉树的前、中、后序遍历(递归与非递归实现)二、二叉树的广度、深度优先遍历三、求二叉树...
  • 二叉树的前序、中序、后序遍历非递归java 核心思路是把每一个结点看成父节点,叶子结点是左右孩子是null的父结点。 前序遍历 思路: 使用一个栈来存储结点,以便回到之前的父结点。 不断往左子树深入并不断先打印...
  • 二叉树前序、中序、后序遍历非递归写法的透彻解析 前言 在前两篇文章二叉树和二叉搜索树中已经涉及到了二叉树的三种遍历。递归写法,只要理解思想,几行代码。可是非递归写法却很不容易。这里特地总结下,...
  • 求根结点到每个叶子节点的逆序列【后序遍历非递归的应用】
  • 二叉树的递归、非递归前中后序遍历和高度前中后序遍历递归非递归层次遍历树的高度递归非递归 前中后序遍历 递归 /** * 递归的前中后 */ public static void preOrder(TreeNode node){ System.out.println(node....
  • 后序遍历 代码 package com.li.traversal; import java.util.Stack; public class LRD { public static void main(String[] args) { TreeNode[] nodes = new TreeNode[10]; for(int i=0;i<10;...
  • 二叉树的基本遍历方式1 二叉树的概念1.1 二叉树的Java实现2 二叉树的遍历2.1 递归实现二叉树的遍历前序遍历:递归实现中序遍历:递归实现后序遍历递归实现2.1 循环实现二叉树的遍历前序遍历1:模拟递归的方式前序...
  • 二叉树最大深度,前序遍历、中序遍历、后序遍历算法,包含递归与非递归 1 import java.util.*; 2 3 import javax.swing.plaf.synth.SynthSpinnerUI; 4 class TreeNode{ 5 int data; 6 TreeNode ...
  • 对于二叉树的遍历一共存在两种类型:递归遍历和非递归遍历,针对每种类型有分为先序遍历,中序遍历和后序遍历。以下是六种遍历执行过程。 //先序遍历二叉树(递归形式) public List preOrder1(TreeNode root){ ...
  • 二叉树三种遍历的递归非递归实现
  • 到现在,树的深度遍历方式中就剩下树的后序...对于后序遍历,我们先给出一个递归的解法: package com.mengzhidu.teach.algorithm.tree.demo.traversal; import com.mengzhidu.teach.algorithm.tree.demo.TreeNode;...
  • 小白都能看懂的-二叉树后序遍历(递归和非递归)递归解决:自定义栈 递归解决: /** * 二叉树的后序遍历 * @author Administrator * */ public class TwoChaTree { /**首先我们要明白二叉树后序遍历的定义?...
  • 面试被问过,记录.... package ***; import java.util.Stack; /** * @author weichen CHEN created on 2018/1/8 ... * 二叉树前中后序非递归算法 */ public class BinarySearchTree { Stack s
  • 对于二叉树这种数据结构的...中序遍历非递归实现): 二叉树的中序遍历首先遍历左子树,然后访问根结点,最后遍历右子树。 代码实现: import java.util.Stack; public class Main { public static void main(String

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,797
精华内容 3,518
关键字:

后序遍历非递归java

java 订阅