最近应用开发的过程中出现了一个小问题，顺便记录一下原因和方法--二叉树遍历

    

        定义

                    二叉树：在数据结构中，二叉树是每一个节点最多有两个子树的树结构。常通子树被称作为

             “左子树”和右子树。二叉树常通被用于现实二叉查找树和二叉堆。

    

        特色

                  二叉树的每一个节点最多只有两颗子树（不存在度大于2的结点），要需注意的是二叉树的子树

             是有阁下之分的，序次不能倒颠。其第i层最多有个结点；深度为k的二叉树最多有

             个结点；对于意任一颗二叉树T，如果其叶子结点树为n0,度为2的结点树为n2，则n0=n2 + 2(根结

             点除外)。

                          二叉树遍历二叉树的实现及先序、中序、后序遍历_结点

    

         存储表现

                  二叉树可以应用数组或者序顺表来表现，种这现实方法更有利于紧凑的存储和更好的拜访

             局部性，但是他要需续连的存储空间，在极端的况情下，如果一颗二叉树只有右子树，那么空

             间的糟蹋将会异常的严峻。

                  二叉树还可以应用表链的存储方法来现实，这也是推荐的现实方法。在Java中体具的树节点

             的体具表现况情如下：

class TreeNode<T> {
    private T data;
    private TreeNode<T> leftNode;
    private TreeNode<T> rightNode;

    public TreeNode(T data, TreeNode<T> leftNode, TreeNode<T> rightNode) {
      this.data = data;
      this.leftNode = leftNode;
      this.rightNode = rightNode;
    }
}


              对于二叉树的体具作操笔者不会去具体的现实，感兴趣的是二叉树的遍历方法。

    

         二叉树的遍历

                    对于二叉树的遍历方法一般分为三种先序、中序、后序三种方法

    

                 先序遍历

                  若二叉树为空，则不行进任何作操：否则

                       1、拜访根结点。

                       2、先序方法遍历左子树。

                       3、先序遍历右子树。

    

                中序遍历

                  若二叉树为空，则不行进任何作操：否则

                       1、中序遍历左子树。

                       2、拜访根结点。

                       3、中序遍历右子树。

    

               后序遍历

                  若二叉树为空，则不行进任何作操：否则

                       1、后序遍历左子树。

                       2、后序遍历右子树。

                       3、放问根结点。

               遍历的况情如下：

                 二叉树遍历二叉树的实现及先序、中序、后序遍历_中序遍历_02

                二叉树遍历的码代现实：


    每日一道理

青春，有嬉笑声与哭泣声夹杂的年华，青春的少年是蓝天中翱翔的幼鹰，虽然没有完全长大，有些稚气，有些懵懂，脱不开父母的双手却极力想去找寻属于自己的一片天空，为的是一时的激情，为的是一种独自翱翔的感觉！

package com.kiritor;

/**
 * Java二叉树的现实 以及遍历
 * 
 * @author Kiritor
 */
public class BinaryTree {

  /**
   * 出输结点信息*/
  public void printNode(TreeNode<String> node)
  {
    System.out.print(node.getData()+"  ");
  }
  /**
   * 定义结点
   * */
  class TreeNode<T> {
    private T data;
    private TreeNode<T> leftNode;
    private TreeNode<T> rightNode;

    public TreeNode(T data, TreeNode<T> leftNode, TreeNode<T> rightNode) {
      this.data = data;
      this.leftNode = leftNode;
      this.rightNode = rightNode;
    }


    public T getData() {
      return data;
    }

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

    public TreeNode<T> getLeftNode() {
      return leftNode;
    }

    public void setLeftNode(TreeNode<T> leftNode) {
      this.leftNode = leftNode;
    }

    public TreeNode<T> getRightNode() {
      return rightNode;
    }

    public void setRightNode(TreeNode<T> rightNode) {
      this.rightNode = rightNode;
    }

  }

  // 初始化二叉树
  public TreeNode<String> init() {
    TreeNode<String> D = new TreeNode<String>("D", null, null);
    TreeNode<String> H = new TreeNode<String>("H", null, null);
    TreeNode<String> I = new TreeNode<String>("I", null, null);
    TreeNode<String> J = new TreeNode<String>("J", null, null);
    TreeNode<String> P = new TreeNode<String>("P", null, null);
    TreeNode<String> G = new TreeNode<String>("G", P, null);
    TreeNode<String> F = new TreeNode<String>("F", null, J);
    TreeNode<String> E = new TreeNode<String>("E", H, I);
    TreeNode<String> B = new TreeNode<String>("B", D, E);
    TreeNode<String> C = new TreeNode<String>("C", F, G);
    TreeNode<String> A = new TreeNode<String>("A", B, C);
    return A;
  }
  /**先序遍历二叉树
   * */
  public void xianIterator(TreeNode<String> node)
  {
    this.printNode(node);
    if(node.getLeftNode()!=null)
    {
      this.xianIterator(node.getLeftNode());
    }
    if(node.getRightNode()!=null)
    {
      this.xianIterator(node.getRightNode());
    }
  }

  /**
   * 中序遍历二叉树*/
  public void zhongIterator(TreeNode<String> node)
  {
    if(node.getLeftNode()!=null)
    {
      this.zhongIterator(node.getLeftNode());
    }
    this.printNode(node);
    if(node.getRightNode()!=null)
    {
      this.zhongIterator(node.getRightNode());
    }
  }

  /**后序遍历二叉树*/
  public void houIterator(TreeNode<String> node)
  {
    if(node.getLeftNode()!=null)
    {
      this.houIterator(node.getLeftNode());
    }
    if(node.getRightNode()!=null)
    {
      this.houIterator(node.getRightNode());
    }
    this.printNode(node);
  }

  public static void main(String[] args) {
     BinaryTree binaryTree = new BinaryTree();
     TreeNode<String> node = binaryTree.init();
     System.out.println("先序遍历的况情");
     binaryTree.xianIterator(node);
     System.out.println("\n中序遍历的况情");
     binaryTree.zhongIterator(node);
     System.out.println("\n后序遍历的况情");
     binaryTree.houIterator(node);
  }

}


                  

    二叉树遍历二叉树的实现及先序、中序、后序遍历_二叉树_03