二叉树遍历 java

原文链接 :http://blog.youkuaiyun.com/hairongtian/article/details/7930937

import java.util.Stack;  

import java.util.HashMap;  
  
public class BinTree {  
    private char date;  
    private BinTree lchild;  
    private BinTree rchild;  
  
    public BinTree(char c) {  
        date = c;  
    }  
  
    // 先序遍历递归   
    public static void preOrder(BinTree t) {  
        if (t == null) {  
            return;  
        }  
        System.out.print(t.date);  
        preOrder(t.lchild);  
        preOrder(t.rchild);  
    }  
  
    // 中序遍历递归   
    public static void InOrder(BinTree t) {  
        if (t == null) {  
            return;  
        }  
        InOrder(t.lchild);  
        System.out.print(t.date);  
        InOrder(t.rchild);  
    }  
  
    // 后序遍历递归   
    public static void PostOrder(BinTree t) {  
        if (t == null) {  
            return;  
        }  
        PostOrder(t.lchild);  
        PostOrder(t.rchild);  
        System.out.print(t.date);  
    }  
  
    // 先序遍历非递归   
    public static void preOrder2(BinTree t) {  
        Stack<BinTree> s = new Stack<BinTree>();  
        while (t != null || !s.empty()) {  
            while (t != null) {  
                System.out.print(t.date);  
                s.push(t);  
                t = t.lchild;  
            }  
            if (!s.empty()) {  
                t = s.pop();  
                t = t.rchild;  
            }  
        }  
    }  
  
    // 中序遍历非递归   
    public static void InOrder2(BinTree t) {  
        Stack<BinTree> s = new Stack<BinTree>();  
        while (t != null || !s.empty()) {  
            while (t != null) {  
                s.push(t);  
                t = t.lchild;  
            }  
            if (!s.empty()) {  
                t = s.pop();  
                System.out.print(t.date);  
                t = t.rchild;  
            }  
        }  
    }  
  
    // 后序遍历非递归   
    public static void PostOrder2(BinTree t) {  
        Stack<BinTree> s = new Stack<BinTree>();  
        Stack<Integer> s2 = new Stack<Integer>();  
        Integer i = new Integer(1);  
        while (t != null || !s.empty()) {  
            while (t != null) {  
                s.push(t);  
                s2.push(new Integer(0));  
                t = t.lchild;  
            }  
            while (!s.empty() && s2.peek().equals(i)) {  
                s2.pop();  
                System.out.print(s.pop().date);  
            }  
  
            if (!s.empty()) {  
                s2.pop();  
                s2.push(new Integer(1));  
                t = s.peek();  
                t = t.rchild;  
            }  
        }  
    }  
  
    public static void main(String[] args) {  
        BinTree b1 = new BinTree('a');  
        BinTree b2 = new BinTree('b');  
        BinTree b3 = new BinTree('c');  
        BinTree b4 = new BinTree('d');  
        BinTree b5 = new BinTree('e');  
  
        /** 
         *      a  
         *     / / 
         *    b   c 
         *   / / 
         *  d   e 
         */  
        b1.lchild = b2;  
        b1.rchild = b3;  
        b2.lchild = b4;  
        b2.rchild = b5;  
  
        BinTree.preOrder(b1);  
        System.out.println();  
        BinTree.preOrder2(b1);  
        System.out.println();  
        BinTree.InOrder(b1);  
        System.out.println();  
        BinTree.InOrder2(b1);  
        System.out.println();  
        BinTree.PostOrder(b1);  
        System.out.println();  
        BinTree.PostOrder2(b1);  
    }  
}
### Java二叉树的前序、中序和后序遍历Java中,可以通过递归方式实现二叉树的三种主要遍历方法:前序遍历、中序遍历以及后序遍历。 #### 前序遍历 前序遍历遵循访问顺序为 **根节点 -> 左子树 -> 右子树** 的原则。以下是其实现代码: ```java public class TreeNode { int value; TreeNode left; TreeNode right; public TreeNode(int value) { this.value = value; this.left = null; this.right = null; } } public class BinaryTree { public void preOrder(TreeNode node) { if (node == null) { return; } System.out.print(node.value + " "); // 处理根节点 preOrder(node.left); // 递归遍历左子树 preOrder(node.right); // 递归遍历右子树 } } ``` 上述代码展示了如何通过递归完成前序遍历操作[^1]。 #### 中序遍历 中序遍历按照 **左子树 -> 根节点 -> 右子树** 的顺序执行。其具体实现如下所示: ```java public class BinaryTree { public void inOrder(TreeNode node) { if (node == null) { return; } inOrder(node.left); // 递归遍历左子树 System.out.print(node.value + " "); // 处理根节点 inOrder(node.right); // 递归遍历右子树 } } ``` 此部分逻辑基于递归调用,先处理左侧分支再打印当前节点值并继续右侧分支的操作[^2]。 #### 后序遍历 对于后序遍历而言,则需依照 **左子树 -> 右子树 -> 根节点** 这样的路径来展开工作流程。下面给出对应的算法描述及其编码形式: ```java public class BinaryTree { public void postOrder(TreeNode node) { if (node == null) { return; } postOrder(node.left); // 递归遍历左子树 postOrder(node.right); // 递归遍历右子树 System.out.print(node.value + " "); // 处理根节点 } } ``` 这段程序片段清楚地表明了后序遍历过程中各阶段的任务安排情况。 以上就是利用Java语言针对二叉树结构分别实施前序、中序及后序这三种不同类型的遍历策略的具体做法说明。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值