二叉树JAVA实现

最新推荐文章于 2024-10-18 20:01:16 发布
转载最新推荐文章于 2024-10-18 20:01:16 发布 · 235 阅读
文章标签：
#二叉树
算法专栏收录该内容
1 篇文章
订阅专栏
package com.test;

import java.util.Stack;

/**
 * 二叉树的链式存储
 * 
 * @author WWX
 */
public class BinaryTree {

    private TreeNode root = new TreeNode(1, "A");

    public BinaryTree() {
    }

    /**
     * 创建一棵二叉树
     * 
     * <pre>
     *          A 
     *      B         C 
     *   D    E     F   G
     *    H     I
     * </pre>
     * 
     * @param root
     * @author WWX
     * @author LPF
     */
    public void createBinTree(TreeNode root) {
        TreeNode newNodeB = new TreeNode(2, "B");
        TreeNode newNodeC = new TreeNode(3, "C");
        TreeNode newNodeD = new TreeNode(4, "D");
        TreeNode newNodeE = new TreeNode(5, "E");
        TreeNode newNodeF = new TreeNode(6, "F");
        TreeNode newNodeG = new TreeNode(7, "G");
        TreeNode newNodeH = new TreeNode(8, "H");
        TreeNode newNodeI = new TreeNode(9, "I");
        root.leftChild = newNodeB;
        root.rightChild = newNodeC;
        root.leftChild.leftChild = newNodeD;
        root.leftChild.leftChild.rightChild = newNodeH;
        root.leftChild.rightChild = newNodeE;
        root.leftChild.rightChild.rightChild = newNodeI;
        root.rightChild.leftChild = newNodeF;
        root.rightChild.rightChild = newNodeG;
    }

    public boolean isEmpty() {
        return root == null;
    }

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

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

    private 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);
        }
    }

    private int size(TreeNode subTree) {
        if (subTree == null) {
            return 0;
        } else {
            return 1 + size(subTree.leftChild) + size(subTree.rightChild);
        }
    }

    // 返回父节点
    public TreeNode parent(TreeNode element) {
        return (root == null || root == element) ? null : parent(root, element);
    }

    public TreeNode parent(TreeNode subTree, TreeNode element) {
        if (subTree == null)
            return null;
        if (subTree.leftChild == element || subTree.rightChild == element)
            // 返回父节点地址
            return subTree;
        TreeNode p;
        // 先在左子树中找，如果左子树中没有找到，到右子树去找
        if ((p = parent(subTree.leftChild, element)) != null)
            // 递归在左子树中搜索
            return p;
        else
            // 递归在右子树中搜索
            return parent(subTree.rightChild, element);
    }

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

    public TreeNode getRightChildNode(TreeNode element) {
        return (element != null) ? element.rightChild : null;
    }

    public TreeNode getRoot() {
        return root;
    }

    // 在释放某个节点时，该节点的左右子树都已经释放，
    // 所以应该采用后续遍历，当访问某个节点时将该节点的存储空间释放
    public void destroy(TreeNode subTree) {
        // 删除根为subTree的子树
        if (subTree != null) {
            // 删除左子树
            destroy(subTree.leftChild);
            subTree.leftChild = null;
            // 删除右子树
            destroy(subTree.rightChild);
            subTree.rightChild = null;
            subTree = null;
        }
    }

    public void traverse(TreeNode subTree) {
        System.out.println("key:" + subTree.key + "--name:" + subTree.data);
        traverse(subTree.leftChild);
        traverse(subTree.rightChild);
    }

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

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

    // 后续遍历
    public void postOrder(TreeNode subTree) {
        if (subTree != null) {
            postOrder(subTree.leftChild);
            postOrder(subTree.rightChild);
            visted(subTree);
        }
    }

    // 前序遍历的非递归实现
    public void nonRecPreOrder(TreeNode p) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode node = p;
        while (node != null || stack.size() > 0) {
            while (node != null) {
                visted(node);
                stack.push(node);
                node = node.leftChild;
            }
            node = stack.pop();
            node = node.rightChild;
            while (node == null && !stack.isEmpty()) {
                node = stack.pop().rightChild;
            }
        }
    }

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

    // 后序遍历的非递归实现
    public void noRecPostOrder(TreeNode node) {
        Stack<TreeNode> stack = new Stack<BinaryTree.TreeNode>();
        while (node != null || stack.size() > 0) {
            // 存在左子树
            while (node != null) {
                stack.push(node);
                node = node.leftChild;
            }

            TreeNode lastEl = null;
            // 栈最后元素
            node = stack.lastElement().rightChild;
            // 当右元素为空或右元素已经访问访问此元素，否则遍历右元素
            while ((node == null || node.isVisted) && !stack.isEmpty()) {
                lastEl = stack.pop();
                visted(lastEl);
                if (stack.isEmpty()) {
                    return;
                } else {
                    node = stack.lastElement().rightChild;
                }
            }
        }
    }

    public void noRecPostOrder2(TreeNode p) {
        Stack<TreeNode> stack = new Stack<BinaryTree.TreeNode>();
        while (p != null) {
            // 左子树入栈
            for (; p.leftChild != null; p = p.leftChild) {
                stack.push(p);
            }
            // 当前节点无右子树或右子树已经输出
            while (p != null && (p.rightChild == null || p.rightChild.isVisted)) {
                visted(p);
                if (stack.empty())
                    return;
                p = stack.pop();
            }
            stack.push(p);
            // 处理右子树
            p = p.rightChild;
        }
    }

    public void visted(TreeNode subTree) {
        subTree.isVisted = true;
        System.out.print(subTree.data + "\t");
    }

    /** 前序遍历初始化 */
    public void resetVisit(TreeNode subTree) {
        if (subTree != null) {
            subTree.isVisted = false;
            resetVisit(subTree.leftChild);
            resetVisit(subTree.rightChild);
        }
    }

    /**
     * 二叉树的节点数据结构
     * 
     * @author WWX
     */
    private class TreeNode {
        private int key = 0;
        private String data = null;
        private boolean isVisted = false;
        private TreeNode leftChild = null;
        private TreeNode rightChild = null;

        /**
         * @param key
         *            层序编码
         * @param data
         *            数据域
         */
        public TreeNode(int key, String data) {
            this.key = key;
            this.data = data;
            this.leftChild = null;
            this.rightChild = null;
        }

    }

    // 测试
    public static void main(String[] args) {
        BinaryTree bt = new BinaryTree();
        bt.createBinTree(bt.root);
        System.out.println("the size of the tree is " + bt.size());
        System.out.println("the height of the tree is " + bt.height());

        System.out.println("递归前序遍历:");
        bt.preOrder(bt.root);
        bt.resetVisit(bt.root);
        System.out.println("\n非递归前序遍:");
        bt.nonRecPreOrder(bt.root);
        bt.resetVisit(bt.root);

        System.out.println("\n递归中序遍历:");
        bt.inOrder(bt.root);
        bt.resetVisit(bt.root);
        System.out.println("\n非递归中序遍历:");
        bt.nonRecInOrder(bt.root);
        bt.resetVisit(bt.root);

        System.out.println("\n递归后序遍历:");
        bt.postOrder(bt.root);
        bt.resetVisit(bt.root);
        System.out.println("\n非递归后序遍历:");
        bt.noRecPostOrder(bt.root);
        bt.resetVisit(bt.root);
        System.out.println("\n非递归后序遍历2:");
        bt.noRecPostOrder2(bt.root);

        bt.destroy(bt.root);
        bt.root = null;
    }
}