二叉树(四)——完整代码（java版）

class BinaryTreeTest{    public static void main(String[] args){        TreeNode<String> right12 = new TreeNode<String>("G", null, null);        TreeNode<String> left1 = new TreeNode<String>("D", null, right12);        TreeNode<String> left2 = new TreeNode<String>("E", null, null);        TreeNode<String> right2 = new TreeNode<String>("F", null, null);        TreeNode<String> left = new TreeNode<String>("B", left1, null);   // 根节点左子树        TreeNode<String> right = new TreeNode<String>("C", left2, right2);  // 根节点右子树        TreeNode<String> root = new TreeNode<String>("A", left,right);      // 创建根节点        //完成二叉树的构建        BinaryTree bt1 = new BinaryTree(root);        System.out.println("=======递归先序遍历======");        bt1.preOrder(bt1.getRoot());        System.out.println("=======非递归先序遍历======");        bt1.preOrder1(bt1.getRoot());        System.out.println("=======递归中序遍历======");        bt1.inOrder(bt1.getRoot());        System.out.println("=======非递归中序遍历======");        bt1.inOrder1(bt1.getRoot());        System.out.println("========递归后续遍历=======");        bt1.postOrder(bt1.getRoot());               System.out.println("========非递归后续遍历=======");        bt1.postOrder1(bt1.getRoot());        System.out.println("===========");        System.out.println("结点个数为："+bt1.getSize(bt1.getRoot()));         System.out.println("二叉树的高度为："+bt1.getHeight());         System.out.println("G的父节点为："+bt1.getParent(right2).getData());        String[] preorder = {"A","B","D","G","C","E","F"};        String[] inorder1 = {"D","G","B","A","E","C","F"};        BinaryTree bt2 = new BinaryTree();        TreeNode root1 = bt2.buildTree(preorder,inorder1);//已知先序和中序构造二叉树        System.out.println("========递归后续遍历=======");        bt2.postOrder(root1);        System.out.println("=======非递归后序遍历======");        bt2.postOrder1(root1);        String[] inorder2 = {"D","G","B","A","E","C","F"};        String[] postorder = {"G","D","B","E","F","C","A"};        BinaryTree bt3 = new BinaryTree();        TreeNode root2 = bt3.buildTree1(inorder2,postorder);//已知中序和后序构造二叉树        System.out.println("=======递归先序遍历======");        bt3.preOrder(root2);        System.out.println("=======非递归先序遍历======");        bt3.preOrder1(root2);       }}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;    }    /*    返回父节点    */    public TreeNode getParent(TreeNode element){        return (root == null || root == element) ? null : parent(root,element);    }    private TreeNode parent(TreeNode subTree,TreeNode element){        if(subTree == null)            return null;        if(subTree.getLeftChild() == element || subTree.getRightChild() == element)            //返回父节点地址            return subTree;        TreeNode p;        if((p = parent(subTree.getLeftChild(),element)) != null)            //递归在左子树中搜索            return p;        else            //递归在右子树中搜索            return parent(subTree.getRightChild(),element);    }    /*    求节点个数    */    public int getSize(TreeNode root){        return getNum(root);    }    private int getNum(TreeNode node){        if(node == null)            return 0;        else{            int i = getNum(node.getLeftChild());            //System.out.println("****");            //System.out.println(i);            //System.out.println("****");            int j = getNum(node.getRightChild());            //System.out.println("----");            //System.out.println(j);            //System.out.println("----");            return i + j + 1;        }    }    /*    求高度    */    public int getHeight(){        return getDepth(root);    }    private int getDepth(TreeNode node){        if(node == null)            return 0;        else{            int i = getDepth(node.getLeftChild());            int j = getDepth(node.getRightChild());            return(i > j)?(i + 1):(j + 1);        }    }    /*    先序遍历递归算法    */    public void preOrder(TreeNode node){        if (node != null){            System.out.println(node.getData());            preOrder(node.getLeftChild());            preOrder(node.getRightChild());        }    }    /*    先序遍历非递归算法    */    public void preOrder1(TreeNode node){        TreeNode p;        TreeNode[] St = new TreeNode[getSize(node)];        int top = -1;        if(node != null){            top ++;            St[top] = node;            while(top > -1){                p = St[top];                top --;                System.out.println(p.getData());                if(p.getRightChild() != null){                    top ++;                    St[top] = p.getRightChild();                }                if(p.getLeftChild() != null){                    top ++;                    St[top] = p.getLeftChild();                }            }        }    }    /*    中序遍历递归算法    */    public void inOrder(TreeNode node){        if(node != null){            inOrder(node.getLeftChild());            System.out.println(node.getData());            inOrder(node.getRightChild());        }    }    /*    中序遍历非递归算法    */    public void inOrder1(TreeNode node){        TreeNode p;        TreeNode[] St = new TreeNode[getSize(node)];        int top = -1;        if(node != null){            p = node;            while(top > -1 || p != null){                while(p != null){                    top ++;                    St[top] = p;                    p = p.getLeftChild();                }                if(top > -1){                    p = St[top];                    top --;                    System.out.println(p.getData());                    p = p.getRightChild();                }            }        }    }    /*    后序遍历递归算法    */    public void postOrder(TreeNode node){        if(node != null){            postOrder(node.getLeftChild());            postOrder(node.getRightChild());            System.out.println(node.getData());        }    }    /*    后序遍历非递归算法    */    public void postOrder1(TreeNode node){        TreeNode p;        TreeNode[] St = new TreeNode[getSize(node)];        int top = -1,flag = 0;        if(node != null){            do{                while(node != null){                    top ++;                    St[top] = node;                    node = node.getLeftChild();                }                p =null;                flag = 1;                while(top != -1 && flag == 1){                    node = St[top];                    if(node.getRightChild() == p){                        System.out.println(node.getData());                        top --;                        p = node;                    }                    else{                        node = node.getRightChild();                        flag = 0;                    }                }            }while(top != -1);        }    }    /*    寻找根结点    */    private int findPosition(String[] arr, int start, int end, String key) {        int i;        for (i = start; i <= end; i++) {            if (arr[i] == key) {                return i;            }        }        return -1;    }    /*    已知先序和中序  构造二叉树    */    private TreeNode myBuildTree(String[] inorder, int instart, int inend,            String[] preorder, int prestart, int preend) {        if (instart > inend) {            return null;        }        TreeNode<String> head = new TreeNode<String>(preorder[prestart]);        int position = findPosition(inorder, instart, inend, preorder[prestart]);        head.setLeftChild(myBuildTree(inorder, instart, position - 1,                preorder, prestart + 1, prestart + position - instart));        head.setRightChild(myBuildTree(inorder, position + 1, inend,                preorder, position - inend + preend + 1, preend));        return head;    }    public TreeNode buildTree(String[] preorder, String[] inorder) {        if (inorder.length != preorder.length) {            return null;        }        return myBuildTree(inorder, 0, inorder.length - 1, preorder, 0, preorder.length - 1);    }    /*    已知中序和后序   构造二叉树    */    private TreeNode myBuildTree1(String[] inorder, int instart, int inend,            String[] postorder, int poststart, int postend) {        if (instart > inend) {            return null;        }        TreeNode<String> head1 = new TreeNode<String>(postorder[postend]);        int position = findPosition(inorder, instart, inend, postorder[postend]);        head1.setLeftChild(myBuildTree1(inorder, instart, position - 1,                postorder, poststart, poststart + position - instart - 1));        head1.setRightChild(myBuildTree1(inorder, position + 1, inend,                postorder, poststart + position - instart, postend - 1));        return head1;    }    public TreeNode buildTree1(String[] inorder, String[] postorder) {        if (inorder.length != postorder.length) {            return null;        }        return myBuildTree1(inorder, 0, inorder.length - 1, postorder, 0, postorder.length - 1);    }}/*    定义结点类*/class TreeNode<T>{    private T data = null;//数据部分    private TreeNode leftChild;//左孩子结点    private TreeNode rightChild;//右孩子结点    public TreeNode(){    }    public TreeNode(T data){        this.data = data;    }    public TreeNode(T data,TreeNode leftChild,TreeNode rightChild){        this.data = data;        this.leftChild = leftChild;        this.rightChild = rightChild;    }    //获取数据    public T getData(){        return data;    }    //修改数据    public void setData(T data){        this.data = data;    }    //获取左孩子结点    public TreeNode getLeftChild(){        return leftChild;    }    //修改左孩子结点    public void setLeftChild(TreeNode leftChild){        this.leftChild = leftChild;    }    //获取右孩子结点    public TreeNode getRightChild(){        return rightChild;    }    //修改右孩子结点    public void setRightChild(TreeNode rightChild){        this.rightChild = rightChild;    }}