Java实现二叉树的深度优先遍历和广度优先遍历算法示例

 更新时间:2018年04月19日 15:02:31   作者:Fantasy_Lin_  
这篇文章主要介绍了Java实现二叉树的深度优先遍历和广度优先遍历算法,结合实例形式详细分析了二叉树的定义、深度优先遍历与广度优先遍历算法原理与相关操作实现技巧,需要的朋友可以参考下

本文实例讲述了Java实现二叉树的深度优先遍历和广度优先遍历算法。分享给大家供大家参考,具体如下:

1. 分析

二叉树的深度优先遍历的非递归的通用做法是采用栈,广度优先遍历的非递归的通用做法是采用队列。

深度优先遍历:对每一个可能的分支路径深入到不能再深入为止,而且每个结点只能访问一次。要特别注意的是,二叉树的深度优先遍历比较特殊,可以细分为先序遍历、中序遍历、后序遍历。具体说明如下:

先序遍历:对任一子树,先访问根,然后遍历其左子树,最后遍历其右子树。

中序遍历:对任一子树,先遍历其左子树,然后访问根,最后遍历其右子树。

后序遍历:对任一子树,先遍历其左子树,然后遍历其右子树,最后访问根。

广度优先遍历:又叫层次遍历,从上往下对每一层依次访问,在每一层中,从左往右(也可以从右往左)访问结点,访问完一层就进入下一层,直到没有结点可以访问为止。

2. 举例说明

对下图所示的二叉排序树进行遍历,要求使用先序遍历(递归、非递归)、中序遍历(递归、非递归)、后序遍历(递归、非递归)和广度优先遍历。

① 参考代码

package BinaryTreeTraverseTest;
import java.util.LinkedList;
import java.util.Queue;
/**
 * 二叉树的深度优先遍历和广度优先遍历
 * @author Fantasy
 * @version 1.0 2016/10/05 - 2016/10/07
 */
public class BinaryTreeTraverseTest {
  public static void main(String[] args) {
  BinarySortTree<Integer> tree = new BinarySortTree<Integer>();
    tree.insertNode(35);
    tree.insertNode(20);
    tree.insertNode(15);
    tree.insertNode(16);
    tree.insertNode(29);
    tree.insertNode(28);
    tree.insertNode(30);
    tree.insertNode(40);
    tree.insertNode(50);
    tree.insertNode(45);
    tree.insertNode(55);
    System.out.print("先序遍历(递归):");
    tree.preOrderTraverse(tree.getRoot());
    System.out.println();
    System.out.print("中序遍历(递归):");
    tree.inOrderTraverse(tree.getRoot());
    System.out.println();
    System.out.print("后序遍历(递归):");
    tree.postOrderTraverse(tree.getRoot());
    System.out.println();
    System.out.print("先序遍历(非递归):");
    tree.preOrderTraverseNoRecursion(tree.getRoot());
    System.out.println();
    System.out.print("中序遍历(非递归):");
    tree.inOrderTraverseNoRecursion(tree.getRoot());
    System.out.println();
    System.out.print("后序遍历(非递归):");
    tree.postOrderTraverseNoRecursion(tree.getRoot());
    System.out.println();
    System.out.print("广度优先遍历:");
    tree.breadthFirstTraverse(tree.getRoot());
  }
}
/**
 * 结点
 */
class Node<E extends Comparable<E>> {
  E value;
  Node<E> left;
  Node<E> right;
  Node(E value) {
    this.value = value;
    left = null;
    right = null;
  }
}
/**
 * 使用一个先序序列构建一棵二叉排序树(又称二叉查找树)
 */
