JAVA递归、非递归遍历二叉树

最新推荐文章于 2021-02-26 05:16:46 发布
最新推荐文章于 2021-02-26 05:16:46 发布
阅读量215 收藏
点赞数
分类专栏： Java基础 文章标签： java

转载：http://blog.csdn.net/hairongtian/article/details/7930937

不错



[java]  view plain  copy
  1. import java.util.Stack;    
  2. import java.util.HashMap;    
  3.     
  4. public class BinTree {    
  5.     private char date;    
  6.     private BinTree lchild;    
  7.     private BinTree rchild;    
  8.     
  9.     public BinTree(char c) {    
  10.         date = c;    
  11.     }    
  12.     
  13.     // 先序遍历递归     
  14.     public static void preOrder(BinTree t) {    
  15.         if (t == null) {    
  16.             return;    
  17.         }    
  18.         System.out.print(t.date);    
  19.         preOrder(t.lchild);    
  20.         preOrder(t.rchild);    
  21.     }    
  22.     
  23.     // 中序遍历递归     
  24.     public static void InOrder(BinTree t) {    
  25.         if (t == null) {    
  26.             return;    
  27.         }    
  28.         InOrder(t.lchild);    
  29.         System.out.print(t.date);    
  30.         InOrder(t.rchild);    
  31.     }    
  32.     
  33.     // 后序遍历递归     
  34.     public static void PostOrder(BinTree t) {    
  35.         if (t == null) {    
  36.             return;    
  37.         }    
  38.         PostOrder(t.lchild);    
  39.         PostOrder(t.rchild);    
  40.         System.out.print(t.date);    
  41.     }    
  42.     
  43.     // 先序遍历非递归     
  44.     public static void preOrder2(BinTree t) {    
  45.         Stack<BinTree> s = new Stack<BinTree>();    
  46.         while (t != null || !s.empty()) {    
  47.             while (t != null) {    
  48.                 System.out.print(t.date);    
  49.                 s.push(t);    
  50.                 t = t.lchild;    
  51.             }    
  52.             if (!s.empty()) {    
  53.                 t = s.pop();    
  54.                 t = t.rchild;    
  55.             }    
  56.         }    
  57.     }    
  58.     
  59.     // 中序遍历非递归     
  60.     public static void InOrder2(BinTree t) {    
  61.         Stack<BinTree> s = new Stack<BinTree>();    
  62.         while (t != null || !s.empty()) {    
  63.             while (t != null) {    
  64.                 s.push(t);    
  65.                 t = t.lchild;    
  66.             }    
  67.             if (!s.empty()) {    
  68.                 t = s.pop();    
  69.                 System.out.print(t.date);    
  70.                 t = t.rchild;    
  71.             }    
  72.         }    
  73.     }    
  74.     
  75.     // 后序遍历非递归     
  76.     public static void PostOrder2(BinTree t) {    
  77.         Stack<BinTree> s = new Stack<BinTree>();    
  78.         Stack<Integer> s2 = new Stack<Integer>();    
  79.         Integer i = new Integer(1);    
  80.         while (t != null || !s.empty()) {    
  81.             while (t != null) {    
  82.                 s.push(t);    
  83.                 s2.push(new Integer(0));    
  84.                 t = t.lchild;    
  85.             }    
  86.             while (!s.empty() && s2.peek().equals(i)) {    
  87.                 s2.pop();    
  88.                 System.out.print(s.pop().date);    
  89.             }    
  90.     
  91.             if (!s.empty()) {    
  92.                 s2.pop();    
  93.                 s2.push(new Integer(1));    
  94.                 t = s.peek();    
  95.                 t = t.rchild;    
  96.             }    
  97.         }    
  98.     }    
  99.     
  100.     public static void main(String[] args) {    
  101.         BinTree b1 = new BinTree('a');    
  102.         BinTree b2 = new BinTree('b');    
  103.         BinTree b3 = new BinTree('c');    
  104.         BinTree b4 = new BinTree('d');    
  105.         BinTree b5 = new BinTree('e');    
  106.     
  107.         /**  
  108.          *      a   
  109.          *     / /  
  110.          *    b   c  
  111.          *   / /  
  112.          *  d   e  
  113.          */    
  114.         b1.lchild = b2;    
  115.         b1.rchild = b3;    
  116.         b2.lchild = b4;    
  117.         b2.rchild = b5;    
  118.     
  119.         BinTree.preOrder(b1);    
  120.         System.out.println();    
  121.         BinTree.preOrder2(b1);    
  122.         System.out.println();    
  123.         BinTree.InOrder(b1);    
  124.         System.out.println();    
  125.         BinTree.InOrder2(b1);    
  126.         System.out.println();    
  127.         BinTree.PostOrder(b1);    
  128.         System.out.println();    
  129.         BinTree.PostOrder2(b1);    
  130.     }    
  131. }    

