二叉树的java实现

一、分析

　　一个二叉树节点有三个部分，一个是指向左子树的部分，一个是指向右子树的部分，另外一个是数据部分。可以把这个节点抽象成一个节点对象，给对象有两个节点对象属性和一个数据属性。如下图：

　　一个二叉树有只有一个根节点，其余的都是根节点的直接或间接子节点。所以可以把二叉树抽象成一个对象，该对象有一个节点类型的数据，也就是用来保存根节点。如下图：

二、代码

 package com.algorithms.treee;

 /**
  * 二叉树
  */
 public class BinaryTree
 {
     private TreeNode root;// 根节点

     public BinaryTree()
     {
     }

     public BinaryTree(TreeNode root)
     {
         this.root = root;
     }

     public TreeNode getRoot()
     {
         return root;
     }

     public void setRoot(TreeNode root)
     {
         this.root = root;
     }

     /**
      * 定义节点
      */
     private static class TreeNode
     {
         private String data = null;// 数据部分
         private TreeNode left;// 左节点的引用
         private TreeNode right;// 右节点的引用

         public TreeNode()
         {
         }

         public TreeNode(String data, TreeNode left, TreeNode right)
         {
             this.data = data;
             this.left = left;
             this.right = right;
         }

         public String getData()
         {
             return data;
         }

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

         public TreeNode getLeft()
         {
             return left;
         }

         public void setLeft(TreeNode left)
         {
             this.left = left;
         }

         public TreeNode getRight()
         {
             return right;
         }

         public void setRight(TreeNode right)
         {
             this.right = right;
         }

     }

     /**
      * 返回父结点
      *
      * @param element
      * @return
      */
     public TreeNode getParent(TreeNode element)
     {
         return (root == null || root == element) ? null : parent(root, element);
     }

     public TreeNode parent(TreeNode subTree, TreeNode element)
     {
         if (subTree == null)
             return null;
         if (subTree.getLeft() == element || subTree.getRight() == element)
             // 返回父结点地址
             return subTree;
         TreeNode p;
         // 现在左子树中找，如果左子树中没有找到，才到右子树去找
         if ((p = parent(subTree.getLeft(), element)) != null)
             // 递归在左子树中搜索
             return p;
         else
             // 递归在右子树中搜索
             return parent(subTree.getRight(), element);
     }

     /**
      * 节点个数
      *
      * @return
      */
     public int getSize()
     {
         return getNum(root);
     }

     private int getNum(TreeNode node)
     {
         if (node == null)
         {
             return 0;
         }
         else
         {
             int i = getNum(node.getLeft());
             int j = getNum(node.getRight());
             return j + i + 1;
         }
     }

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

     private int getHeight(TreeNode node)
     {
         if (node == null)
             return 0;// 递归结束：空树高度为0
         else
         {
             int i = getHeight(node.getLeft());
             int j = getHeight(node.getRight());
             return (i < j) ? (j + 1) : (i + 1);
         }
     }

     /**
      * 前序遍历
      *
      * @param node
      */
     public void preOrder(TreeNode node)
     {
         if (node != null)
         {
             System.out.println(node.getData());
             preOrder(node.getLeft());
             preOrder(node.getRight());
         }
     }

     /**
      * 中序遍历
      *
      * @param node
      */
     public void inOrder(TreeNode node)
     {
         if (node != null)
         {
             inOrder(node.getLeft());
             System.out.println(node.getData());
             inOrder(node.getRight());
         }
     }

     /**
      * 后续遍历
      *
      * @param node
      */
     public void postOrder(TreeNode node)
     {
         if (node != null)
         {
             postOrder(node.getLeft());
             postOrder(node.getRight());
             System.out.println(node.getData());
         }
     }

     public static void main(String[] args)
     {

         TreeNode l12 = new TreeNode("left12", null, null);
         TreeNode r12 = new TreeNode("right12", null, null);
         TreeNode l22 = new TreeNode("left22", null, null);
         TreeNode r22 = new TreeNode("right22", null, null);

         TreeNode l1 = new TreeNode("left1", l12, r12);// 根节点左子树
         TreeNode r1 = new TreeNode("right1", l22, r22);// 根节点右子树
         TreeNode root = new TreeNode("root", l1, r1);// 创建根节点

         BinaryTree bt = new BinaryTree(root);
         System.out.println("=======先序遍历======");
         bt.preOrder(bt.getRoot());
         System.out.println("=======中序遍历======");
         bt.inOrder(bt.getRoot());
         System.out.println("========后续遍历=======");
         bt.postOrder(bt.getRoot());
         System.out.println("===========");
         System.out.println(bt.getHeight());
         System.out.println(bt.getSize());

         System.out.println(bt.getParent(r22).getData());
     }
 }