杠上数据结构 - 二叉树

二叉树在面试过程中出现的频率非常高，因此熟练掌握二叉树是吊打面试官的必备技能。

基本认识

二叉树：是节点的一个有限集合，该集合要么为空，要么由一个根节点加上左子树和右子树组成。

特点：

• 每个节点最多有两颗子树，即二叉树不存在度大于 2 的节点。
• 二叉树的子树有左右之分，左子树在左，右子树在右。

二叉树的存储结构

二叉树的存储结构有：

• 顺序存储
• 链式存储

顺序存储

顺序存储是使用一维数组存储二叉树中的节点，节点的存储位置就是数组的下表索引。

可以看到，顺序存储结构在存储非完全二叉树时，会出现空间利用不完全的问题。对于某种极端情况，比如只有左子树，或只有右子树，采用顺序存储结构是十分浪费空间的。因此顺序存储一般适用于完全二叉树。

链式存储

链式存储是使用链表来存储，每个节点包含三个域： 数据域和左右孩子域。

二叉树遍历

二叉树的遍历方式有：

• 先序遍历
• 中序遍历
• 后序遍历
• 层级遍历

其中先中后序都是相对于根节点而言的，先序就是先根再左右孩子，中序就是先左孩子再根最后右孩子，后续就是先左孩子再右孩子最后根。层级遍历就是从上往下一层层的访问节点。
例如上面二叉树链式存储结构图，
先序： A B D E C
中序： D B E A C
后续： D E B C A
层级： A B C D E

二叉树遍历代码实现

定义二叉树节点类：

/**
 * 二叉树的节点
 */
public class Node {
   
    private int value;
    private Node left;
    private Node right;

    public Node() {
   
    }

    public Node(int value) {
   
        this.value = value;
    }

    public int getValue() {
   
        return value;
    }

    public void setValue(int value) {
   
        this.value = value;
    }

    public Node getLeft() {
   
        return left;
    }

    public void setLeft(Node left) {
   
        this.left = left;
    }

    public Node getRight() {
   
        return right;
    }

    public void setRight(Node right) {
   
        this.right = right;
    }

    @Override
    public String toString() {
   
        return "ListNode{" +
                "value=" + value +
                ", left=" + left +
                ", right=" + right +
                '}';
    }
}

定义二叉树类, 通过根节点来定义：

/**
 * 二叉树类
 */
public class BinaryTree {
   
    /**
     * 根节点
     */
    private Node root;

    public BinaryTree() {
   
    }

    public BinaryTree(int value) {
   
        Node node = new Node(value);
        setRoot(node);
    }

    public Node getRoot() {
   
        return root;
    }

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

1. 插入节点

	/**
     * 往二叉树中插入节点
     *
     * @param value
     */
    public void add(int value) {
   
        Node newNode = new Node(value);
        // 没有根节点时，插入到根节点
        if (root == null) {
   
            root = newNode;
        } else {
      // 有节点
            Node curNode = root;
            while (true) {
   
                // 插入节点的值小于当前节点的值，放到当前节点的左边
                if (value < curNode.getValue()) {
   
                    // 如果当前节点没有左孩子，则直接放入，否则继续循环
                    if (curNode.getLeft() == null) {
   
                        curNode.setLeft(newNode);
                        break;
                    }
                    curNode = curNode.getLeft();
                } else if (value > curNode.getValue()) {
     // 插入节点大于当前节点的值，放到节点的右边
                    if (curNode.getRight() == null) {
   
                        curNode.setRight(newNode);
                        break;
                    }
                    curNode = curNode.getRight();
                }
            }
        }
    }

2. 先序遍历

	/**
     * 先序遍历，输出到 List 集合中
     *
     * @return
     */ 
    private void pre2(Node node, List<Integer