二叉树的遍历分为深度优先遍历(DFS)和广度优先遍历(BFS)

DFS遍历主要有:

  • 前序遍历
  • 中序遍历
  • 后序遍历

一、递归实现DFS
Node.java:

  1. public class Node {
  2. private Object data;
  3. Node richild;
  4. Node lechild;
  5.  
  6. public Object getData() {
  7. return data;
  8. }
  9.  
  10. public void setData(Object data) {
  11. this.data = data;
  12. }
  13.  
  14. public Node getRichild() {
  15. return richild;
  16. }
  17.  
  18. public void setRichild(Node richild) {
  19. this.richild = richild;
  20. }
  21.  
  22. public Node getLechild() {
  23. return lechild;
  24. }
  25.  
  26. public void setLechild(Node lechild) {
  27. this.lechild = lechild;
  28. }
  29.  
  30. public Node(Object data, Node lechild, Node richild) {
  31. super();
  32. this.data = data;
  33. this.richild = richild;
  34. this.lechild = lechild;
  35. }
  36.  
  37. public Node() {
  38. super();
  39. }
  40.  
  41. }

递归遍历:

  1. public class BTree {
  2.  
  3. private static Node root;
  4. //构造树
  5. public static void init() {
  6. Node node1 = new Node("A", null, null);
  7. Node node2 = new Node("B", node1, null);
  8. Node node3 = new Node("C", null, null);
  9. Node node4 = new Node("D", node2, node3);
  10. Node node5 = new Node("E", null, null);
  11. Node node6 = new Node("F", null, node5);
  12. Node node7 = new Node("G", node4, node6);
  13. root = node7;
  14. }
  15. //访问节点
  16. public static void visited(Node n) {
  17. System.out.print(n.getData() + " ");
  18. }
  19. //前序遍历
  20. public static void preOrder(Node n) {
  21. if (n != null) {
  22. visited(n);
  23. preOrder(n.getLechild());
  24. preOrder(n.getRichild());
  25. }
  26. }
  27. //中序遍历
  28. public static void inOrder(Node n) {
  29. if (n != null) {
  30. inOrder(n.getLechild());
  31. visited(n);
  32. inOrder(n.getRichild());
  33. }
  34. }
  35. //后序遍历
  36. public static void postOrder(Node n) {
  37. if (n != null) {
  38. postOrder(n.getLechild());
  39. postOrder(n.getRichild());
  40. visited(n);
  41. }
  42. }
  43.  
  44. public static void main(String[] args) {
  45. init();
  46. System.out.print("递归前序:");
  47. preOrder(root);
  48. System.out.println();
  49. System.out.print("递归中序:");
  50. inOrder(root);
  51. System.out.println();
  52. System.out.print("递归后序:");
  53. postOrder(root);
  54. System.out.println();
  55. }
  56.  
  57. }

二、非递归实现DFS(依靠栈)

  1. //前序遍历
  2. public static void preOrder(Node n) {
  3. System.out.print("非递归前序:");
  4. Stack<Node> stack = new Stack<>();
  5. int index = 0;
  6. while (n != null || index > 0) {
  7. while (n != null) {
  8. System.out.print(n.getData() + " ");
  9. stack.push(n);
  10. index++;
  11. n = n.getLechild();
  12. }
  13. n = stack.pop();
  14. index--;
  15. n = n.getRichild();
  16. }
  17. }
  18. //中序遍历
  19. public static void inOrder(Node n) {
  20. System.out.print("非递归中序:");
  21. Stack<Node> stack = new Stack<>();
  22. int index = 0;
  23. while (n != null || index > 0) {
  24. while (n != null) {
  25. stack.push(n);
  26. index++;
  27. n = n.getLechild();
  28. }
  29. n = stack.pop();
  30. System.out.print(n.getData() + " ");
  31. index--;
  32. n = n.getRichild();
  33. }
  34. }
  35. //后序遍历
  36. public static void postOrder(Node n) {
  37. System.out.print("非递归后序:");
  38. Stack<Node> stack = new Stack<>();
  39. int index = 0;
  40. Node lastVisited = null;
  41. while (n != null || index > 0) {
  42. while (n != null) {
  43. stack.push(n);
  44. index++;
  45. n = n.getLechild();
  46. }
  47. n = stack.peek();
  48. if (n.getRichild() == null || n.getRichild() == lastVisited) {
  49. System.out.print(n.getData() + " ");
  50. lastVisited = n;
  51. index--;
  52. stack.pop();
  53. n = null;
  54. } else {
  55. n = n.getRichild();
  56. }
  57. }
  58. }

  

三、实现层序遍历(依靠队列)

  1. public static void LevenOrder(Node root) {
  2. if (root == null) {
  3. return;
  4. }
  5. Queue<Node> queue = new LinkedList<>();
  6. queue.add(root);
  7. Node temp = null;
  8. while (!queue.isEmpty()) {
  9. temp = queue.poll();
  10. visited(temp);
  11. if (temp.getLeChild() != null) {
  12. queue.add(temp.getLeChild());
  13. }
  14. if (temp.getRChild() != null) {
  15. queue.add(temp.getChild());
  16. }
  17. }
  18. }

