二叉树的java实现

Posted 2020-09-10 myJavaEE

import java.util.Arrays;
import java.util.Stack;


// 链式存储的二叉树
public class BSTree {
    private TreeNode root = null;
    public TreeNode getRoot() {
        return root;
    }
    public BSTree(TreeNode root) {
        this.root = root;
    }
    
    public boolean isEmpty() {
        return root == null;
    }

    // 树的高度
    public int height() {
        return TreeNode.height(root);
    }

    // 节点个数
    public int size() {
        return TreeNode.size(root);
    }

    // 返回树中某节点的父节点
    public TreeNode parent(TreeNode element) {
        return (root == null || root == element) ? null : TreeNode.getParent(root, element);
    }

    
    // 定义树的节点
    private static class TreeNode {
        private int data;
        private TreeNode leftChild = null;
        private TreeNode rightChild = null;
        
        public TreeNode(int data) {
            this.data = data;
            this.leftChild = null;
            this.rightChild = null;
        }
        
        public static TreeNode getParent(TreeNode subTree, TreeNode element) {
            if (subTree == null)
                return null;
            if (subTree.leftChild == element || subTree.rightChild == element)
                return subTree;
            TreeNode p = null;
            // 递归左右子树
            if ((p = getParent(subTree.leftChild, element)) != null)
                return p;
            else
                return getParent(subTree.rightChild, element);
        }

        public static TreeNode getLeftChildNode(TreeNode element) {
            return (element != null) ? element.leftChild : null;
        }

        public static TreeNode getRightChildNode(TreeNode element) {
            return (element != null) ? element.rightChild : null;
        }
        
        public static int height(TreeNode subTree) {
            if (subTree == null)
                return 0;// 递归结束：空树高度为0
            else {
                int i = height(subTree.leftChild);
                int j = height(subTree.rightChild);
                return (i < j) ? (j + 1) : (i + 1);
            }
        }
        
        public static int size(TreeNode subTree) {
            if (subTree == null) {
                return 0;
            } else {
                return 1 + size(subTree.leftChild) + size(subTree.rightChild);
            }
        }
        
        // 在释放某个结点前, 该结点的左右子树应该已经释放, 所以应该采用后续遍历
        public static void destroySubTree(TreeNode subTree) {
            // 删除根为subTree的子树
            if (subTree != null) {
                destroySubTree(subTree.leftChild);
                destroySubTree(subTree.rightChild);
                // 删除根结点
                subTree = null;
            }
        }
        
        
        public static void visted(TreeNode subTree) {
            System.out.println("data: " + subTree.data);
        }
        
        // 前序遍历
        public static void preOrder(TreeNode subTree) {
            if (subTree != null) {
                visted(subTree);
                preOrder(subTree.leftChild);
                preOrder(subTree.rightChild);
            }
        }

        // 中序遍历
        public static void inOrder(TreeNode subTree) {
            if (subTree != null) {
                inOrder(subTree.leftChild);
                visted(subTree);
                inOrder(subTree.rightChild);
            }
        }

        // 后续遍历
        public static void postOrder(TreeNode subTree) {
            if (subTree != null) {
                postOrder(subTree.leftChild);
                postOrder(subTree.rightChild);
                visted(subTree);
            }
        }
        
        // 前序遍历的非递归实现
        public static void nonRecPreOrder(TreeNode subTree) {
            Stack<TreeNode> stack = new Stack<TreeNode>();
            TreeNode node = subTree;
            while (node != null || stack.size() > 0) {
                if (node != null) {
                    visted(node);
                    stack.push(node);
                    node = node.leftChild;
                } else {
                    node = stack.pop();
                    node = node.rightChild;
                }
            }
        }

        // 中序遍历的非递归实现
        public static void nonRecInOrder(TreeNode subTree) {
            Stack<TreeNode> stack = new Stack<TreeNode>();
            TreeNode node = subTree;
            while (node != null || stack.size() > 0) {
                // 存在左子树
                if (node != null) {
                    stack.push(node);
                    node = node.leftChild;
                }
                else {
                    node = stack.pop();
                    visted(node);
                    node = node.rightChild;
                }
            }
        }