[java]  view plain  copy
  1. import java.util.Stack;    
  2. import java.util.HashMap;    
  3.     
  4. public class BinTree {    
  5.     private char date;    
  6.     private BinTree lchild;    
  7.     private BinTree rchild;    
  8.     
  9.     public BinTree(char c) {    
  10.         date = c;    
  11.     }    
  12.     
  13.     // 先序遍历递归     
  14.     public static void preOrder(BinTree t) {    
  15.         if (t == null) {    
  16.             return;    
  17.         }    
  18.         System.out.print(t.date);    
  19.         preOrder(t.lchild);    
  20.         preOrder(t.rchild);    
  21.     }    
  22.     
  23.     // 中序遍历递归     
  24.     public static void InOrder(BinTree t) {    
  25.         if (t == null) {    
  26.             return;    
  27.         }    
  28.         InOrder(t.lchild);    
  29.         System.out.print(t.date);    
  30.         InOrder(t.rchild);    
  31.     }    
  32.     
  33.     // 后序遍历递归     
  34.     public static void PostOrder(BinTree t) {    
  35.         if (t == null) {    
  36.             return;    
  37.         }    
  38.         PostOrder(t.lchild);    
  39.         PostOrder(t.rchild);    
  40.         System.out.print(t.date);    
  41.     }    
  42.     
  43.     // 先序遍历非递归     
  44.     public static void preOrder2(BinTree t) {    
  45.         Stack<BinTree> s = new Stack<BinTree>();    
  46.         while (t != null || !s.empty()) {    
  47.             while (t != null) {    
  48.                 System.out.print(t.date);    
  49.                 s.push(t);    
  50.                 t = t.lchild;    
  51.             }    
  52.             if (!s.empty()) {    
  53.                 t = s.pop();    
  54.                 t = t.rchild;    
  55.             }    
  56.         }    
  57.     }    
  58.     
  59.     // 中序遍历非递归     
  60.     public static void InOrder2(BinTree t) {    
  61.         Stack<BinTree> s = new Stack<BinTree>();    
  62.         while (t != null || !s.empty()) {    
  63.             while (t != null) {    
  64.                 s.push(t);    
  65.                 t = t.lchild;    
  66.             }    
  67.             if (!s.empty()) {    
  68.                 t = s.pop();    
  69.                 System.out.print(t.date);    
  70.                 t = t.rchild;    
  71.             }    
  72.         }    
  73.     }    
  74.     
  75.     // 后序遍历非递归     
  76.     public static void PostOrder2(BinTree t) {    
  77.         Stack<BinTree> s = new Stack<BinTree>();    
  78.         Stack<Integer> s2 = new Stack<Integer>();    
  79.         Integer i = new Integer(1);    
  80.         while (t != null || !s.empty()) {    
  81.             while (t != null) {    
  82.                 s.push(t);    
  83.                 s2.push(new Integer(0));    
  84.                 t = t.lchild;    
  85.             }    
  86.             while (!s.empty() && s2.peek().equals(i)) {    
  87.                 s2.pop();    
  88.                 System.out.print(s.pop().date);    
  89.             }    
  90.     
  91.             if (!s.empty()) {    
  92.                 s2.pop();    
  93.                 s2.push(new Integer(1));    
  94.                 t = s.peek();    
  95.                 t = t.rchild;    
  96.             }    
  97.         }    
  98.     }    
  99.     
  100.     public static void main(String[] args) {    
  101.         BinTree b1 = new BinTree('a');    
  102.         BinTree b2 = new BinTree('b');    
  103.         BinTree b3 = new BinTree('c');    
  104.         BinTree b4 = new BinTree('d');    
  105.         BinTree b5 = new BinTree('e');    
  106.     
  107.         /**  
  108.          *      a   
  109.          *     / /  
  110.          *    b   c  
  111.          *   / /  
  112.          *  d   e  
  113.          */    
  114.         b1.lchild = b2;    
  115.         b1.rchild = b3;    
  116.         b2.lchild = b4;    
  117.         b2.rchild = b5;    
  118.     
  119.         BinTree.preOrder(b1);    
  120.         System.out.println();    
  121.         BinTree.preOrder2(b1);    
  122.         System.out.println();    
  123.         BinTree.InOrder(b1);    
  124.         System.out.println();    
  125.         BinTree.InOrder2(b1);    
  126.         System.out.println();    
  127.         BinTree.PostOrder(b1);    
  128.         System.out.println();    
  129.         BinTree.PostOrder2(b1);    
  130.     }    
  131. }    