class BinarySortTree<E extends Comparable<E>> {
  private Node<E> root;
  BinarySortTree() {
    root = null;
  }
  public void insertNode(E value) {
    if (root == null) {
      root = new Node<E>(value);
      return;
    }
    Node<E> currentNode = root;
    while (true) {
      if (value.compareTo(currentNode.value) > 0) {
        if (currentNode.right == null) {
          currentNode.right = new Node<E>(value);
          break;
        }
        currentNode = currentNode.right;
      } else {
        if (currentNode.left == null) {
          currentNode.left = new Node<E>(value);
          break;
        }
        currentNode = currentNode.left;
      }
    }
  }
  public Node<E> getRoot(){
    return root;
  }
  /**
   * 先序遍历二叉树(递归)
   * @param node
   */
  public void preOrderTraverse(Node<E> node) {
    System.out.print(node.value + " ");
    if (node.left != null)
      preOrderTraverse(node.left);
    if (node.right != null)
      preOrderTraverse(node.right);
  }
  /**
   * 中序遍历二叉树(递归)
   * @param node
   */
  public void inOrderTraverse(Node<E> node) {
    if (node.left != null)
      inOrderTraverse(node.left);
    System.out.print(node.value + " ");
    if (node.right != null)
      inOrderTraverse(node.right);
  }
  /**
   * 后序遍历二叉树(递归)
   * @param node
   */
  public void postOrderTraverse(Node<E> node) {
    if (node.left != null)
      postOrderTraverse(node.left);
    if (node.right != null)
      postOrderTraverse(node.right);
    System.out.print(node.value + " ");
  }
  /**
   * 先序遍历二叉树(非递归)
   * @param root
   */
  public void preOrderTraverseNoRecursion(Node<E> root) {
    LinkedList<Node<E>> stack = new LinkedList<Node<E>>();
    Node<E> currentNode = null;
    stack.push(root);
    while (!stack.isEmpty()) {
      currentNode = stack.pop();
      System.out.print(currentNode.value + " ");
      if (currentNode.right != null)
        stack.push(currentNode.right);
      if (currentNode.left != null)
        stack.push(currentNode.left);
    }
  }
  /**
   * 中序遍历二叉树(非递归)
   * @param root
   */
  public void inOrderTraverseNoRecursion(Node<E> root) {
    LinkedList<Node<E>> stack = new LinkedList<Node<E>>();
    Node<E> currentNode = root;
    while (currentNode != null || !stack.isEmpty()) {
      // 一直循环到二叉排序树最左端的叶子结点(currentNode是null)
      while (currentNode != null) {
        stack.push(currentNode);
        currentNode = currentNode.left;
      }
      currentNode = stack.pop();
      System.out.print(currentNode.value + " ");
      currentNode = currentNode.right;
    }
  }
  /**
   * 后序遍历二叉树(非递归)
   * @param root
   */
  public void postOrderTraverseNoRecursion(Node<E> root) {
    LinkedList<Node<E>> stack = new LinkedList<Node<E>>();
    Node<E> currentNode = root;
    Node<E> rightNode = null;
    while (currentNode != null || !stack.isEmpty()) {
      // 一直循环到二叉排序树最左端的叶子结点(currentNode是null)
      while (currentNode != null) {
        stack.push(currentNode);
        currentNode = currentNode.left;
      }
      currentNode = stack.pop();
      // 当前结点没有右结点或上一个结点(已经输出的结点)是当前结点的右结点,则输出当前结点
      while (currentNode.right == null || currentNode.right == rightNode) {
        System.out.print(currentNode.value + " ");
        rightNode = currentNode;
        if (stack.isEmpty()) {
          return; //root以输出,则遍历结束
        }
        currentNode = stack.pop();
      }
      stack.push(currentNode); //还有右结点没有遍历
      currentNode = currentNode.right;
    }
  }
  /**
   * 广度优先遍历二叉树,又称层次遍历二叉树
   * @param node
   */
  public void breadthFirstTraverse(Node<E> root) {
    Queue<Node<E>> queue = new LinkedList<Node<E>>();
    Node<E> currentNode = null;
    queue.offer(root);
    while (!queue.isEmpty()) {
      currentNode = queue.poll();
      System.out.print(currentNode.value + " ");
      if (currentNode.left != null)
        queue.offer(currentNode.left);
      if (currentNode.right != null)
        queue.offer(currentNode.right);
    }
  }
}

② 输出结果

