(三)数据结构树之叉树遍历代码实现

二叉树相关遍历学习笔记

1：构建二叉树数据结构
/**
* 树节点数据结构
*/
public class TreeNode {

        public int Index;
        public String data;
        public TreeNode leftTreeNode;
        public TreeNode rightTreeNode;
        public TreeNode(int index, String data) {
            this.Index = index;
            this.data = data;
            this.leftTreeNode = null;
            this.rightTreeNode = null;
        }
}
    /**
 * 构造一个这种类型的二叉树 
 *                      A
 *              B            C
 *         D      E      F
 */

public void createBinaryTree() {

    TreeNode nodeB = new TreeNode(2, "B");
    TreeNode nodeC = new TreeNode(3, "C");
    TreeNode nodeD = new TreeNode(4, "D");
    TreeNode nodeE = new TreeNode(5, "E");
    TreeNode nodeF = new TreeNode(6, "F");
    root.leftTreeNode = nodeB;
    root.rightTreeNode = nodeC;
    nodeC.leftTreeNode = nodeF;
    nodeB.leftTreeNode = nodeD;
    nodeB.rightTreeNode = nodeE;

}

2：二叉树的迭代遍历
(1)前序遍历
/**
* 递归式前序遍历
*/
public void preOrder(TreeNode node) {

        if (node == null)
            return;
        System.out.println("前序遍历:" + node.data);
        preOrder(node.leftTreeNode);
        preOrder(node.rightTreeNode);
    }

    /**
     * 利用栈的实现前序遍历
     */
    public void preStackOrder(TreeNode node) {
        if (node == null)
            return;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(node);
        while (!stack.isEmpty()) {
            // 出栈和进栈
            TreeNode n = stack.pop();
            System.out.println("栈式前序遍历:" + n.data);
            // 压入子节点
            if (n.rightTreeNode != null) {
                stack.push(n.rightTreeNode);
            }
            if (n.leftTreeNode != null) {
                stack.push(n.leftTreeNode);
            }
        }
}

(2)中序遍历

/**
 * 中序遍历
 */
public void midOrder(TreeNode node) {

        if (node == null)
            return;
        midOrder(node.leftTreeNode);
        System.out.println("中序遍历:" + node.data);
        midOrder(node.rightTreeNode);
}

/**
 * 利用栈的实现中序遍历
 */
public void midStackOrder(TreeNode node) {
        if (node == null)
            return;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode cur = node;
        while (cur != null || !stack.isEmpty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.leftTreeNode;
            }
            cur = stack.pop();
            System.out.println("栈式后序遍历:" + cur.data);
            cur = cur.rightTreeNode;
        }
}

(3)后序遍历
/**
* 双栈式后续序遍历
*/
public void postStackOrder2(TreeNode node) {

    if (node == null)
        return;
    Stack<TreeNode> stack = new Stack<TreeNode>(); 
    Stack<TreeNode> modStack = new Stack<TreeNode>();//翻转输出用
    stack.push(node);
    while (!stack.isEmpty()) { 
        TreeNode cur = stack.pop(); 
        modStack.push(cur);
        if (cur.leftTreeNode != null) { 
            stack.push(cur.leftTreeNode);
        }
        if (cur.rightTreeNode != null) {
            stack.push(cur.rightTreeNode);
        }
    }
    while (!modStack.isEmpty()) { 
        System.out.println(modStack.pop().data + " ");
    }
}

/**
 * 双栈式后续序遍历
 */
public void postStackOrder2(TreeNode node) {

    if (node == null)
        return;
    TreeNode cur = node;
    Stack<TreeNode> stack = new Stack<TreeNode>();
    while (node != null) {
        // 左子树入栈
        for (; node.leftTreeNode != null; node = node.leftTreeNode)
            stack.push(node);
        // 当前节点无右子或右子已经输出
        while (node != null
                && (node.rightTreeNode == null || node.rightTreeNode == cur)) {
            System.out.println(node.data + " ");
            cur = node;// 记录已输出节点
            if (stack.empty())
                return;
            node = stack.pop();
        }
        // 处理右子
        stack.push(node);
        node = node.rightTreeNode;
    }
}

(4)层序遍历

/**
* 层序遍历，利用链表形式或者队列的形式
* 树的深度优先遍历需要用–>栈；而广度优先遍历用–>队列；
*/
public void levelListOrder(TreeNode node) {

    if (node == null)
        return;
    LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
    queue.addFirst(node);
    while (!queue.isEmpty()) {
        TreeNode cur = queue.removeFirst();
        System.out.print(cur.data + " ");
        if (cur.leftTreeNode != null) {
            queue.add(cur.leftTreeNode);
        }
        if (cur.rightTreeNode != null) {
            queue.add(cur.rightTreeNode);
        }
    }
}