ForPan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
百度脑图(kityminder)优化
liuwk_2320的博客
03-19 3659
2017-03-14目标： 优化脑图，使其操作更为顺畅 问题： 脑图节点数过多时，初始化渲染很慢。 对节点进行增、删、改、移动等操作时，页面卡顿，无法进行其他操作。 原因： 节点数过多，初始化、导入、渲染操作耗时较长 节点数过多，重新渲染、布局操作耗时较长 dom数过多，即使一些小改动也会引起html重绘重排，造成页面卡顿 解决方案： 尽量减少页面上的dom数 脑图初始化时，只渲染到二级 展开节点时...
java实现的二叉树的递归和非递归遍历
05-14
已经经过不断的调试可以跑起来了 有详细的注释
java非递归遍历树_二叉树的递归与非递归遍历(Java描述)
weixin_31565723的博客
02-26 95
其中二叉树节点类/** 二叉树节点 */public class BTNode {private char key;private BTNode left, right;public BTNode(char key) {this(key, null, null);}public BTNode(char key, BTNode left, BTNode right) {this.key = key;...
二叉树的非递归遍历（java版）
qiuxinfa123的博客
12-07 8294
二叉树的递归遍历比较简单，这里就不聊了。今天主要聊聊二叉树的非递归遍历，主要借助于“栈”后进先出的特性来保存节点的顺序，先序遍历和中序遍历相对来说比较简单，重点理解后序遍历。 1. 先看看节点类型： //二叉树的节点类型 private class Node{ int data; //节点值 Node leftChild; //左孩子 Node right...
二叉树的非递归遍历（Java）
zz070的博客
04-08 292
二叉树的非递归遍历 1、非递归先序遍历 2、非递归中序遍历 3、非递归后序遍历 构建一棵二叉树 构建二叉树，并写出，前序遍历，中序变异，后序遍历的结果 代码运行结果： 代码实现 import java.util.Stack; public class Ergodic { //构建一棵二叉树 public static TreeNode build() { ...
二叉树非递归前序、中序、后序遍历
llllqqqqzzzz的博客
12-28 120
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;
非递归中序遍历二叉树java代码.docx
最新发布
10-16
非递归中序遍历二叉树
Java实现的二叉树常用操作【前序建树，前中后递归非递归遍历及层序遍历】
08-28
主要介绍了Java实现的二叉树常用操作,包括二叉树的前序建树，前中后递归非递归遍历及层序遍历等相关操作技巧,需要的朋友可以参考下
Java版二叉树遍历非递归程序
09-08
Java版二叉树遍历非递归程序，里面写的一般，希望大家喜欢！
二叉树的非递归遍历方式（Java）.md
04-24
详细介绍了JAVA中二叉树的非递归遍历方式，三种方式都是采用栈来辅助完成，其中前序遍历采用的是先入右子节点再入左子节点的方法，这样弹出栈时左在前，右在后。中序遍历的话则是要先一直到达最左的子节点，然后才弹...
java语言实现的二叉树的各种操作(包括递归与非递归遍历二叉树,求二叉树的高度，节点总数，叶子节点等)
03-08
java语言实现的二叉树的各种操作(包括递归与非递归遍历二叉树,求二叉树的高度，节点总数，叶子节点等)
java非递归实现二叉树的遍历
蕉下客
07-22 365
1、中序非递归遍历思想   初始化栈，根节点入栈   若栈非空，则栈顶节点的左孩子依次进栈。直到null，则   访问栈顶节点，使栈顶节点出栈。若栈顶节点右孩子非空，则使右孩子进栈成为栈顶节点。重复至栈空。 初始化二叉树如图所示： 步骤如下： 至此，中序输出顺序为：D->B->H->E->I->A->F->C->G
java非递归遍历二叉树 - Kaiqisan
Kaiqisan的博客
01-24 279
大家好，都吃晚饭了吗？我是Kaiqisan,是一个已经走出社恐的一般生徒,都说所有的递归都可以使用非递归的方式来解决，所以这次来一起康康非递归版本的二叉树的遍历 递归的本质就是不断往栈中塞入待执行代码，然后在代码块被执行的时候就会被调用执行，直到栈空，所以我们遍历树的时候也需要利用栈结构。 众所周知，前中后序遍历树的方法都很好理解 前序遍历就是先访问自己，再访问左节点最后访问右节点（中左右） 中序遍历就是先访问左节点，再访问自己最后访问右节点（左中右） 后序遍历就是先访问左节点，再访问右节点最后访问自己.
java实现二叉树的非递归遍历
Clouds
10-18 579
二叉树的递归遍历写起来很简单，但是往往在面试中要写出它的非递归遍历，结合网上的资料，自己写了一个完整的二叉树的前序遍历、中序遍历和后序遍历作为总结。 实现的二叉树如下：
java非递归遍历树_JAVA递归、非递归遍历二叉树
weixin_34307867的博客
02-20 101
不错import java.util.Stack;import java.util.HashMap;public class BinTree {private char date;private BinTree lchild;private BinTree rchild;public BinTree(char c) {date = c;}// 先序遍历递归public static void pr...
java非递归遍历file树_JAVA递归、非递归遍历二叉树
weixin_34677379的博客
02-25 64
s2 = new Stack();Integer i = new Integer(1);while (t != null || !s.empty()) {while (t != null) {s.push(t);s2.push(new Integer(0));t = t.lchild;}while (!s.empty() && s2.peek().equals(i)) {s2.po...
java递归，非递归遍历二叉树
yajlv的专栏
09-28 394
import java.util.Stack; public class BinTree { private char date; private BinTree lchild; private BinTree rchild; public BinTree(char c) { date = c;
Java二叉树非递归遍历
08-26
Java二叉树的非递归遍历可以通过使用栈数据结构来实现。首先，我们创建一个空的栈，将根节点入栈。然后，我们进入一个循环，直到栈为空为止。在每一次循环中，我们弹出栈顶元素，并将其访问。接下来，如果该节点有右...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值