二叉树的遍历(traversing binary tree)是指从根节点出发,按照某种次序依次访问二叉树中所有节点,使得每个节点仅被访问一次

前序遍历:若二叉树为空,则空操作返回null。否则先访问根节点,然后前序遍历左子树,再前序遍历右子树

中序遍历:若二叉树为空,则空操作返回null。否则从根节点开始,中序遍历根节点左子树,然后访问根节点,最后中序遍历右子树

后序遍历:若二叉树为空,则空操作返回null。否则以从左到右先叶子后节点的方式遍历访问左右子树,最后访问根节点

层序遍历:若树为空,空操作返回null。否则从树的第一层,也就是根节点开始访问,从上而下逐层遍历,在同一层中,从左到右对结点逐个访问

com

└── rust

└── datastruct

├── BinaryTree.java

└── TestBinaryTree.java

二叉树用一个类来实现,并包含内部类节点

以下是Java代码:

 package com.rust.datastruct;

 public class BinaryTree {
     private int BinaryNodeCount = 0;
     BinaryNode root;
     public BinaryTree(){}

     public BinaryNode createRoot(){
         return createRoot(1,null);
     }
     public BinaryNode createRoot(int key,String data){
         BinaryNode root = new BinaryNode(key, data);
         this.root = root;
         return root;
     }

     public BinaryNode createNode(int key,String data){
         return new BinaryNode(key,data);
     }
     public int getNodeCount(){
         return BinaryNodeCount;
     }
     public BinaryNode getRoot(){
         return root;
     }
     public void visitNode(BinaryNode node){
         if (node == null) {
             return ;
         }
         node.setVisited(true);
         System.out.print(node.getData());
     }
     // 前序遍历
     public void preOrderTravels(BinaryNode node) {
         if (node == null) {
             return;
         } else {
             BinaryNodeCount++;
             visitNode(node);
             preOrderTravels(node.leftChild);
             preOrderTravels(node.rightChild);
         }
     }
     // 中序遍历
     public void midOrderTravels(BinaryNode node) {
         if (node == null) {
             return;
         } else {
             BinaryNodeCount++;
             midOrderTravels(node.leftChild);
             visitNode(node);
             midOrderTravels(node.rightChild);
         }
     }
     // 后序遍历
     public void postOrderTravels(BinaryNode node) {
         if (node == null) {
             return;
         } else {
             BinaryNodeCount++;
             postOrderTravels(node.leftChild);
             postOrderTravels(node.rightChild);
             visitNode(node);
         }
     }  

     class BinaryNode{
         private int key;
         private String data;
         private BinaryNode leftChild = null;
         private BinaryNode rightChild = null;
         private boolean isVisited = false;

         public int getKey() {
             return key;
         }
         public void setKey(int key) {
             this.key = key;
         }
         public String getData() {
             return data;
         }
         public void setData(String data) {
             this.data = data;
         }
         public BinaryNode getLeftChild() {
             return leftChild;
         }
         public void setLeftChild(BinaryNode leftChild) {
             this.leftChild = leftChild;
         }
         public BinaryNode getRightChild() {
             return rightChild;
         }
         public void setRightChild(BinaryNode rightChild) {
             this.rightChild = rightChild;
         }
         public boolean isVisited() {
             return isVisited;
         }
         public void setVisited(boolean isVisited) {
             this.isVisited = isVisited;
         }
         public BinaryNode(){

         }
         public BinaryNode(int key, String data){
             this.key = key;
             this.data = data;
             this.leftChild = null;
             this.rightChild = null;
         }
     }

 }

