visited = set()
def dfs(node, visited):
    if node in visited: #termintor
    # already visited
    return 

    visited.add(node)

    # process current node here
    #...

    for next_node in node.children():
        if not next_node in visited:
            dfs(next node, visited)
    

def DFS(self, tree):
    if tree.root is None:
        return []
    visited, stack = [], [tree.root]

    while stack:
        node = stack.pop()
        visited.add(node)

        process (node)
        nodes = grenerate_related_nodes(node)
        statck.push(nodes)

     #other processing work
     #...

function BFS(graph, start, end) {
    let queue = []
    queue.append([start])
    visited.add(start)

    while (queue.length) {
        let node = queue.shift();
        visited.add(node);

        process(node)
        node = generate_related_nodes(node)
        queue.push(nodes)

        // other processing work
    }
}

贪心算法是一种在每一步选中都采取在当前状态下最好或最优(即最有利)的选择，从而希望导致结果是全局最好或最优的算法。
贪心算法与动态规划的不同在于它对每个子问题的解决方案都做出选择，不能回退。动态规划则会保存以前的运算结果，并根据以前的结果对当前进行选择，有回退功能。
贪心法可以解决一些最优化问题，如：求图中的最小生成树、求哈夫曼编码等。然而对于工程和生活中的问题，贪心法一般不能得到我们所要的答案。
一旦一个问题可以通过贪心法来解决。那么贪心法一般是解决这个问题的最好办法。由于贪心法的高效性以及其所求得的答案比较接近最优结果，贪心法也可以用作辅助算法或者直接解决一些要求结果不特别精确的问题。

问题能分解成子问题来解决，子问题的最优解能递推到最终问题的最优解。这种子问题最优解称为最优子结构。

let left = 0, right = array.length - 1;
while (left <= right) {
    let mid = (left + right) / 2;
    if (array[mid] === target) {
        //find the target
        //break or return result
    } else if (array[mid] < target) {
        left = mid + 1;
    } else {
        right = mid - 1;
    }
}