二叉树的遍历

树节点类：public class TreeNode {    int val = 0;    TreeNode left = null;    TreeNode right = null;    public TreeNode(int val) {        this.val = val;    }}

先序遍历：

递归：

public ArrayList<Integer> preOrderTraverseRecur(TreeNode root) {if(root == null) {return null;}ArrayList<Integer> result = new ArrayList<Integer>();result.add(root.val);if(root.left != null) {<span style="white-space: pre;"></span>result.addAll(preOrderTraverseRecur(root.left));}if(root.right != null) {result.addAll(preOrderTraverseRecur(root.right));}</span>

return result;}

非递归

public ArrayList<Integer> preOrderTraverseNoRecur(TreeNode root) {if(root == null) {return null;}ArrayList<Integer> result = new ArrayList<Integer>();Stack<TreeNode> stack = new Stack<TreeNode>();stack.push(root);result.add(root.val);while(!stack.empty()) {if(stack.peek().left != null && !result.contains(stack.peek().left.val)) {result.add(stack.peek().left.val);stack.push(stack.peek().left);} else {if(stack.peek().right != null && !result.contains(stack.peek().right.val)) {result.add(stack.peek().right.val);stack.push(stack.peek().right);} else {stack.pop();}}}return result;}

中序遍历：

递归：

public ArrayList<Integer> inOrderTraverseRecur(TreeNode root) {if(root == null) {return null;}ArrayList<Integer> result = new ArrayList<Integer>();if(root.left != null) {result.addAll(inOrderTraverseRecur(root.left));}result.add(root.val);if(root.right != null) {result.addAll(inOrderTraverseRecur(root.right));}return result;}

非递归：

public ArrayList<Integer> inOrderTraverseNoRecur(TreeNode root) {if(root == null) {return null;}ArrayList<Integer> result = new ArrayList<Integer>();Stack<TreeNode> stack = new Stack<TreeNode>();stack.push(root);while(!stack.empty()) {if(stack.peek().left != null && !result.contains(stack.peek().left.val)) {stack.push(stack.peek().left);} else {if(stack.peek().right != null && !result.contains(stack.peek().right.val)) {TreeNode temp = stack.peek();result.add(stack.pop().val);stack.push(temp.right);} else {result.add(stack.pop().val);}}}return result;}

后序遍历：

递归：

public ArrayList<Integer> postOrderTraverseRecur(TreeNode root) {if(root == null) {return null;}ArrayList<Integer> result = new ArrayList<Integer>();if(root.left != null) {result.addAll(postOrderTraverseRecur(root.left));}if(root.right != null) {result.addAll(postOrderTraverseRecur(root.right));}result.add(root.val);return result;}

非递归：

public ArrayList<Integer> postOrderTraverseNoRecur(TreeNode root) {if(root == null) {return null;}ArrayList<Integer> result = new ArrayList<Integer>();Stack<TreeNode> stack = new Stack<TreeNode>();stack.push(root);while(!stack.empty()) {if(stack.peek().left != null && !result.contains(stack.peek().left.val)) {stack.push(stack.peek().left);} else {if(stack.peek().right != null && !result.contains(stack.peek().right.val)) {stack.push(stack.peek().right);} else {result.add(stack.pop().val);}}}return result;}

层序遍历：

public ArrayList<Integer> levelOrderTraverse(TreeNode root) {if(root == null) {return null;}LinkedList<TreeNode> queue = new LinkedList<TreeNode>();        ArrayList<Integer> result = new ArrayList<Integer>();                queue.add(root);        result.add(root.val);                while(!(queue.size() == 0)) {             TreeNode head = queue.remove();            if(head.left != null ) {                queue.add(head.left);                result.add(head.left.val);            }                         if(head.right != null ) {                queue.add(head.right);                result.add(head.right.val);            }             }                return result;    }

结果测试：

Test.java:

