Java二阶知识点总结（四）常见算法的基本结构

一、二叉树的DFS（深度优先算法）

1、递归

基本递归（以中序遍历为例）

	public List<Integer> inorderTraversal(TreeNode root) {List<Integer> result=new ArrayList<>();order(root,result);return result;}public void order(TreeNode node,List<Integer> result){	//递归携带的参数看情况设置if(node==null){	//这里要写一个递归终止条件return;}//这里可插入其他业务逻辑order(node.left,result);    //进入左节点result.add(node.val);		//业务代码，此处为中序遍历例order(node.right,result);	//进入右节点//这里可插入其他业务逻辑}

递归+前缀和+从下到上传递累加值（力扣437：路径总和）

	public int pathSum(TreeNode root, int targetSum) {Map<Long,Integer> prefix=new HashMap<Long,Integer>();prefix.put(0L,1);return dfs(root,prefix,0,targetSum);}public int dfs(TreeNode root,Map<Long,Integer> prefix,long sum,int targetSum){if(root==null){return 0;}int result=0;	//结果累加值sum+=root.val;	//当前值result=prefix.getOrDefault(sum-targetSum,0);	//若前缀和Map中存在计算总值-目标值对应的值，说明计算总值-这段前缀和=目标值prefix.put(sum,prefix.getOrDefault(sum,0)+1);	//存储前缀和result+=dfs(root.left,prefix,sum,targetSum);	//左递归result+=dfs(root.right,prefix,sum,targetSum);	//右递归prefix.put(sum,prefix.getOrDefault(sum,0)-1);	//从当前节点返回后，要把对应前缀和去掉return result;	//传递累加值}

递归+分治（力扣105：从前序和中序遍历序列构造二叉树）

	int[] preorder;HashMap<Integer, Integer> dic = new HashMap<>();public TreeNode buildTree(int[] preorder, int[] inorder) {this.preorder = preorder;for(int i = 0; i < inorder.length; i++)dic.put(inorder[i], i);return dfs(0, 0, inorder.length - 1);}public TreeNode dfs(int curr,int left,int right){if(left>right){return null;}TreeNode node=new TreeNode(preorder[curr]);int i=dic.get(preorder[curr]);node.left=dfs(curr+1,left,i-1);node.right=dfs(curr+i-left+1,i+1,right);return node;}

递归+标记（力扣236：二叉树的最近公共祖先）

	public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {if(root==null||root==p||root==q){	//若相等，则将该节点标记并往上传return root;}TreeNode left=lowestCommonAncestor(root.left,p,q);	//左递归TreeNode right=lowestCommonAncestor(root.right,p,q);	//右递归//放在递归最后是因为要从下往上排查if(left==null&&right==null){	//若两边都没有找到目标节点，则返回的是nullreturn null;}if(left==null){		//如果只是一边没找到，说明另外一边找到了return right;}if(right==null){	//同理return left;}return root;	//如果左右两边都找到了，说明这就是最近的公共祖先，直接往上传}

2、迭代

基本迭代（中序遍历例）

	public List<Integer> inorderTraversal(TreeNode root) {List<Integer> res = new ArrayList<Integer>();Deque<TreeNode> stack = new LinkedList<TreeNode>();	//Stack类已过时，使用Deque代替栈while (root != null || !stack.isEmpty()) {	//while (root != null) {	//后进先出，从最右侧的节点开始stack.push(root);	//push入栈root = root.left;}//这里可插入其他业务逻辑root = stack.pop();		//pop出栈res.add(root.val);		//业务代码，此处为中序遍历例root = root.right;		//回溯时再进入右侧节点//这里可插入其他业务逻辑}return res;}

二、二叉树的BFS（广度优先算法、层序遍历）

迭代

public List<List<Integer>> levelOrder(TreeNode root) {List<List<Integer>> res = new ArrayList<>();Queue<TreeNode> queue = new LinkedList<>();if (root != null) {	//队列中加入初始节点queue.offer(root);}while (!queue.isEmpty()) {	//只要队列不为空就一直进行int n = queue.size();List<Integer> level = new ArrayList<>();for (int i = 0; i < n; i++) { 	//只循环当前层拥有的节点次数TreeNode node = queue.poll();level.add(node.val);if (node.left != null) {	//若不为空就把下一层的节点加入，并且排到后面queue.offer(node.left);}if (node.right != null) {	//左右各一次queue.offer(node.right);}}res.add(level);}return res;}

三、图论的DFS

核心思想在于上下左右的操作，以及边界的判断
例题：力扣200.岛屿数量

	int result=0;public int numIslands(char[][] grid) {int result=0;for(int i=0;i<grid.length;i++){for(int j=0;j<grid[0].length;j++){if(grid[i][j]=='1'){result++;dfs(grid,i,j);}}}return result;}public void dfs(char[][] grid, int r, int c) {// 判断 base caseif (!inArea(grid, r, c)) {return;}// 如果这个格子不是岛屿，直接返回if (grid[r][c] != '1') {return;}grid[r][c] = '0'; // 将格子标记为「已遍历过」// 访问上、下、左、右四个相邻结点dfs(grid, r - 1, c);dfs(grid, r + 1, c);dfs(grid, r, c - 1);dfs(grid, r, c + 1);}// 判断坐标 (r, c) 是否在网格中public boolean inArea(char[][] grid, int r, int c) {return 0 <= r && r < grid.length && 0 <= c && c < grid[0].length;}

四、二分查找

核心思想在于两点，一是退出循环的条件是左小于右，二是每次都把范围缩小一半
参考（力扣704.二分查找）

    public int search(int[] nums, int target) {int left=0,right=nums.length-1;while(left<=right){int mid=(right-left)/2+left;int num=nums[mid];if(num==target){return mid;}else if(num>target){right=mid-1;}else{left=mid+1;}}return -1;}

五、单调栈

核心思想在于维护栈内保持单调，当栈顶元素小于或大于要放入的元素时，就持续弹出

 Stack<Integer> stack = new Stack<>();int[] nums = new int[]{9, 6, 4, 3, 1, 2, 6, 3};for (int num : nums) {//如果栈顶元素小于要放入的元素，就弹出。while (!stack.isEmpty() && stack.peek() < num) {	//核心步骤stack.pop();//后续业务}stack.push(num);}

六、回溯

回溯的核心思想是当后续流程走完后，返回到原始状态
如题：力扣46.全排列

	public void dfs(List<Integer> list,int n,int[] nums){if(n==nums.length){result.add(new ArrayList(list));return;}for(int i=0;i<nums.length;i++){if(flag[i]==0){list.add(nums[i]);	//满足条件后进行标记flag[i]=1;dfs(list,n+1,nums);	//递归到下一层flag[i]=0;			//返回到该层时，把原先的标记清除list.remove(list.size()-1);}}}