Java数据结构——二叉树的遍历(汇总)的更多相关文章

  1. 【Java】 二叉树的遍历(递归与循环+层序遍历)

    在[Java] 大话数据结构(9) 树(二叉树.线索二叉树)一文中,已经实现了采用递归方法的前.中.后序遍历,本文补充了采用循环的实现方法.以及层序遍历并进行了一个总结. 递归实现 /* * 前序遍历 ...

  2. java算法----------二叉树的遍历

    二叉树的遍历分为前序.中序.后序和层序遍历四种方式 首先先定义一个二叉树的节点 //二叉树节点 public class BinaryTreeNode { private int data; priv ...

  3. 数据结构-二叉树的遍历实现笔记C++

    二叉树的遍历实现,可以用递归的方法也可以用非递归的方法.非递归的方法可以借助栈(前序遍历,中序遍历,后序遍历),也可以借助队列(层次遍历).本次笔记只使用了递归的方法来进行前序遍历,中序遍历,后序遍历 ...

  4. (2)Java数据结构--二叉树 -和排序算法实现

    === 注释:此人博客对很多个数据结构类都有讲解-并加以实例 Java API —— ArrayList类 & Vector类 & LinkList类Java API —— BigDe ...

  5. java数据结构——二叉树(BinaryTree)

    前面我们已经学习了一些线性结构的数据结构和算法,接下来我们开始学习非线性结构的内容. 二叉树 前面显示增.删.查.遍历方法,完整代码在最后面. /** * 为什么我们要学习树结构. * 1.有序数组插 ...

  6. Java实现二叉树地遍历、求深度和叶子结点的个数

    一.分析 二叉树是n个结点所构成的集合,它或为空树,或为非空树.对于非空树,它有且仅有一个根结点,且除根结点以外的其余结点分为两个互不相交的子集,分别称为左子树和右子树,它们本身又都是二叉树. 显而易 ...

  7. Java数据结构——二叉树

    前序遍历——根 左 右 中序遍历——左 根 右 后序遍历——左 右 根 //================================================= // File Name ...

  8. Java数据结构——二叉树 增加、删除、查询

    //二叉树系统 public class BinarySystem { public static void main(String[] args) { BinaryDomain root = nul ...

  9. 数据结构-二叉树的遍历(类C语言描写叙述)

    遍历概念     所谓遍历(Traversal)是指沿着某条搜索路线.依次对树中每一个结点均做一次且仅做一次訪问.訪问结点所做的操作依赖于详细的应用问题. 遍历是二叉树上最重要的运算之中的一个,是二叉 ...

随机推荐

  1. IDEA去掉Autowired的黄色背景和对象的红线

    Intellij idea @AutoWired注入bean 出现红色波浪线,@autowird下面显示黄色波浪线或者标黄,如下图,解决方法总结一下供大家使用  首先选择File--Settings- ...

  2. Vue中数组元素被替换,页面没有动态展示

    原始代码 页面没有相应goodsList替换,打印goodsList数据已经被替换: (借用https://www.cnblogs.com/belongs-to-qinghua/p/11112613. ...

  3. PHP系列之钩子

    PHP 提供的钩子 PHP 和 Zend Engine 为扩展提供了许多不同的钩子,这些扩展允许扩展开发人员以 PHP userland 无法提供的方式控制 PHP 运行时. 本章将展示各种钩子和从扩 ...

  4. PHP ord() 函数

    实例 返回 "h" 的 ASCII值: <?php高佣联盟 www.cgewang.comecho ord("h")."<br>&q ...

  5. luogu P4724 模板 三维凸包

    LINK:三维凸包 一个非常古老的知识点.估计也没啥用. 大体上了解了过程 能背下来就背下来吧. 一个bf:暴力枚举三个点 此时只需要判断所有的点都在这个面的另外一侧就可以说明这个面是三维凸包上的面了 ...

  6. NameNode中的高可用方案

    NN中元数据的可靠性是可以保证的,但是其可用性并不高,因为Namenode是单节点的,所以一旦这个节点不能工作,那么整个hdfs都不能工作,但是由于SecondaryNameNode的机制,所以,即便 ...

  7. Mybitis根据工具类反射数据库生成映射+整合springboot

    一 反向生成数据库mapper的工具类: 添加依赖 <dependency> <groupId>org.mybatis.generator</groupId> &l ...

  8. JavaScript异步编程——Async/Await vs Promise

    兼容性 提醒一下各位,Node 现在从版本 7.6 开始就支持 async/await 了.而就在前几天,Node 8已经正式发布了,你可以放心地使用它. 如果你还没有试过它,这里有一堆带有示例的理由 ...

  9. Android menu菜单的深入了解。。。

    今天补充刚开始的菜单控件,这是基于: https://www.cnblogs.com/aolong/p/12868015.html 里面的菜单写的. 今天学的后面部分是结合昨天的Fragment一起的 ...

  10. “随手记”开发记录day16

    今天先对前两天增加的“修改”功能进行测试.然后进行功能的明显划分,丰富账单的添加和显示方法.