前序遍历（递归、非递归）、层序遍历（递归、非递归）

递归：

package 剑指offer.前序遍历;

import java.util.ArrayList;

/**
 * Created by nick on 2018/10/6.
 */
public class Solution {
    ArrayList<Integer> res=new ArrayList<Integer>();
    public void preNode(TreeNode root){
        if(root==null)
            return;
        res.add(root.val);
        preNode(root.left);
        preNode(root.right);
    }
    
}
class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }
}

非递归：

package 剑指offer.前序遍历;

import java.util.ArrayList;
import java.util.Stack;

/**
 * Created by nick on 2018/10/6.
 */
public class Solution1 {
    ArrayList<Integer> res=new ArrayList<Integer>();
    public ArrayList<Integer> preNode(TreeNode root){
        Stack<TreeNode> temp=new Stack<TreeNode>();
        if(root==null)
            return res;
        temp.push(root);
        while (!temp.isEmpty()){
            TreeNode t=temp.pop();
            res.add(t.val);
            if(t.right!=null)
                temp.push(root.right);
            if(t.left!=null)
                temp.push(root.left);

        }
        return res;
    }

    public static void main(String[] args) {
        TreeNode root=new TreeNode(1);
        root.left=new TreeNode(2);
        root.right=new TreeNode(3);

        System.out.println(new Solution1().preNode(root));
    }
}

 层序遍历：

    /*
     * 层序遍历
     * 递归
     */
    public void levelOrder(BinaryNode<AnyType> Node) {
        if (Node == null) {
            return;
        }

        int depth = depth(Node);

        for (int i = 1; i <= depth; i++) {
            levelOrder(Node, i);
        }
    }

    private void levelOrder(BinaryNode<AnyType> Node, int level) {
        if (Node == null || level < 1) {
            return;
        }

        if (level == 1) {
            System.out.print(Node.element + "  ");
            return;
        }

        // 左子树
        levelOrder(Node.left, level - 1);//直到第level层，再进行打印

        // 右子树
        levelOrder(Node.right, level - 1);
    }

    public int depth(BinaryNode<AnyType> Node) {
        if (Node == null) {
            return 0;
        }

        int l = depth(Node.left);
        int r = depth(Node.right);
        if (l > r) {
            return l + 1;
        } else {
            return r + 1;
        }
    }

非递归算法：

    //使用队列
    public static void levelTraversal2(TreeNode root)
    {
        ArrayDeque<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        while(!queue.isEmpty())
        {
            TreeNode temp = queue.poll();
            System.out.print(temp.val);
            if(temp.left != null)
            {
                queue.offer(temp.left);
            }
            if(temp.right != null)
            {
                queue.offer(temp.right);
            }
        }
    }
}