算法打卡第十周-CSDN博客

本文链接：https://blog.csdn.net/xiaoyong_j/article/details/117201557

leetcode第437题路径总和
题目描述：
给定一个二叉树，它的每个结点都存放着一个整数值。
找出路径和等于给定数值的路径总数。
路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

```java
class Solution {
    private int sum = 0;

   public int pathSum(TreeNode root, int targetSum) {
        if (root == null) {
            return 0;
        }
        dfs(root,targetSum);
        pathSum(root.left,targetSum);
        pathSum(root.right,targetSum);
        return sum;
    }
    //遍历以节点root为起始节点下，路径和为targetSum的路径总数
    private void dfs(TreeNode root,int targetSum) {
        if (root == null) {
            return;
        }
        if (targetSum - root.val == 0) {
            sum++;
        }
        dfs(root.left,targetSum-root.val);
        dfs(root.right,targetSum-root.val);
    }
}```

leetcode第889题根据前序和后序遍历构造二叉树

package datastruct.contructtree;

import java.util.Arrays;

/**
 * 根据前序遍历和后序遍历  返回匹配的任意二叉树的
 *
 * @Date: 2021/5/23 8:55
 */
public class ContructTreeFromPreAndPost {

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
        }
    }


    public TreeNode constructFromPrePost(int[] pre, int[] post) {
        if (pre.length == 0 || pre == null) {
            return null;
        }


        return dfs(pre, post);

    }


    public TreeNode dfs(int[] pre, int[] post) {
        if (pre == null || pre.length ==0) {
            return null;
        }
        if (pre.length == 1) {
            return new TreeNode(pre[0]);
        }
        int n = post.length;
        TreeNode root = new TreeNode(pre[0]);
        for (int i = 0; i < n; i++) {
            if (post[i] == pre[1]) {
                int[] preLeft = Arrays.copyOfRange(pre, 1, i + 2);
                int[] preRight = Arrays.copyOfRange(pre, i + 2, pre.length);
                int[] postLeft = Arrays.copyOfRange(post, 0, i+1);
                int[] postRight = Arrays.copyOfRange(post, i + 1, post.length - 1);
                root.left = dfs(preLeft, postLeft);
                root.right = dfs(preRight, postRight);
                break;
            }
        }
        return root;
    }
//测试类
package datastruct.contructtree;

/**
 * @Date: 2021/5/23 16:40
 */
public class TestContructTreeFromPreAndPost {

    public static void main(String[] args) {
        ContructTreeFromPreAndPost contruct = new ContructTreeFromPreAndPost();
        int[] pre = new int[]{2,1};
        int[] post = new int[]{1,2};
        ContructTreeFromPreAndPost.TreeNode treeNode = contruct.constructFromPrePost(pre, post);
        firstSearch(treeNode);
        System.out.println();
        lastSearch(treeNode);

    }


    private static void firstSearch(ContructTreeFromPreAndPost.TreeNode root){
        if (root == null) {
            return;
        }
        System.out.print(root.val + "->");
        firstSearch(root.left);
        firstSearch(root.right);
    }

    private static void lastSearch(ContructTreeFromPreAndPost.TreeNode root) {
        if (root == null) {
            return;
        }
        lastSearch(root.left);
        lastSearch(root.right);
        System.out.print(root.val + "->");
    }
}
}

leetcode第105题从前序与中序遍历序列构造二叉树

package datastruct.contructtree;

import java.util.Arrays;

/**
 * 根据先序和中序数组构建树
 *
 * @Date: 2021/5/23 19:22
 */
public class ContructTreeFromPreAndIn {

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
        }
    }


    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if (preorder == null || preorder.length == 0) {
            return null;
        }
        return dfs(preorder, inorder);

    }

    private TreeNode dfs(int[] preorder, int[] inorder) {
        if (preorder == null || preorder.length == 0) {
            return null;
        }
        if (preorder.length == 1) {
            return new TreeNode(preorder[0]);
        }
        TreeNode root = new TreeNode(preorder[0]);
        int size = inorder.length;
        for (int i = 0; i < size; i++) {
            if (inorder[i] == root.val) {
                int[] inorderLeft = Arrays.copyOfRange(inorder,0,i);
                int[] inorderRight = Arrays.copyOfRange(inorder,i+1,inorder.length);
                int[] preorderleft = Arrays.copyOfRange(preorder,1,i+1);
                int[] preorderRight = Arrays.copyOfRange(preorder,i+1,preorder.length);
                root.left = dfs(preorderleft,inorderLeft);
                root.right = dfs(preorderRight,inorderRight);
                break;
            }
        }
        return root;
    }
}

