二叉树BinaryTree

Java 实现二叉树的构造以及遍历过程

二叉树遍历(先序、中序、后序)

/*
 * John Han.
 * Copyright (c) 2019-2019　All Rights Reserved.
 */
package com.demo.service.structure.btree;

/*
 *
 * author: john.
 * version: Btree.java, v 0.1 2019年04月28日　下午11:32 Exp.
 */
public class BinaryTree {

  /**
   * 定义二叉树节点
   *
   * @param 
   */
  private class TreeNode {
    private int index;
    private T data;
    private TreeNode leftChild;
    private TreeNode rightChild;

    public TreeNode(int index, T data) {
      this.index = index;
      this.data = data;
      this.leftChild = null;
      this.rightChild = null;
    }

    public int getIndex() {
      return index;
    }

    public void setIndex(int index) {
      this.index = index;
    }

    public T getData() {
      return data;
    }

    public void setData(T data) {
      this.data = data;
    }

    public TreeNode getLeftChild() {
      return leftChild;
    }

    public void setLeftChild(TreeNode leftChild) {
      this.leftChild = leftChild;
    }

    public TreeNode getRightChild() {
      return rightChild;
    }

    public void setRightChild(TreeNode rightChild) {
      this.rightChild = rightChild;
    }
  }

  // 二叉树的构建首先需要跟节点，一般在构造方法里面创建
  public static TreeNode root = null;

  /** 构造函数，初始化根节点 */
  public BinaryTree() {
    root = new TreeNode(1, "A");
  }

  /** 创建二叉树 */
  public void createBinaryTree() {
    TreeNode nodeB = new TreeNode(1, "B");
    TreeNode nodeC = new TreeNode(1, "C");
    TreeNode nodeD = new TreeNode(1, "D");
    TreeNode nodeE = new TreeNode(1, "E");
    TreeNode nodeF = new TreeNode(1, "F");
    TreeNode nodeG = new TreeNode(1, "G");
    root.leftChild = nodeB;
    root.rightChild = nodeC;
    nodeB.leftChild = nodeD;
    nodeB.rightChild = nodeE;
    nodeC.leftChild = nodeF;
    nodeC.rightChild = nodeG;
  }

  /**
   * 获取树高度
   *
   * @return
   */
  public int getHeight() {
    return getHeight(root);
  }

  public int getHeight(TreeNode node) {
    if (node == null) {
      return 0;
    }
    int leftHeight = getHeight(node.leftChild);
    int rightHeight = getHeight(node.rightChild);
    return leftHeight > rightHeight ? (leftHeight + 1) : (rightHeight + 1);
  }

  public int getSize() {
    return getSize(root);
  }

  /**
   * 获取节点数
   *
   * @param node
   * @return
   */
  public int getSize(TreeNode node) {
    if (node == null) {
      return 0;
    }
    int leftSize = getSize(node.leftChild);
    int rightSize = getSize(node.rightChild);
    return leftSize + rightSize + 1;
  }

  /**
   * 先续遍历
   *
   * @param node
   */
  public void beforeOrder(TreeNode node) {
    if (node == null) {
      return;
    }
    System.out.print(node.getData() + " ");
    beforeOrder(node.leftChild);
    beforeOrder(node.rightChild);
  }

  /**
   * 中序遍历
   *
   * @param node
   */
  public void midOrder(TreeNode node) {
    if (node == null) {
      return;
    }
    midOrder(node.leftChild);
    System.out.print(node.getData() + " ");
    midOrder(node.rightChild);
  }

  /**
   * 后续遍历
   *
   * @param node
   */
  public void afterOrder(TreeNode node) {
    if (node == null) {
      return;
    }
    afterOrder(node.leftChild);
    afterOrder(node.rightChild);
    System.out.print(node.getData() + " ");
  }

  public static void main(String[] args) {
    BinaryTree binaryTree = new BinaryTree();
    binaryTree.createBinaryTree();
    int height = binaryTree.getHeight();
    System.out.println("tree height: " + height);
    int size = binaryTree.getSize();
    System.out.println("tree size: " + size);

    System.out.println("先序遍历：");
    binaryTree.beforeOrder(root);
    System.out.println("\n中序遍历：");
    binaryTree.midOrder(root);
    System.out.println("\n后序遍历：");
    binaryTree.afterOrder(root);
  }
}