二叉树

public class BinaryTreeTest {
    public static void main(String[] args) {
        
        TreeNode root = new TreeNode(1,"A");
        TreeNode treeNode_2 = new TreeNode(2,"B");
        TreeNode treeNode_3 = new TreeNode(3,"C");
        TreeNode treeNode_4 = new TreeNode(4,"D");
        TreeNode treeNode_5 = new TreeNode(5,"E");
        TreeNode treeNode_6 = new TreeNode(6,"F");
        TreeNode treeNode_7 = new TreeNode(7,"G");
        root.setLeftNode(treeNode_2);
        root.setRightNode(treeNode_3);
        treeNode_2.setLeftNode(treeNode_4);
        treeNode_2.setRightNode(treeNode_5);
        treeNode_3.setLeftNode(treeNode_6);
        treeNode_5.setRightNode(treeNode_7);
        
        
        BinaryTree tree = new BinaryTree();
        int n = tree.getTreeHeight(root);
        System.out.println(n);
        
        int size = tree.getTreeSize(root);
        System.out.println(size);
        
        tree.preorderTraversal(root);
        System.out.println("递归中庿鿿历：");
        tree.middleTraversal(root);
        System.out.println();
        System.out.println("递归忎庿鿿历：");
        tree.subsequentTraversal(root);
        
        CreateCinaryTreeByStack treeByStack = new CreateCinaryTreeByStack();
        treeByStack.preOrder(root);
        System.out.println();
        System.out.println("栈，鿞递归中庿鿿历");
        treeByStack.middleOrderByStack(root);
        System.out.println();
        System.out.println("栈，鿞递归忎庿鿿历");
        treeByStack.lastOrder(root);
        
    }
}
//create binaryTree node
class TreeNode {
    private int index;
    private String data;
    private TreeNode leftNode;
    private TreeNode rightNode;
    private boolean isVisited;
    
    public TreeNode() {
        
    }
    
    public TreeNode(int index,String data) {
        this.data = data;
        this.index = index;
        this.leftNode = null;
        this.rightNode = null;
        this.isVisited = false;
    }
    
    public int getIndex() {
        return index;
    }

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

    public String getData() {
        return data;
    }

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

    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
    }
    
    public TreeNode getLeftNode() {
        return this.leftNode;
    }
    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
    }
    
    public TreeNode getRightNode() {
        return this.rightNode;
    }

    public boolean isVisited() {
        return isVisited;
    }

    public void setVisited(boolean isVisited) {
        this.isVisited = isVisited;
    }

    
    
    
    
}

class CreateCinaryTreeByStack {
    public void preOrder(TreeNode rootNode) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(rootNode);
        if(stack.empty()) {
            return;
        }
        while(!stack.empty()) {
            //pop rootNode
            rootNode = stack.pop();
            System.out.print(rootNode.getData()+"  ");
            //push childrenNode
            if(rootNode.getRightNode() != null) {
                stack.push(rootNode.getRightNode());
            }
            if(rootNode.getLeftNode() != null) {
                stack.push(rootNode.getLeftNode());
            }
            
        }
    }

    /**
     * 使用栈的数濮结构中庿鿿历二忉树**/
    public void middleOrderByStack(TreeNode rootNode) {
        if(rootNode == null) {
            return;
        }else {
            Stack<TreeNode> stack = new Stack<TreeNode>();
            stack.push(rootNode);
            while(!stack.isEmpty()) {
                if(rootNode.getLeftNode() != null) {
                    rootNode = stack.push(rootNode.getLeftNode());
                    
                    continue;
                }
                rootNode = stack.pop();
                System.out.print(rootNode.getData()+"  ");
                if(rootNode.getRightNode() != null) {
                    rootNode = stack.push(rootNode.getRightNode());
                    
                    continue;
                }
                
            }
        }
    }
    
    /**
     * 使用栈结构，忎庿鿿历二忉树**/
    public void lastOrder(TreeNode rootNode) {
        if(rootNode == null) {
            return;
        }else {
            Stack<TreeNode> stack = new Stack<TreeNode>();
            stack.push(rootNode);
            while(!stack.isEmpty()) {
                if(rootNode.getLeftNode() != null && rootNode.getLeftNode().isVisited() == false) {
                    rootNode = stack.push(rootNode.getLeftNode());
                    
                    continue;
                }
                if(rootNode.getRightNode() != null && rootNode.getRightNode().isVisited() == false) {
                    rootNode = stack.push(rootNode.getRightNode());
                    //rootNode.setVisited(true);
                    continue;
                }
                System.out.print(rootNode.getData()+"  ");
                rootNode.setVisited(true);
                rootNode = stack.pop();
                
                
            }
        }
        
    }
}
/**
（1）将根节点 push 入栈；

（2）当栈丿为空时，釿夿（3）到（5）的擿作：

（3）忷窥栈顶部节点，如果节点的左孿节点丿为 NULL，且没有被访问，则将其左孿节点 push 入栈，并跳到（3）。

（4）当被忷窥的节点没有左孿树，pop 该节点出栈，并访问它（忌时标记该节点为已访问状怿）。

（5）当该节点的忳孿节点丿为空，将其忳孿节点 push 入栈，并跳到（3）。

**/

//create binary tree
class BinaryTree {
    //preorder traversal
    public void  preorderTraversal(TreeNode rootNode) {
        if(rootNode == null) {
            //System.out.println("root doesn't allow null");
            return;
        }
        System.out.print(rootNode.getData()+"  ");
        preorderTraversal(rootNode.getLeftNode());
        preorderTraversal(rootNode.getRightNode());
    }
    
    //middle traversal
    public void middleTraversal(TreeNode rootNode) {
        if(rootNode == null) {
            return;
        }else {
            middleTraversal(rootNode.getLeftNode());
            System.out.print(rootNode.getData()+"  ");
            middleTraversal(rootNode.getRightNode());
        }
    }
    
    //subsequent traversal
    public void subsequentTraversal(TreeNode rootNode) {
        if(rootNode == null) {
            return;
        }else {
            subsequentTraversal(rootNode.getLeftNode());
            subsequentTraversal(rootNode.getRightNode());
            System.out.print(rootNode.getData()+"  ");
        //    if(rootNode.getData().equals("A")) {
        //        System.out.println(rootNode.getIndex());
        //    }
        }
        
    }
    
    //get tree height
    public int getTreeHeight(TreeNode rootNode) {
        if(rootNode == null) {
            return 0;
        }else {
            int i = getTreeHeight(rootNode.getLeftNode());
            int j = getTreeHeight(rootNode.getRightNode());
            return (i < j)?j+1:i+1;
        }
    }
    
    //get tree size
    public int getTreeSize(TreeNode rootNode) {
        if(rootNode == null) {
            return 0;
        }else {
            int size = getTreeSize(rootNode.getLeftNode()) 
                    + getTreeSize(rootNode.getRightNode()) 
                    + 1;
            return size;
        }
    }
    
    
}