二叉树

二叉树抽象数据结构定义

public class BinaryTreeNode {
    private String value;
    private BinaryTreeNode leftChild;
    private BinaryTreeNode rightChild;

    public BinaryTreeNode(String value) {
        this.value = value;
    }
}

以广义表的形式创建二叉树

/**
     * 以广义表的形式新建二叉树
     * A,(B,C)
     *
     * @return
     */
    public BinaryTreeNode createTree() {
        // 左右子树的标志
        int k = 0;
        String endVale = "#";
        Scanner scanner = new Scanner(System.in);
        String value = scanner.next();
        BinaryTreeNode root = null;
        BinaryTreeNode p = null;
        Stack<BinaryTreeNode> stack = new Stack<>();
        while (value != endVale) {
            switch (value) {
                // 左括号表明进入左子树
                case "(":
                    k = 1;
                    stack.push(p);
                    break;
                // 逗号表明进入右子树
                case ",":
                    k = 2;
                    break;
                // 右括号标明子树创建完毕
                case ")":
                    stack.pop();
                    break;
                default:
                    p = new BinaryTreeNode(value);
                    if (root == null) {
                        root = p;
                    } else if (k == 1) {
                        // 连接左孩子
                        stack.peek().leftChild = p;
                    } else {
                        // 连接右孩子
                        stack.peek().rightChild = p;
                    }
            }
            value = scanner.next();
        }
        return root;
    }

二叉树的先序遍历

1. 递归先序遍历

/**
     * 递归前序遍历
     *
     * @param root 根节点
     */
    public void preOrder(BinaryTreeNode root) {
        if (root != null) {
            System.out.println(root.value);
            preOrder(root.leftChild);
            preOrder(root.rightChild);
        }
    }

2. 非递归先序遍历

/**
     * 非递归前序遍历
     *
     * @param root 根节点
     */
    public void preOrderWithNoCur(BinaryTreeNode root) {
        BinaryTreeNode p = root;
        Stack<BinaryTreeNode> stack = new Stack<>();
        while (p != null) {
            // 首先访问根节点
            System.out.println(p.value);
            // 右孩子入栈
            if (p.rightChild != null) {
                stack.push(p.rightChild);
            }
            // 左孩子不为空，先访问左孩子
            if (p.leftChild != null) {
                p = p.leftChild;
            } else if (!stack.isEmpty()) { // 否则访问右孩子
                p = stack.pop();
            } else {
                p = null;
            }
        }
    }
/**
     * 非递归前序遍历
     *
     * @param root 根节点
     */
    public void preOrderWithNoCur2(BinaryTreeNode root) {
        BinaryTreeNode p = null;
        Stack<BinaryTreeNode> stack = new Stack<>();
        // 首先根节点入栈
        stack.push(root);
        while (!stack.isEmpty()) {
            p = stack.pop();
            System.out.println(p.value);
            // 保证先访问左子树，所以右孩子先入栈
            if (p.rightChild != null) {
                stack.push(p.rightChild);
            }
            if (p.leftChild != null) {
                stack.push(p.leftChild);
            }
        }
    }   

二叉树的中序遍历

1. 递归中序遍历

/**
     * 递归中序遍历
     *
     * @param root 根节点
     */
    public void inOrder(BinaryTreeNode root) {
        if (root != null) {
            inOrder(root.leftChild);
            System.out.println(root.value);
            inOrder(root.rightChild);
        }
    }

2. 非递归中序遍历

/**
     * 非递归中序遍历
     *
     * @param root 根节点
     */
    public void inOrderWithNoCur(BinaryTreeNode root) {
        Stack<BinaryTreeNode> stack = new Stack<>();
        BinaryTreeNode p = root;
        do {
            // 左进
            while (p != null) {
                stack.push(p);
                p = p.leftChild;
            }
            if (!stack.isEmpty()) {
                BinaryTreeNode top = stack.pop();
                System.out.println(top.value);
                // 回退到右孩子
                p = top.rightChild;
            }
        } while (p != null || !stack.isEmpty());
    }

二叉树的后续遍历

1. 递归后续遍历

