算法实现之二叉树的前序、中序、后序递归和非递归遍历以及层序遍历

概述

二叉树是每个节点最多有两个子树的树结构。通常子树被称作左子树和右子树。

二叉树的遍历通常分为：前序遍历、中序遍历、后序遍历和层序遍历。

前序遍历

前序递归遍历算法：访问根结点-->递归遍历根结点的左子树-->递归遍历根结点的右子树

中序遍历

中序递归遍历算法：递归遍历根结点的左子树-->访问根结点-->递归遍历根结点的右子树

后序遍历

后序递归遍历算法：递归遍历根结点的左子树-->递归遍历根结点的右子树-->访问根结点

二叉树节点

//二叉树节点
public class BinaryTreeNode {

    private Object data;

    private BinaryTreeNode left;

    private BinaryTreeNode right;

    public BinaryTreeNode() {

    }

    public BinaryTreeNode(Object data, BinaryTreeNode left, BinaryTreeNode right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public BinaryTreeNode getLeft() {
        return left;
    }

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

    public BinaryTreeNode getRight() {
        return right;
    }

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

前序遍历

//前序遍历递归的方式
public void preOrder(BinaryTreeNode root) {
    if (null != root) {
        System.out.print(root.getData() + "\t");
        preOrder(root.getLeft());
        preOrder(root.getRight());
    }
}

//前序遍历非递归的方式
public void preOrderNonRecursive(BinaryTreeNode root) {
    Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
    while (true) {
        while (root != null) {
            System.out.print(root.getData() + "\t");
            stack.push(root);
            root = root.getLeft();
        }
        if (stack.isEmpty()) break;
        root = stack.pop();
        root = root.getRight();
    }
}

中序遍历

//中序遍历采用递归的方式
public void inOrder(BinaryTreeNode root) {
    if (null != root) {
        inOrder(root.getLeft());
        System.out.print(root.getData() + "\t");
        inOrder(root.getRight());
    }
}

//中序遍历采用非递归的方式
public void inOrderNonRecursive(BinaryTreeNode root) {
    Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
    while (true) {
        while (root != null) {
            stack.push(root);
            root = root.getLeft();
        }
        if (stack.isEmpty()) break;
        root = stack.pop();
        System.out.print(root.getData() + "\t");
        root = root.getRight();
    }
}

后序遍历

//后序遍历采用递归的方式
public void postOrder(BinaryTreeNode root) {
    if (root != null) {
        postOrder(root.getLeft());
        postOrder(root.getRight());
        System.out.print(root.getData() + "\t");
    }
}

//后序遍历采用非递归的方式
public void postOrderNonRecursive(BinaryTreeNode root) {
    Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
    while (true) {
        if (root != null) {
            stack.push(root);
            root = root.getLeft();
        } else {
            if (stack.isEmpty()) return;

            if (null == stack.lastElement().getRight()) {
                root = stack.pop();
                System.out.print(root.getData() + "\t");
                while (root == stack.lastElement().getRight()) {
                    System.out.print(stack.lastElement().getData() + "\t");
                    root = stack.pop();
                    if (stack.isEmpty()) {
                        break;
                    }
                }
            }

            if (!stack.isEmpty())
                root = stack.lastElement().getRight();
            else
                root = null;
        }
    }
}

层序遍历

//层序遍历
public void levelOrder(BinaryTreeNode root) {
    BinaryTreeNode temp;
    Queue<BinaryTreeNode> queue = new LinkedList<BinaryTreeNode>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        temp = queue.poll();
        System.out.print(temp.getData() + "\t");
        if (null != temp.getLeft())
            queue.offer(temp.getLeft());
        if (null != temp.getRight()) {
            queue.offer(temp.getRight());
        }
    }
}

模拟二叉树实现

public static void main(String[] args) {
    //模拟生成上图的二叉树
    BinaryTreeNode nodeF = new BinaryTreeNode("F", null, null);
    BinaryTreeNode nodeE = new BinaryTreeNode("E", null, nodeF);
    BinaryTreeNode nodeD = new BinaryTreeNode("D", null, null);
    BinaryTreeNode nodeC = new BinaryTreeNode("C", null, null);
    BinaryTreeNode nodeB = new BinaryTreeNode("B", nodeC, nodeD);
    BinaryTreeNode nodeA = new BinaryTreeNode("A", nodeB, nodeE);

    BinaryTree tree = new BinaryTree();
    //采用递归的方式进行前序遍历
    System.out.println("-----前序遍历------");
    tree.preOrder(nodeA);
    System.out.println();
    //采用非递归的方式进行前序遍历
    tree.preOrderNonRecursive(nodeA);
    System.out.println();


    //采用递归的方式进行遍历
    System.out.println("-----中序遍历------");
    tree.inOrder(nodeA);
    System.out.println();
    //采用非递归的方式遍历
    tree.inOrderNonRecursive(nodeA);
    System.out.println();

    //采用递归的方式进行遍历
    System.out.println("-----后序遍历------");
    tree.postOrder(nodeA);
    System.out.println();
    //采用非递归的方式遍历
    tree.postOrderNonRecursive(nodeA);
    System.out.println();

    //采用递归的方式进行遍历
    System.out.println("-----层序遍历------");
    tree.levelOrder(nodeA);
    System.out.println();
}

输出如下：

-----前序遍历------
A	B	C	D	E	F
A	B	C	D	E	F
-----中序遍历------
C	B	D	A	E	F
C	B	D	A	E	F
-----后序遍历------
C	D	B	F	E	A
C	D	B	F	E	A
-----层序遍历------
A	B	E	C	D	F

参考

https://www.cnblogs.com/qiuyong/p/6675492.html