一、分析

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

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

二、代码

  1 package com.algorithms.treee;
  2 
  3 /**
  4  * 二叉树
  5  */
  6 public class BinaryTree
  7 {
  8     private TreeNode root;// 根节点
  9 
 10     public BinaryTree()
 11     {
 12     }
 13 
 14     public BinaryTree(TreeNode root)
 15     {
 16         this.root = root;
 17     }
 18 
 19     public TreeNode getRoot()
 20     {
 21         return root;
 22     }
 23 
 24     public void setRoot(TreeNode root)
 25     {
 26         this.root = root;
 27     }
 28 
 29     /**
 30      * 定义节点
 31      */
 32     private static class TreeNode
 33     {
 34         private String data = null;// 数据部分
 35         private TreeNode left;// 左节点的引用
 36         private TreeNode right;// 右节点的引用
 37 
 38         public TreeNode()
 39         {
 40         }
 41 
 42         public TreeNode(String data, TreeNode left, TreeNode right)
 43         {
 44             this.data = data;
 45             this.left = left;
 46             this.right = right;
 47         }
 48 
 49         public String getData()
 50         {
 51             return data;
 52         }
 53 
 54         public void setData(String data)
 55         {
 56             this.data = data;
 57         }
 58 
 59         public TreeNode getLeft()
 60         {
 61             return left;
 62         }
 63 
 64         public void setLeft(TreeNode left)
 65         {
 66             this.left = left;
 67         }
 68 
 69         public TreeNode getRight()
 70         {
 71             return right;
 72         }
 73 
 74         public void setRight(TreeNode right)
 75         {
 76             this.right = right;
 77         }
 78 
 79     }
 80 
 81     /**
 82      * 返回父结点
 83      * 
 84      * @param element
 85      * @return
 86      */
 87     public TreeNode getParent(TreeNode element)
 88     {
 89         return (root == null || root == element) ? null : parent(root, element);
 90     }
 91 
 92     public TreeNode parent(TreeNode subTree, TreeNode element)
 93     {
 94         if (subTree == null)
 95             return null;
 96         if (subTree.getLeft() == element || subTree.getRight() == element)
 97             // 返回父结点地址
 98             return subTree;
 99         TreeNode p;
100         // 现在左子树中找，如果左子树中没有找到，才到右子树去找
101         if ((p = parent(subTree.getLeft(), element)) != null)
102             // 递归在左子树中搜索
103             return p;
104         else
105             // 递归在右子树中搜索
106             return parent(subTree.getRight(), element);
107     }
108 
109     /**
110      * 节点个数
111      * 
112      * @return
113      */
114     public int getSize()
115     {
116         return getNum(root);
117     }
118 
119     private int getNum(TreeNode node)
120     {
121         if (node == null)
122         {
123             return 0;
124         }
125         else
126         {
127             int i = getNum(node.getLeft());
128             int j = getNum(node.getRight());
129             return j + i + 1;
130         }
131     }
132 
133     /**
134      * 树高度
135      * 
136      * @return
137      */
138     public int getHeight()
139     {
140         return getHeight(root);
141     }
142 
143     private int getHeight(TreeNode node)
144     {
145         if (node == null)
146             return 0;// 递归结束：空树高度为0
147         else
148         {
149             int i = getHeight(node.getLeft());
150             int j = getHeight(node.getRight());
151             return (i < j) ? (j + 1) : (i + 1);
152         }
153     }
154 
155     /**
156      * 前序遍历
157      * 
158      * @param node
159      */
160     public void preOrder(TreeNode node)
161     {
162         if (node != null)
163         {
164             System.out.println(node.getData());
165             preOrder(node.getLeft());
166             preOrder(node.getRight());
167         }
168     }
169 
170     /**
171      * 中序遍历
172      * 
173      * @param node
174      */
175     public void inOrder(TreeNode node)
176     {
177         if (node != null)
178         {
179             inOrder(node.getLeft());
180             System.out.println(node.getData());
181             inOrder(node.getRight());
182         }
183     }
184 
185     /**
186      * 后续遍历
187      * 
188      * @param node
189      */
190     public void postOrder(TreeNode node)
191     {
192         if (node != null)
193         {
194             postOrder(node.getLeft());
195             postOrder(node.getRight());
196             System.out.println(node.getData());
197         }
198     }
199 
200     public static void main(String[] args)
201     {
202 
203         TreeNode l12 = new TreeNode("left12", null, null);
204         TreeNode r12 = new TreeNode("right12", null, null);
205         TreeNode l22 = new TreeNode("left22", null, null);
206         TreeNode r22 = new TreeNode("right22", null, null);
207 
208         TreeNode l1 = new TreeNode("left1", l12, r12);// 根节点左子树
209         TreeNode r1 = new TreeNode("right1", l22, r22);// 根节点右子树
210         TreeNode root = new TreeNode("root", l1, r1);// 创建根节点
211 
212         BinaryTree bt = new BinaryTree(root);
213         System.out.println("=======先序遍历======");
214         bt.preOrder(bt.getRoot());
215         System.out.println("=======中序遍历======");
216         bt.inOrder(bt.getRoot());
217         System.out.println("========后续遍历=======");
218         bt.postOrder(bt.getRoot());
219         System.out.println("===========");
220         System.out.println(bt.getHeight());
221         System.out.println(bt.getSize());
222 
223         System.out.println(bt.getParent(r22).getData());
224     }
225 }