二叉树的数据结构及遍历

二叉树结构：

public class BinTree {
    private TreeNode root = null;

    public BinTree() {

    }

    public BinTree(TreeNode root) {
        this.root = root;
    }

    public TreeNode getRoot() {
        return root;
    }

    public void setRoot(TreeNode root) {
        this.root = root;
    }

    private static class TreeNode {
        private String data;
        private TreeNode left;
        private TreeNode right;

        public TreeNode() {
        }

        public TreeNode(String data, TreeNode left, TreeNode right) {
            this.data = data;
            this.left = left;
            this.right = right;
        }
    }

    /**
     * 返回父节点
     */
    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.left == element || subTree.right == element)
            return subTree;
        TreeNode p;
        if ((p = parent(subTree.left, element)) != null)
            return p;
        else
            return parent(subTree.right, element);
    }

    /**
     * 返回孩子
     */
    public TreeNode getLeftChildNode(TreeNode element) {
        return (element != null) ? element.left : null;
    }

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

    /**
     * 返回节点个数
     */
    public int getSize() {
        return getNum(root);
    }

    private int getNum(TreeNode node) {
        if (node == null) {
            return 0;
        } else {
            int i = getNum(node.left);
            int j = getNum(node.right);
            return i + j + 1;
        }
    }

    /**
     * 树高度
     */
    public int getHeight() {
        return getHeight(root);
    }

    private int getHeight(TreeNode node) {
        if (node == null) {
            return 0;
        } else {
            int i = getHeight(node.left);
            int j = getHeight(node.right);
            return (i < j) ? (j + 1) : (i + 1);
        }
    }
}

遍历递归算法：

/**
     * 前序遍历
     */
    public void preOrder(TreeNode subTree) {
        if (subTree != null) {
            System.out.print(subTree.data + " ");
            preOrder(subTree.left);
            preOrder(subTree.right);
        }
    }

    /**
     * 中序遍历
     */
    public void inOrder(TreeNode subTree) {
        if (subTree != null) {
            inOrder(subTree.left);
            System.out.print(subTree.data + " ");
            inOrder(subTree.right);
        }
    }

    /**
     * 后序遍历
     */
    public void postOrder(TreeNode subTree) {
        if (subTree != null) {
            postOrder(subTree.left);
            postOrder(subTree.right);
            System.out.print(subTree.data + " ");
        }
    }

遍历非递归算法：

// 先序遍历非递归实现
    public void nPreOrder(TreeNode p) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode node = p;

        while (node != null || stack.size() > 0) {// 将所有左孩子压栈
            if (node != null) {
                System.out.print(node.data + " ");// 压栈前先访问
                stack.push(node);
                node = node.left;
            } else {
                node = stack.pop();
                node = node.right;
            }
        }
    }

    // 中序遍历的非递归实现
    public void nInOrder(TreeNode p) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode node = p;

        while (node != null || stack.size() > 0) {
            if (node != null) {
                stack.push(node);// 直接压栈
                node = node.left;
            } else {
                node = stack.pop();// 出栈并访问
                System.out.print(node.data + " ");
                node = node.right;
            }
        }
    }

    // 后序遍历的非递归实现
    public void nPostOrder(TreeNode p) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        Stack<TreeNode> output = new Stack<TreeNode>();// 构造中间栈来存储逆后序遍历的结果
        TreeNode node = p;

        while (node != null || stack.size() > 0) {
            if (node != null) {
                output.push(node);
                stack.push(node);
                node = node.right;
            } else {
                node = stack.pop();
                node = node.left;
            }
        }
        while (output.size() > 0) {
            System.out.print(output.pop().data + " ");
        }
    }

    // 层次遍历
    public static void levelOrder(TreeNode p) {
        if (p == null)
            return;
        Queue<TreeNode> q = new LinkedList<TreeNode>();
        q.offer(p);

        while (!q.isEmpty()) {
            TreeNode node = q.poll();
            System.out.print(node.data + " ");
            if (node.left != null)
                q.offer(node.left);
            if (node.right != null)
                q.offer(node.right);
        }
    }