廣度優先搜索（BFS）

廣度優先搜索（BFS）的數據結構是隊列queue。算法思路是用vector來記錄每層結點，然後清空當前隊列，再將該層隊列的下一層加入隊列。
算法思路：

public class BreadthFirstPaths {
	private boolean[] marked; // 到達該頂點的最短路徑已知嗎？
	private int[] edgeTo; // 到達該頂點的已知路徑上的最後一個頂點
	private final int s; // 起點
	public BreadthFirstPaths(Graph G, int s) {
		marked = new boolean[G.V()];
		edgeTo = new int[G.V()];
		this.s = s;
		bfs(G, s);
	}

	private void bfs(Graph G, int s) {
		Queue<Integer> queue = new Queue<Integer>();
		marked[s] = true; // 標記起點
		queue.enqueue(s); // 將它加入隊列
		while (!queue.isEmpty()) {
			int v = queue.dequeue(); // 從隊列中刪去下一頂點
			for (int w : G.adj(v))
				if (!marked[w]) {// 對於每個未被標記的相鄰頂點
					edgeTo[w] = v; // 保存最短路徑的最後一條邊
					marked[w] = true; // 標記它，因爲最短路徑已知
					queue.enqueue(w); // 並將它添加到隊列中
				}
		}
	}
	public boolean hasPathTo(int v) {
	    return marked[v];
	}
	public Iterable<Integer> pathTo(int v)
// 和深度優先搜索中的實現相同（請見算法4.1）
}

參考題：LeetCode103

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if (!root) return res;
        vector<int> vec;
        vector<TreeNode*> nodes;
        queue<TreeNode*> que;
        que.push(root);
        int level = 0;

        while (!que.empty()) {
        	while (!que.empty()) {
        		TreeNode* node = que.front();
        		nodes.push_back(node);
        		vec.push_back(node->val);
        		que.pop();
        	}
        	level++;

        	for (auto node : nodes) {
        		if (node->left) que.push(node->left);
        		if (node->right) que.push(node->right);
        	}
        	nodes.clear();
        	if (level%2 == 0) reverse(vec.begin(), vec.end());
        	res.push_back(vec);
        	vec.clear();
        }
        
        return res;
    }
};