import java.util.ArrayList;public class Test {public static void main(String[] args) {// TODO Auto-generated method stub/** * 构建一颗二叉树

 *     1 *   /   \ *      2     3 *             /  \     \ *           7    4     8 *          / \   / *         6   5 9 */BinaryTree bt = new BinaryTree();TreeNode root = new TreeNode(1);TreeNode node1 = new TreeNode(2);TreeNode node2 = new TreeNode(3);TreeNode node3 = new TreeNode(7);TreeNode node4 = new TreeNode(4);TreeNode node5 = new TreeNode(8);TreeNode node6 = new TreeNode(6);TreeNode node7 = new TreeNode(5);TreeNode node8 = new TreeNode(9);root.left = node1;root.right = node2;node1.left = node3;node1.right = node4;node2.right = node5;node4.left = node6;node4.right = node7;node5.left = node8;/** *   测试递归先序遍历 *   正确输出为：   1  2  7  4  6  5  3  8  9  */        ArrayList<Integer> preOrderResultRecur = new ArrayList<Integer>();        preOrderResultRecur = bt.preOrderTraverseRecur(root);        System.out.println("递归先序遍历的结果为：   ");        for(Integer integer : preOrderResultRecur) {        System.out.print(integer + "  ");        }        System.out.println();                /** *   测试非递归先序遍历 *   正确输出为：   1  2  7  4  6  5  3  8  9  */        ArrayList<Integer> preOrderResultNoRecur = new ArrayList<Integer>();        preOrderResultNoRecur = bt.preOrderTraverseNoRecur(root);        System.out.println("非递归先序遍历的结果为：   ");        for(Integer integer : preOrderResultNoRecur) {        System.out.print(integer + "  ");        }        System.out.println();                        /** *   测试递归中序遍历 *   正确输出为：    7  2  6  4  5  1  3  9  8 */        ArrayList<Integer> inOrderResultRecur = new ArrayList<Integer>();        inOrderResultRecur = bt.inOrderTraverseRecur(root);        System.out.println("递归中序遍历的结果为：   ");        for(Integer integer : inOrderResultRecur) {        System.out.print(integer + "  ");        }        System.out.println();                /** *   测试非递归中序遍历 *   正确输出为：     7  2  6  4  5  1  3  9  8  */        ArrayList<Integer> inOrderResultNoRecur = new ArrayList<Integer>();        inOrderResultNoRecur = bt.inOrderTraverseNoRecur(root);        System.out.println("非递归中序遍历的结果为：   ");        for(Integer integer : inOrderResultNoRecur) {        System.out.print(integer + "  ");        }        System.out.println();                /** *   测试递归后序遍历 *   正确输出为：    7  6  5  4  2  9  8  3  1 */        ArrayList<Integer> postOrderResultRecur = new ArrayList<Integer>();        postOrderResultRecur = bt.postOrderTraverseRecur(root);        System.out.println("递归后序遍历的结果为：   ");        for(Integer integer : postOrderResultRecur) {        System.out.print(integer + "  ");        }        System.out.println();                /** *   测试非递归后序遍历 *   正确输出为：    7  6  5  4  2  9  8  3  1 */        ArrayList<Integer> postOrderResultNoRecur = new ArrayList<Integer>();        postOrderResultNoRecur = bt.postOrderTraverseNoRecur(root);        System.out.println("非递归后序遍历的结果为：   ");        for(Integer integer : postOrderResultNoRecur) {        System.out.print(integer + "  ");        }        System.out.println();                /** *   测试层序遍历 *   正确输出为：    1  2  3  7  4  8  6  5  9 */        ArrayList<Integer> levelOrderResult = new ArrayList<Integer>();        levelOrderResult = bt.levelOrderTraverse(root);        System.out.println("层序遍历的结果为：   ");        for(Integer integer : levelOrderResult) {        System.out.print(integer + "  ");        }        System.out.println(); }}

结果输出：