二叉樹的遍歷

什麼是二叉樹？
定義：二叉樹是每個結點最多有兩個子樹的樹結構。通常子樹被稱作“左子樹”和“右子樹”。
那什麼是遍歷？
遍歷:所謂遍歷(Traversal)是指沿着某條搜索路線，依次對樹中每個結點均做一次且僅做一次訪問。
二叉樹的遍歷方式有以下幾種：
1.前序遍歷：先訪問根節點——左子樹——右子樹。
2.中序遍歷：先訪問左子樹——根節點——右子樹，按照這個順序。
3.後序遍歷：和前面差不多，先訪問樹的左子樹——右子樹——根節點。按層遍歷：把一棵樹從上到下，從左到右依次寫出來。
4.層序遍歷：將二叉樹的每一層分別遍歷，直到最後的葉子節點被全部遍歷完
現有二叉樹如下，其通過各種遍歷方式得到的遍歷結果如下：
前序：0137849256
中序：7381940526
後序：7839415620
層序：0123456789

這裏先介紹前，中，後三種遍歷方式，最基本的實現方式就是通過遞歸實現：
首先編寫一個TreeNode類，並添加一個構造二叉樹的方法

package study.main.tree.binarytree;

/**
 * @author : [email protected]
 * @date : 2019/10/31 20:47
 */
public class TreeNode{
    private int data;
    private TreeNode leftNode;
    private TreeNode rightNode;
    public TreeNode(int data){
        this.data = data;
    }
    public void setData(int data){
        this.data = data;
    }
    public int getData(){
        return this.data;
    }
    public void setLeftNode(TreeNode node){
        this.leftNode = node;
    }
    public TreeNode getLeftNode(){
        return this.leftNode;
    }
    public void setRightNode(TreeNode node){
        this.rightNode = node;
    }
    public TreeNode getRightNode(){
        return this.rightNode;
    }

    /**
     * 構造二叉樹
     * @return TreeNode
     */
    public TreeNode getTree(){
        TreeNode[] nodes = new TreeNode[10];
        for (int i = 0;i < nodes.length;i++){
            nodes[i] = new TreeNode(i);
        }
        nodes[0].leftNode = nodes[1];
        nodes[0].rightNode = nodes[2];
        nodes[1].leftNode = nodes[3];
        nodes[1].rightNode = nodes[4];
        nodes[2].leftNode = nodes[5];
        nodes[2].rightNode = nodes[6];
        nodes[3].leftNode = nodes[7];
        nodes[3].rightNode = nodes[8];
        nodes[4].leftNode = nodes[9];
        return nodes[0];
    }
}

編寫實現類

package study.main.tree.binarytree;

/**
 * @author : [email protected]
 * @date : 2019/10/31 20:47
 */
public class BinaryTree{
    public static void main(String[] args){
        TreeNode treeNode = new TreeNode(10);
        //生成初始二叉樹
        TreeNode node = treeNode.getTree();
        BinaryTree binaryTree = new BinaryTree();
        binaryTree.qianxu(node);
        System.out.println("");
        binaryTree.zhongxu(node);
        System.out.println("");
        binaryTree.houxu(node);
        System.out.println(" ");
    }
    private void qianxu(TreeNode node){
        if (null == node){
            return;
        }
        System.out.print(node.getData()+" ");
        qianxu(node.getLeftNode());
        qianxu(node.getRightNode());
    }
    private void zhongxu(TreeNode node){
        if (null == node){
            return;
        }
        zhongxu(node.getLeftNode());
        System.out.print(node.getData()+" ");
        zhongxu(node.getRightNode());
    }
    private void houxu(TreeNode node){
        if (null == node){
            return;
        }
        houxu(node.getLeftNode());
        houxu(node.getRightNode());
        System.out.print(node.getData()+" ");
    }
}

除了使用遞歸，還可以用java的棧stack來實現三種遍歷方式
什麼是棧？
棧是一種數據項按序排列的數據結構，只能在一端(稱爲棧頂(top))對數據項進行插入和刪除。特點：後進先出

package study.main.tree.binarytree;

import java.util.Stack;

/**
 * @author : [email protected]
 * @date : 2019/11/3 17:54
 */
public class BinaryTreeByStack {
    public static void main(String[] args){
        TreeNode treeNode = new TreeNode(10);
        TreeNode node = treeNode.getTree();
        BinaryTreeByStack binaryTreeByStack = new BinaryTreeByStack();
        binaryTreeByStack.qianxu(node);
        System.out.println(" ");
        binaryTreeByStack.zhongxu(node);
        System.out.println(" ");
        binaryTreeByStack.houxu(node);
    }
    private void qianxu(TreeNode node){
        Stack<TreeNode> stack = new Stack<>();
        TreeNode root = node;
        while (null != root || !stack.isEmpty()){
            if (null != root){
                System.out.print(root.getData()+" ");
                stack.push(root);
                root = root.getLeftNode();
            } else {
                root = stack.pop().getRightNode();
            }
        }
    }
    private void zhongxu(TreeNode node){
        Stack<TreeNode> stack = new Stack<>();
        TreeNode root = node;
        while (null != root || !stack.isEmpty()){
            if (null != root){
                stack.push(root);
                root = root.getLeftNode();
            } else {
                root = stack.pop();
                System.out.print(root.getData()+" ");
                root = root.getRightNode();
            }
        }
    }
    private void houxu(TreeNode node){
        if (null == node) {
            return;
        }
        TreeNode root = node;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        stack.push(root);
        while (!stack.isEmpty()){
            root = stack.pop();
            if (!stack.isEmpty() && root == stack.peek()){
                if (null != root.getRightNode()){
                    stack.push(root.getRightNode());
                    stack.push(root.getRightNode());
                }
                if (null != root.getLeftNode()){
                    stack.push(root.getLeftNode());
                    stack.push(root.getLeftNode());
                }
            } else{
                System.out.print(root.getData()+" ");
            }
        }
    }
}

講完前，中，後三種遍歷方式，這裏再說一下層序遍歷，它是最接近我們思維的一種遍歷方式，這裏用java的隊列Queue來實現它
隊列是一種特殊的線性表，它只允許在表的前端進行刪除操作，而在表的後端進行插入操作。
LinkedList類實現了Queue接口，因此我們可以把LinkedList當成Queue來用。

package study.main.tree.binarytree;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @author : [email protected]
 * @date : 2019/11/10 23:33
 */
public class BinaryTreeByQueue {
    public static void main(String[] args){
        TreeNode treeNode = new TreeNode(10);
        //生成初始二叉樹
        TreeNode node = treeNode.getTree();
        BinaryTreeByQueue binaryTree = new BinaryTreeByQueue();
        binaryTree.cengxu(node);
    }
    private void cengxu(TreeNode node){
        if (null == node){
            return;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(node);
        while (!queue.isEmpty()){
            node = queue.poll();
            if (null != node.getLeftNode()){
                queue.offer(node.getLeftNode());
            }
            if (null != node.getRightNode()){
                queue.offer(node.getRightNode());
            }
            System.out.print(node.getData()+" ");
        }
    }
}