//测试类
package datastruct.contructtree;

/**
 *
 * 根据先序遍历和中序遍历结果构造二叉树
 * @Date: 2021/5/23 19:33
 */
public class TestContructTreeFromPreAndIn {

    public static void main(String[] args) {
        ContructTreeFromPreAndIn preAndIn = new ContructTreeFromPreAndIn();
        int[] preorder= new int[]{3,9,20,15,7};
        int[] inorder = new int[]{9,3,15,20,7};
        ContructTreeFromPreAndIn.TreeNode treeNode = preAndIn.buildTree(preorder, inorder);
        //先序打印
        firstSearch(treeNode);
        System.out.println();
        //中序打印
        inSearch(treeNode);
    }

    private static void firstSearch(ContructTreeFromPreAndIn.TreeNode root){
        if (root == null) {
            return;
        }
        System.out.print(root.val + "->");
        firstSearch(root.left);
        firstSearch(root.right);
    }

    private static void inSearch(ContructTreeFromPreAndIn.TreeNode root) {
        if (root == null) {
            return;
        }
        inSearch(root.left);
        System.out.print(root.val + "->");
        inSearch(root.right);
    }
}

leetcode第106题从中序与后序遍历序列构造二叉树

package datastruct.contructtree;

import java.util.Arrays;

/**
 *
 * 根据中序和后序遍历数组 构建出二叉树
 * @Date: 2021/5/23 18:43
 */
public class ContructTreeFromInAndPost {

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }


    public TreeNode buildTree(int[] inorder, int[] postorder) {
        if (postorder == null || postorder.length == 0) {
            return null;
        }
        return dfs(inorder, postorder);
    }

    private TreeNode dfs(int[] inorder, int[] postorder) {
        if (postorder.length == 1) {
            return new TreeNode(postorder[0]);
        }
        TreeNode root = new TreeNode(postorder[postorder.length - 1]);
        int size = inorder.length;
        for (int i = 0; i < size; i++) {
            if (inorder[i] == root.val) {
                int[] inorderLeft = Arrays.copyOfRange(inorder, 0, i);
                int[] inorderRight = Arrays.copyOfRange(inorder, i + 1, inorder.length);
                int[] postorderLeft = Arrays.copyOfRange(postorder, 0, i);
                int[] postorderRight = Arrays.copyOfRange(postorder, i, postorder.length - 1);
                root.left = dfs(inorderLeft, postorderLeft);
                root.right = dfs(inorderRight, postorderRight);
                break;
            }
        }
        return root;
    }
}

//测试类
package datastruct.contructtree;

/**
 * @Date: 2021/5/23 19:10
 */
public class TestContructFromInAndPost {

    public static void main(String[] args) {
        int[] inorder = new int[]{9, 3, 15, 20, 7};
        int[] postorder = new int[]{9, 15, 7, 20, 3};
        ContructTreeFromInAndPost contructTreeFromInAndPost = new ContructTreeFromInAndPost();
        ContructTreeFromInAndPost.TreeNode treeNode = contructTreeFromInAndPost.buildTree(inorder, postorder);
        inSearch(treeNode);
        System.out.println();
        lastSearch(treeNode);

    }

    private static void inSearch(ContructTreeFromInAndPost.TreeNode root) {
        if (root == null) {
            return;
        }
        inSearch(root.left);
        System.out.print(root.val + "->");
        inSearch(root.right);
    }

    private static void lastSearch(ContructTreeFromInAndPost.TreeNode root) {
        if (root == null) {
            return;
        }
        lastSearch(root.left);
        lastSearch(root.right);
        System.out.print(root.val + "->");
    }
}