        // 后序遍历的非递归实现
        public static void nonRecPostOrder(TreeNode subTree) {
            if (null == subTree) { //为确保下面循环至少执行一次
                return;  
            }
            Stack<TreeNode> stack = new Stack<TreeNode>();
            TreeNode node = subTree;
            TreeNode lastVisited = subTree;
            while (true) {
                // 左路入栈
                while (node.leftChild != null) {
                    stack.push(node);    //第一次压栈, 为了访问左路后退出
                    node = node.leftChild;
                }
                // 连续处理从右路返回的节点
                while (node.rightChild == null || node.rightChild == lastVisited) {
                    // 访问并纪录本次访问节点
                    visted(node);
                    lastVisited = node;
                    if (stack.empty()) {
                        return;
                    }
                    node = stack.pop();
                }
                // 处理从左路返回的节点
                stack.push(node);  // 第二次压栈, 为了访问右路后退出
                node = node.rightChild;
            }
        }
    }
    
    
    // 二叉搜索树
    public void add(int data) {
        add(root, data);
    }
    
    public boolean contains(int data) {
        return contains(root, data);
    }
    
    public int minValue() {
        return findMin(root).data;
    }
    
    public int maxValue() {
        return findMax(root).data;
    }
    
    private TreeNode findMin(TreeNode subTree) {
        if (null == subTree) {
            return null;
        } else if (null == subTree.leftChild) {
            return subTree;
        }
        return findMin(subTree.leftChild);
    }

    private TreeNode findMax(TreeNode subTree) {
        if (null != subTree) {
            while (null != subTree.rightChild) {
                subTree = subTree.rightChild;
            }
        }
        return subTree;
    }
    // 添加节点进搜索树
    private TreeNode add(TreeNode subTree, int data) {
        if (null == subTree) {
            return new TreeNode(data);
        } else if (data > subTree.data) {
            subTree.rightChild = add(subTree.rightChild, data);
            return subTree;
        } else if (data < subTree.data) {
            subTree.leftChild = add(subTree.leftChild, data);
            return subTree;
        } // 这里限定搜索树中元素不重复
        return subTree;
    }

    private boolean contains(TreeNode subTree, int data) {
        if (null == subTree) {
            return false;
        } else if (data > subTree.data) {
                return contains(subTree.rightChild, data);
        } else if (data < subTree.data){
                return contains(subTree.leftChild, data);
        } else {
            return true;
        }
    }
    
    private TreeNode remove(TreeNode subTree, int data) {
        if (null == subTree) {
            return null;
        } else if (data > subTree.data) {
            return remove(subTree.rightChild, data);
        } else if (data < subTree.data) {
            return remove(subTree.leftChild, data);
        } else if (null == subTree.leftChild || null == subTree.rightChild) {  //节点匹配, 只有一个孩子或没有孩子
            return (subTree.leftChild != null) ? subTree.leftChild : subTree.rightChild; 
        } else {      //节点匹配, 有两个孩子
            subTree.data = findMin(subTree.rightChild).data;
            subTree.rightChild = remove(subTree.rightChild, subTree.data);
            return subTree;
        }
    }
    
    // 测试
    public static void main(String[] args) {
        // 创建树
        int[] values = new int[8];
        for (int i = 0; i < 8; i++) {
            int num = (int) (Math.random() * 15);
            if (!checkDup(values, num))
                values[i] = num;
            else
                i--;
        }
        System.out.println("generate Nums:" + Arrays.toString(values));

        BSTree tree = new BSTree(new TreeNode(values[0]));
        for (int i = 1; i < values.length; i++) {
            tree.add(values[i]);
        }

        System.out.println("树高: " + TreeNode.height(tree.getRoot()));
        System.out.println("树大小: " + TreeNode.size(tree.getRoot()));
        System.out.println("前序遍历:");
        TreeNode.nonRecPreOrder(tree.getRoot());
        System.out.println("中序遍历:");
        TreeNode.nonRecInOrder(tree.getRoot());
        System.out.println("后序遍历:");
        TreeNode.nonRecPostOrder(tree.getRoot());
    }
    private static boolean checkDup(int[] arr, int value) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == value)
                return true;
        }
        return false;
    }
    
}