dfs、bfs、动态规划、二分、递归的模板汇总

dfs：

/** 用栈保存节点，用于回溯 */
static LinkedList<Integer> visited = new LinkedList<>();
    public static void dfs(TreeNode node){
        visited.addLast(node.val);
        // process current node here

        // 递归
        if (node.left != null && !visited.contains(node.left) )
            dfs(node.left);
        if (node.right != null && !visited.contains(node.right) )
            dfs(node.right);
    }

bfs:

/** 用队列保存节点，先进先出 */
    static ArrayDeque<TreeNode> q = new ArrayDeque();
    public static void _bfs(TreeNode node){
        System.out.print(node.val);
        if (node.left != null)
            q.add(node.left);
        if (node.right != null)
            q.add(node.right);
    }

dp：

/** Q：如何剪绳子，会让剪后的长度相乘最大 */
    // dp：O(n) = max(O(i)*O(n-i))
    public static int maxProductAfterCut(int length){
        // 校验
        if (length < 2)
            return 0;
        if (length ==2)
            return 1;
        if (length == 3)
            return 2;
        // dp状态定义
        int[] products = new int[length+1];// 为什么这里设置length+1
        // 初始状态
        products[0] = 0;
        products[1] = 1;
        products[2] = 2;
        products[3] = 3;
        // dp状态的推导
        int max = 0;
        for (int i = 4; i < length; i++) {
            max = 0;
            // j表示剪多长
            for (int j = 1; j < i/2; j++) {
                // 计算长度为i，乘积的最大值
                int product = products[j] * products[i-j];// 从已有的数据取！！
                max = max < product ? product : max;
                products[i] = max;// 保存局部最优解！！动态规划核心
            }
        }
        // 最优解
        max = products[length];
        return max;
    }

二分查找

/**
	 * 计算中间下标
	 * 判断：小于取左；大于取右
	 * 结束：数组长度为1
	 */
	public int search(int[] nums, int target) 
	{
	    int lo = 0;
	    int hi = nums.length - 1;

	    while(lo <= hi)
	    {
	    	int mid = lo + (hi - lo)/2;

	    	if(nums[mid] < target)
	    		lo = mid + 1;
	    	else if(nums[mid] > target)
	    		hi = mid - 1;
	    	else
	    		return mid;
	    }

	    return -1;
	}

递归

/** 盗梦空间 -- 递归 */
    public static void moveIn(int level){
        // recursion terminator：递归终止条件
        if (level == 6 || level == 0){
            return;
        }
        // process logic in current level：当前逻辑
        System.out.println("进入第" + level + "层梦境");
        // drill down：下一层
        moveIn(level+1);
        // reverse the current level if need：返回当前层逻辑
        System.out.println("返回第" + level + "层梦境");
    }