1. public class BinaryTree {
    2.     private TreeNode  root = null;
    4.     public BinaryTree(){
    5.         root = new TreeNode(1, "A");
    6.     }
    8.     public class TreeNode{
    9.         private int index;
    10.         private String data;
    11.         private TreeNode leftChild;
    12.         private TreeNode rightChild;
    15.         public int getIndex() {
    16.             return index;
    17.         }
    20.         public void setIndex(int index) {
    21.             this.index = index;
    22.         }
    25.         public String getData() {
    26.             return data;
    27.         }
    30.         public void setData(String data) {
    31.             this.data = data;
    32.         }
    35.         public TreeNode(int index,String data){
    36.             this.index = index;
    37.             this.data = data;
    38.             this.leftChild = null;
    39.             this.rightChild = null;
    40.         }
    41.     }
    43.     /**
    44.      * 构建二叉树
    45.      *         A
    46.      *     B       C
    47.      * D      E        F
    48.      */
    49.     public void createBinaryTree(){
    50.         TreeNode nodeB = new TreeNode(2, "B");
    51.         TreeNode nodeC = new TreeNode(3, "C");
    52.         TreeNode nodeD = new TreeNode(4, "D");
    53.         TreeNode nodeE = new TreeNode(5, "E");
    54.         TreeNode nodeF = new TreeNode(6, "F");
    55.         root.leftChild = nodeB;
    56.         root.rightChild = nodeC;
    57.         nodeB.leftChild = nodeD;
    58.         nodeB.rightChild = nodeE;
    59.         nodeC.rightChild = nodeF;
    60.     }
    62.     /**
    63.      * 求二叉树的高度
    64.      * @author smallkong
    65.      *
    66.      */
    67.     public int getHeight(){
    68.         return getHeight(root);
    69.     }
    71.     private int getHeight(TreeNode node) {
    72.         if(node == null){
    73.             return 0;
    74.         }else{
    75.             int i = getHeight(node.leftChild);
    76.             int j = getHeight(node.rightChild);
    77.             return (i<j)?j+1:i+1;
    78.         }
    79.     }
    81.     /**
    82.      * 获取二叉树的结点数
    83.      * @author smallkong
    84.      *
    85.      */
    86.     public int getSize(){
    87.         return getSize(root);
    88.     }
    91.     private int getSize(TreeNode node) {
    92.         if(node == null){
    93.             return 0;
    94.         }else{
    95.             return 1+getSize(node.leftChild)+getSize(node.rightChild);
    96.         }
    97.     }
    99.     /**
    100.      * 前序遍历——递归
    101.      * @author smallkong
    102.      *
    103.      */
    104.     public void preOrder(TreeNode node){
    105.         if(node == null){
    106.             return;
    107.         }else{
    108.             System.out.print(node.getData());
    109.             preOrder(node.leftChild);
    110.             preOrder(node.rightChild);
    111.         }
    112.     }
    114.     /**
    115.      * 前序遍历——非递归
    116.      */
    118.     public void nonRecOrder(TreeNode node){
    119.         if(node == null){
    120.             return;
    121.         }
    122.         Stack<TreeNode> stack = new Stack<TreeNode>();
    123.         stack.push(node);
    124.         while(!stack.isEmpty()){
    125.             //出栈和进栈
    126.             TreeNode n = stack.pop();//弹出根结点
    127.             //压入子结点
    128.             System.out.print(n.getData());
    129.             if(n.rightChild!=null){
    130.                 stack.push(n.rightChild);
    132.             }
    133.             if(n.leftChild!=null){
    134.                 stack.push(n.leftChild);
    135.             }
    136.         }
    137.     }
    138.     /**
    139.      * 中序遍历——递归
    140.      * @author smallkong
    141.      *
    142.      */
    143.     public void midOrder(TreeNode node){
    144.         if(node == null){
    145.             return;
    146.         }else{
    147.             midOrder(node.leftChild);
    148.             System.out.print(node.getData());
    149.             midOrder(node.rightChild);
    150.         }
    151.     }
    153.     /**
    154.      * 后序遍历——递归
    155.      * @author smallkong
    156.      *
    157.      */
    158.     public void postOrder(TreeNode node){
    159.         if(node == null){
    160.             return;
    161.         }else{
    162.             postOrder(node.leftChild);
    163.             postOrder(node.rightChild);
    164.             System.out.print(node.getData());
    165.         }
    166.     }
    169.     public static void main(String[] args){
    170.         BinaryTree binaryTree = new BinaryTree();
    171.         binaryTree.createBinaryTree();
    173.         int height = binaryTree.getHeight();
    174.         System.out.println("树的高度treeHeihgt:"+height);
    176.         int size = binaryTree.getSize();
    177.         System.out.println("结点数treeSize:"+size);
    179.         System.out.print("前序preOrder data:");
    180.         binaryTree.preOrder(binaryTree.root);
    182.         System.out.print("\n中序midOrder data:");
    183.         binaryTree.midOrder(binaryTree.root);
    185.         System.out.print("\n后序postOrder data:");
    186.         binaryTree.postOrder(binaryTree.root);
    188.         System.out.print("\n前序非递归preOrder data:");
    189.         binaryTree.nonRecOrder(binaryTree.root);
    190.     }
    191. }

    image.png