Java数据结构详解(二叉树篇)

二叉树的结构

class Node{
    char val;
    Node left, right;
    public Node(){}
    public Node(char val, Node left, Node right){
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

二叉树的遍历

先序遍历 

若二叉树为空，则空操作；否则：
（1）访问根结点
（2）先序遍历左子树
（3）先序遍历右子树 

递归代码 

/**
 * 二叉树先序遍历（递归写法）
 * @param root
 */
public static void preRecursion(Node root){
    if (root == null)
        return;
    System.out.println(root.val);
    preRecursion(root.left);
    preRecursion(root.right);
}

非递归代码

非递归线序遍历需要借助栈来实现

/**
 * 先序遍历的非递归写法
 * @param root
 */
public static void preOrder(Node root){
    //用一个辅助栈
    Deque<Node> stack = new ArrayDeque<>();
    stack.push(root);
    while (!stack.isEmpty()){
        Node tmp = stack.peek();
        System.out.println(tmp.val);
        stack.pop();
        if (tmp.right != null)
            stack.push(tmp.right);
        if(tmp.left != null)
            stack.push(tmp.left);
    }
}

 中序遍历

若二叉树为空，则空操作；否则：
（1）中序遍历左子树
（2）访问根结点
（3）中序遍历右子树 

递归代码：

/**
 * 二叉树中序遍历（递归写法）
 * @param root
 */
public static void inRecursion(Node root){
    if (root == null)
        return;
    inRecursion(root.left);
    System.out.println(root.val);
    inRecursion(root.right);
}

非递归写法:

/**
 * 二叉树中序遍历（非递归写法）
 * @param root
 */
public static void inOrder(Node root){
    Deque<Node> stack = new ArrayDeque<>();
    Node tmp = root;
    while (!stack.isEmpty() || tmp != null){
        if (tmp != null){
            stack.push(tmp);
            tmp = tmp.left;
        }else {
            tmp = stack.peek();
            System.out.println(tmp.val);
            stack.pop();
            tmp = tmp.right;
        }
    }
}

后序遍历

若二叉树为空，则空操作；否则：
（1）后序遍历左子树
（2）后序遍历右子树
（3）访问根结点 

递归代码 

/**
 * 二叉树后序遍历（递归写法）
 * @param root
 */
public static void postRecursion(Node root){
    if (root == null)
        return;
    postRecursion(root.left);
    postRecursion(root.right);
    System.out.println(root.val);
}

非递归代码

/**
 * 二叉树后序遍历（非递归写法）
 * @param root
 */
public static void postOrder(Node root){
    //用两个栈
    Deque<Node> stack1 = new ArrayDeque<>();
    Deque<Node> stack2 = new ArrayDeque<>();
    stack1.push(root);
    while (!stack1.isEmpty()){
        Node tmp = stack1.peek();
        stack2.push(tmp);
        stack1.pop();
        if (tmp.left != null)
            stack1.push(tmp.left);
        if (tmp.right != null)
            stack1.push(tmp.right);
    }
    while (!stack2.isEmpty()){
        System.out.println(stack2.pop().val);
    }
}