深度优先和广度优先算法（例题）

在LeetCode上面刷题刷到一道二叉树的题，这道题我认为对学习树的深度优先和广度优先算法有一定的帮助，先来看一下题
这道题是这样的：
给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

这道题有两种思路一种是深度优先一种是广度优先
深度优先
见名知意这种思路就是先从深度遍历，我们先去往深处遍历，由于这道题是寻找每一层最右面的值，我们可以总是先访问右子树。这样就保证了当我们访问树的某个特定深度时，我们正在访问的节点总是该深度的最右侧节点。于是，可以存储在每个深度访问的第一个结点，一旦我们知道了树的层数，就可以得到最终的结果。
代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        int max_depth = -1;

        Stack<TreeNode> nodeStack = new Stack<TreeNode>();
        Stack<Integer> depthStack = new Stack<Integer>();
        nodeStack.push(root);
        depthStack.push(0);

        while (!nodeStack.isEmpty()) {
            TreeNode node = nodeStack.pop();
            int depth = depthStack.pop();

            /*关键点如果节点为空就去找他的根节点的左节点，
            如果还为空返回上一级去找，如此循环，直到全部出栈*/
            if (node != null) {
                max_depth = Math.max(max_depth, depth);

                /*判定这个map里是否有这个key的值*/
                if (!map.containsKey(depth)) {
                    map.put(depth, node.val);
                }

                nodeStack.push(node.left);
                nodeStack.push(node.right);
                depthStack.push(depth+1);
                depthStack.push(depth+1);
            }
        }

        /*使用list去接受map里的value的值*/
        List<Integer> rightView = new ArrayList<Integer>();
        for (int depth = 0; depth <= max_depth; depth++) {
            rightView.add(map.get(depth));
        }

        return rightView;
    }
}

广度优先
同样很容易看到这个词的1意思，就是从宽度下手，跟深度优先正好相反，每一层每一层的去遍历，直到最后一层，我们对每一层都从左到右访问。因此，通过只保留每个深度最后访问的结点，我们就可以在遍历完整棵树后得到每个深度最右的结点。
代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
         //这个和二叉树的层序遍历区别在于,只需要保存最右边的TreeNode即可
        List<Integer>list=new ArrayList<Integer>();
        if(root==null)
            return list;
        int level=0;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while ( !queue.isEmpty() ) {
            int level_length = queue.size();
            for(int i = 0; i < level_length; ++i) {
              /*关键点如果是这一层的最后一个就输出他*/
                if(i==level_length-1){
                    list.add(queue.peek().val);
              }
            TreeNode node = queue.remove();
            if (node.left != null) queue.add(node.left);
            if (node.right != null) queue.add(node.right);    
          }
        level++;
        }
        return list;

    }
}

上面是这个题的两种解法，一个使用的是栈一个使用的是队列，分别应用了栈后入先出的特向和队列先进先出的特性，上面的关键点已经标出，只要花时间就可以看懂，这道题难度不高，我认为可能对DFS和BFS有一定的理解