先序遍历(递归):35 20 15 16 29 28 30 40 50 45 55
中序遍历(递归):15 16 20 28 29 30 35 40 45 50 55
后序遍历(递归):16 15 28 30 29 20 45 55 50 40 35
先序遍历(非递归):35 20 15 16 29 28 30 40 50 45 55
中序遍历(非递归):15 16 20 28 29 30 35 40 45 50 55
后序遍历(非递归):16 15 28 30 29 20 45 55 50 40 35
广度优先遍历:35 20 40 15 29 50 16 28 30 45 55

更多关于java算法相关内容感兴趣的读者可查看本站专题:《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总

希望本文所述对大家java程序设计有所帮助。

相关文章

  • Java爬虫Jsoup+httpclient获取动态生成的数据

    Java爬虫Jsoup+httpclient获取动态生成的数据

    这篇文章主要介绍了Java爬虫Jsoup+httpclient获取动态生成的数据的相关资料,需要的朋友可以参考下
    2017-05-05
  • java自带的四种线程池实例详解

    java自带的四种线程池实例详解

    java线程的创建非常昂贵,需要JVM和OS(操作系统)互相配合完成大量的工作,下面这篇文章主要给大家介绍了关于java自带的四种线程池的相关资料,文中通过图文介绍的非常详细,需要的朋友可以参考下
    2022-04-04
  • springcloud项目里application.yml不加载的坑及解决

    springcloud项目里application.yml不加载的坑及解决

    这篇文章主要介绍了springcloud项目里application.yml不加载的坑及解决,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-07-07
  • 详解MyBatis的动态SQL实现原理

    详解MyBatis的动态SQL实现原理

    MyBatis提供了强大的动态SQL语句生成功能,以应对复杂的业务场景,本篇文章将结合MyBatis解析SQL语句的过程对MyBatis中对<if>,<where>,<foreach>等动态SQL标签的支持进行分析,需要的朋友可以参考下
    2023-07-07
  • Spring之@Aspect中通知的5种方式详解

    Spring之@Aspect中通知的5种方式详解

    本文主要介绍了Spring之@Aspect中通知的5种方式详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2022-05-05
  • 一篇文章带你搞定JAVA反射

    一篇文章带你搞定JAVA反射

    这篇文章主要介绍了Java反射机制的简单讲解,本文讲解了Java的高级概念反射机制,通过文字介绍案例该项概念和代码的详细展示,需要的朋友可以参考下
    2021-07-07
  • 使用SpringSecurity+defaultSuccessUrl不跳转指定页面的问题解决方法

    使用SpringSecurity+defaultSuccessUrl不跳转指定页面的问题解决方法

    本人是用springsecurity的新手,今天遇到defaultSuccessUrl不跳转指定页面的问题,真是头疼死了,网上找遍了解决方法都解决不了,今天给大家分享使用SpringSecurity+defaultSuccessUrl不跳转指定页面的问题解决方法,感兴趣的朋友一起看看吧
    2023-12-12
  • Spingboot JPA CriteriaBuilder 如何获取指定字段

    Spingboot JPA CriteriaBuilder 如何获取指定字段

    这篇文章 主要介绍了Spingboot JPA CriteriaBuilder 如何获取指定字段,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-12-12
  • Java Web项目中Spring框架处理JSON格式数据的方法

    Java Web项目中Spring框架处理JSON格式数据的方法

    Spring MVC是个灵活的框架,返回JSON数据的也有很多五花八门的方式,这里我们来整理一个最简单的Java Web项目中Spring框架处理JSON格式数据的方法:
    2016-05-05
  • SpringBoot使用thymeleaf实现一个前端表格方法详解

    SpringBoot使用thymeleaf实现一个前端表格方法详解

    Thymeleaf是一个现代的服务器端 Java 模板引擎,适用于 Web 和独立环境。Thymeleaf 的主要目标是为您的开发工作流程带来优雅的自然模板,本文就来用它实现一个前端表格,感兴趣的可以了解一下
    2022-10-10

最新评论