里面内置前序遍历、中序遍历和后序遍历三种方法

 package com.rust.datastruct;

 import com.rust.datastruct.BinaryTree.BinaryNode;

 public class TestBinaryTree {

     public static void main(String args[]){
         BinaryTree bt = new BinaryTree();
         initTree(bt, 1, "A");
         System.out.println("********preOrderTravels********");
         bt.preOrderTravels(bt.root);
         System.out.println();
         System.out.println("********midOrderTravels********");
         bt.midOrderTravels(bt.root);
         System.out.println();
         System.out.println("********postOrderTravels********");
         bt.postOrderTravels(bt.root);
     }
     /**
      *               A
      *        B            C
      *    D     E      F     G
      * H   I  J
      * @param bt 输入一个二叉树对象,定义一个根结点
      * @param rootKey
      * @param rootData
      */
     public static void initTree(BinaryTree bt,int rootKey, String rootData){
         BinaryNode root = bt.createRoot(rootKey, rootData);
         BinaryNode nodeB = bt.createNode(2, "B");
         BinaryNode nodeC = bt.createNode(3, "C");
         BinaryNode nodeD = bt.createNode(4, "D");
         BinaryNode nodeE = bt.createNode(5, "E");
         BinaryNode nodeF = bt.createNode(6, "F");
         BinaryNode nodeG = bt.createNode(7, "G");
         BinaryNode nodeH = bt.createNode(8, "H");
         BinaryNode nodeI = bt.createNode(9, "I");
         BinaryNode nodeJ = bt.createNode(10, "J");
         root.setLeftChild(nodeB);
         root.setRightChild(nodeC);
         nodeB.setLeftChild(nodeD);
         nodeB.setRightChild(nodeE);
         nodeC.setLeftChild(nodeF);
         nodeC.setRightChild(nodeG);
         nodeD.setLeftChild(nodeH);
         nodeD.setRightChild(nodeI);
         nodeE.setRightChild(nodeJ);
     }
 }

输出:

********preOrderTravels********

ABDHIEJCFG

********midOrderTravels********

HDIBEJAFCG

********postOrderTravels********

HIDJEBFGCA

·树,森林和二叉树

#树转换为二叉树

1.加线,在所有兄弟节点之间加一条线

2.去线,对树中每一个节点,只保留它与第一个孩子结点的连线,删除它与其它孩子节点之间的连线

3.层次调整。以树的根节点为轴心,将整棵树顺时针旋转一定的角度,使其结构分明

#森林转换为二叉树

1.把每棵树转换为二叉树

2.第一棵二叉树不动,从第二棵二叉树开始,依次把后一棵二叉树的根节点作为前一棵二叉树的根节点的右孩子,

用线连起来。当所有的二叉树连接起来后就得到了由森林转换来的二叉树。

#二叉树转换为树

右孩子都跨一层连接上去,删掉二叉树右孩子的连线

#二叉树转换为森林

逐层删掉右孩子的连线

