public void recursion(int level, int param1, int param2, ...) {
    // 递归终止条件
    if (level > MAX_LEVEL) {
        // print
        return;
    }

    // 当前处理逻辑
    processData(level, param1, param2, ...);

    // 递归
    recursion(level + 1, param1, param2, ...);

    // 如有必要，还原状态
    reverseState(level, data);
}

Set<Node> visited = new HashSet<>();

public void dfs(Node node, Set<Node> visited) {
    visited.add(node);
    for (Node n : node.children) {
        if (!visited.contains(n)) {
            dfs(n, visited);
        }
    }
}

public List<List<Integer>> bfs(Node root) {
    List<List<Integer>> list = new ArrayList<>();
    Queue<Node> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        List<Integer> levelList = new ArrayList<>();

        int size = queue.size();
        // 遍历当前层级所有节点
        for (int i = 0; i < size; i++) {
            Node n = queue.poll();

            // 对节点 n 做逻辑处理
            levelList.add(n.val);

            // 将 n 的所有节点加入队列
            for (Node c : n.children) {
                queue.offer(c);
            }
        }

        list.add(levelList);
    }

    return list;
}

int left = 0, right = nums.length - 1;
while (left <= right) {
    int mid = left + (right - left) / 2; // 防止数据类型溢出
    if (nums[mid] == target) {
        break or return result;
    } else if (nums[mid] < target) {
        left = mid + 1;
    } else {
        right = mid - 1;
    }
}

// DP 状态定义
int[][] dp = new int[m + 1][n + 1];

// 初始状态
dp[0][0] = x;
dp[0][1] = y;

// DP 状态推导
for (int i = 0; i < m; i++) {
    for (int j = 0; j < n; j++) {
        // 方程根据实际场景推导
        dp[i][j] = max or min { dp[i - 1][j], dp[i][j - 1], ... }
    }
}

// 返回最优解
return dp[m][n];