/**
     * 递归后序遍历
     *
     * @param root 根节点
     */
    public void postOrder(BinaryTreeNode root) {
        if (root != null) {
            postOrder(root.leftChild);
            postOrder(root.rightChild);
            System.out.println(root.value);
        }
    }

2. 非递归后续遍历

public class StackEle {
    private BinaryTreeNode binaryTreeNode;
    private char child;

    public StackEle(BinaryTreeNode binaryTreeNode, char child) {
        this.binaryTreeNode = binaryTreeNode;
        this.child = child;
    }

    public BinaryTreeNode getBinaryTreeNode() {
        return binaryTreeNode;
    }

    public void setBinaryTreeNode(BinaryTreeNode binaryTreeNode) {
        this.binaryTreeNode = binaryTreeNode;
    }

    public char getChild() {
        return child;
    }

    public void setChild(char child) {
        this.child = child;
    }
}
/**
     * 非递归后序遍历
     * 需要标识是否是
     * 第二次访问根节点
     *
     * @param root 根节点
     */
    public void postOrderWithNoCur(BinaryTreeNode root) {
        BinaryTreeNode p = root;
        Stack<StackEle> stack = new Stack<>();
        do {
            // 左进
            while (p != null) {
                StackEle temp = new StackEle(p, 'L');
                stack.push(temp);
                p = p.leftChild;
            }
            int contin = 1;
            while (contin != 0 && !stack.isEmpty()) {
                StackEle stackEle = stack.pop();
                p = stackEle.getBinaryTreeNode();
                // 当栈顶元素child域为L时
                // 说明是第一次访问，不输出
                // 将其右子树再入栈
                if (stackEle.getChild() == 'L') {
                    stackEle.setChild('R');
                    stack.push(stackEle);
                    p = p.rightChild;
                    contin = 0;
                } else {
                    System.out.println(stackEle.getBinaryTreeNode().value);
                }
            }
        } while (!stack.isEmpty());
    }

二叉树的层次遍历

/**
     * 层次遍历
     *
     * @param root 根节点
     */
    public void levelOrder(BinaryTreeNode root) {
        Queue<BinaryTreeNode> queue = new ArrayDeque<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            BinaryTreeNode q = queue.poll();
            System.out.println(q.value);
            if (q.leftChild != null) {
                queue.offer(q.leftChild);
            }
            if (q.rightChild != null) {
                queue.offer(q.rightChild);
            }
        }
    }

计算二叉树节点的个数

/**
     * 计算二叉树结点的个数
     *
     * @param root 根节点
     */
    public int size(BinaryTreeNode root) {
        if (root == null) {
            return 0;
        }
        // 返回1+左子树的结点个数+右子树结点的个数
        return 1 + size(root.leftChild) + size(root.rightChild);
    }

计算二叉树的高度

/**
     * 计算二叉树结点的高度
     *
     * @param root 根节点
     */
    public int height(BinaryTreeNode root) {
        if (root == null) {
            return 0;
        }
        int i = height(root.leftChild);
        int j = height(root.rightChild);
        // 取左子树和右子树高度较高的+1
        return i > j ? i + 1 : j + 1;
    }

判断两个二叉树是否相等

/**
     * 判断两个二叉树是否相等
     *
     * @param one
     * @param another
     * @return
     */
    public boolean equal(BinaryTreeNode one, BinaryTreeNode another) {
        if (one == null && another == null) {
            return true;
        } else if (one != null && another != null &&
                equal(one.leftChild, another.leftChild) && equal(one.rightChild, another.rightChild)) {
            return true;
        } else {
            return false;
        }
    }

以广义表的形式打印二叉树

/**
     * 以广义表的形式打印二叉树
     *
     * @param root 根节点
     */
    public void printBTree(BinaryTreeNode root) {
        if (root != null)  {
            System.out.print(root.value);
            if (root.leftChild != null || root.rightChild != null) {
                System.out.print("(");
                printBTree(root.leftChild);
                System.out.print(",");
                if (root.rightChild != null) {
                    printBTree(root.rightChild);
                }
                System.out.print(")");
            }
        }
    }