二叉树 - 建立与遍历使用Java的更多相关文章

  1. 二叉树建立,遍历和二叉排序树的判断【c++】

    // test.cpp : Defines the entry point for the console application. // #include "stdafx.h" ...

  2. 二叉树的层次遍历(Java代码实现)

    与树的前中后序遍历的DFS思想不同,层次遍历用到的是BFS思想.一般DFS用递归去实现(也可以用栈实现),BFS需要用队列去实现. 层次遍历的步骤是: 1.对于不为空的结点,先把该结点加入到队列中 2 ...

  3. 二叉树建立及遍历 C++ 源码

    #define _CRT_SECURE_NO_WARNINGS #include<iostream> #include <stdlib.h> using namespace s ...

  4. 数据结构二叉树的递归与非递归遍历之java,javascript,php实现可编译(1)java

    前一段时间,学习数据结构的各种算法,概念不难理解,只是被C++的指针给弄的犯糊涂,于是用java,web,javascript,分别去实现数据结构的各种算法. 二叉树的遍历,本分享只是以二叉树中的先序 ...

  5. Java实现二叉树及相关遍历方式

    Java实现二叉树及相关遍历方式 在计算机科学中.二叉树是每一个节点最多有两个子树的树结构.通常子树被称作"左子树"(left subtree)和"右子树"(r ...

  6. 数据结构代码整理(线性表,栈,队列,串,二叉树,图的建立和遍历stl,最小生成树prim算法)。。持续更新中。。。

    //归并排序递归方法实现 #include <iostream> #include <cstdio> using namespace std; #define maxn 100 ...

  7. C语言二叉树的建立与遍历

    二叉树的建立和遍历都要用到递归,先暂时保存一下代码,其中主要是理解递归的思想,其它的就都好理解了.这里是三种遍历方式,其实理解一种,其它的几个就都理解了,就是打印出来的顺序不一样而已.建立和遍历的方式 ...

  8. 二叉树3种递归和非递归遍历(Java)

    import java.util.Stack; //二叉树3种递归和非递归遍历(Java) public class Traverse { /******************一二进制树的定义*** ...

  9. 二叉树遍历(Java实现)

    二叉树遍历(Java实现)   主要是二叉树的遍历,包括递归遍历和非递归遍历 import java.util.ArrayDeque; import java.util.ArrayList; impo ...

随机推荐

  1. (整理)使用tomcat搭建HTTP文件下载服务器

    本文是整理,非原创,由网络资料组成上自己踩的坑整理而成. 1. 假设需要下载的文件目录是D:\download1(注意这里写了个1,跟后面的名称区分) 2. 设置 tomcat 的虚拟目录.在 {to ...

  2. openvpn实现内网 映射到 外网

    openvpn实现内网 映射到 外网 场景介绍: 机器介绍 本地一台Ubuntu服务器A , 处于内网中 , 无外网IP 外网一台Ubuntu服务器B , 外网地址139.199.4.205 目标 : ...

  3. AppServ安装的一点小麻烦----

    好久,没装AppServ了,今天安装过程顺利,但是Apache,服务开启不了,页面也不能访问. 刚开始以为是版本下载错误了,先后换了N个版本,都不行. 在网上搜的过程中,偶然发现,一句话:64位系统, ...

  4. Bash中的特殊变量和位置参量

    位置参量:向脚本或函数传递的参数,可以被set命令设置.重置和清空. 1.$$ 当前Shell的PID 2.$- 当前Shell的选项,如果是交互式shell,应该包含字符i,例如$ echo $-h ...

  5. EntityFramework Core迁移时出现数据库已存在对象问题解决方案

    前言 刚开始接触EF Core时本着探索的精神去搞,搞着搞着发现出问题了,后来就一直没解决,觉得很是不爽,借着周末好好看看这块内容. EntityFramework Core迁移出现对象在数据库中已存 ...

  6. 表单格式化插件jquery.serializeJSON

    前言 前端在处理含有大量数据提交的表单时,除了使用Form直接提交刷新页面之外,经常碰到的需求是收集表单信息成数据对象,Ajax提交. 而在处理复杂的表单时,需要一个一个区手动判断处理字段值,显得非常 ...

  7. mysql left join

    MySQL左连接不同于简单连接.MySQL LEFT JOIN提供该表额外字段在左侧. 如果使用LEFT JOIN,得到的所有记录的匹配方式相同, 在左边表中得到的每个记录不匹配也会有一个额外的记录. ...

  8. 搭建es6开发与非开发环境babel-browser

    前言 最近打算把es6应用到项目中,但是如何在开发环境(浏览器端)直接运行es6?es6已经发布一段时间了,现在大部分是在node.js环境运行,或者通过babel编译之后运行.babel-brows ...

  9. C++函数重载实现的原理以及为什么在C++中使用用C语言编译的函数时,要在函数名称前面加上extern "C"声明

    C++相对于C语言而言支持函数重载是其极大的一个特点,相信在使用C语言的时候大家如果要写一个实现两个整型数据相加的函数还要写一个浮点型数据相加的函数,那么这两个函数的名字绝对不可以一样,这样无疑在我们 ...

  10. ng-cordova(插件库)

    ng-cordova 环境配置 1.执行以下命令 bower install ngCordova 2.引用文件(在引用cordova.js之前引用) <script src="lib/ ...