算法系列（1）--广度优先遍历和深度优先遍历

BFS（Breadth First Search）

对于广度优先遍历，需要有一个队列。

算法思路：

1. 输出根节点的值，将根节点放入队列
2. 从队列中弹出一个节点
3. 如果该节点有左节点，输出左节点，并将左节点放入队列
4. 如果该节点有右节点，输出右节点，并将右节点放入队列
5. 重复2~4步骤，直到队列为空

Java代码实现

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;
    }
}
*/

public class Solution {
    public ArrayList<Integer> BFS(TreeNode root) {
        ArrayList<Integer> lists = new ArrayList<Integer>();
        if(root==null)
            return lists;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode tree = queue.poll();
            if(tree.left!=null)
                queue.offer(tree.left);
            if(tree.right!=null)
                queue.offer(tree.right);
            lists.add(tree.val);
        }
        return lists;
    }
}

DFS（Depth First Search）

深度优先遍历需要一个栈作为辅助

算法思路：

1. 将根节点压入栈
2. 从栈中弹出一个节点，输出节点的值
3. 如果存在右节点，将右节点压入栈中
4. 如果存在左节点，将左节点压入栈中
5. 重复2~4，直到栈为空

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    
    public TreeNode(int val) {
        this.val = val;
    }
}
*/

public class Solution {
    public ArrayList<Integer> BFS(TreeNode root) {
        ArrayList<Integer> lists = new ArrayList<Integer>();
        if(root==null)
            return lists;
        Stack<TreeNode> stack=new Stack<TreeNode>();
        stack.push(root)
        while(!stack.isEmpty()){
        		TreeNode node = stack.pop()
        		lists.add(node.val)
        		if(node.rigth!=null){
        				stack.push(node.right)
        		}
        		if(node.left!=null){
        				stack.push(node.left)
        		}
        }
        return lists;
    }
}

递归实现

public class Solution{
  	ArrayList<Integer> lists = new ArrayList<Integer>();
		public ArrayList<Integer> BFS(TreeNode root) {
        if(root==null)
            return lists;
				depthTraversal(root)
    }
  
  	public void depthTraversal(TreeNode node){
      	self.lists.add(node.val)
      	if(node.left!=null){
            depthTraversal(node.left)
        }
        if(node.right!=null){
         		depthTraversal(node.right)
        }
    }
}

参考

1. https://www.cnblogs.com/xiaolovewei/p/7763867.html

算法系列（1）--广度优先遍历和深度优先遍历

原文：https://www.cnblogs.com/njuclc/p/13149499.html