数据结构---二叉树路径问题

原创 已于 2023-01-04 15:30:52 修改 · 795 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #深度优先 #java

于 2023-01-03 16:36:09 首次发布

二叉树路径问题

二叉树所有路径

在这里插入图片描述
257二叉树所有路径

分析

前序遍历二叉树+递归实现回溯
深度优先搜索dfs

JAVA实现

//静态内部类
    //二叉树节点
    public static class TreeNode{
        int data;
        bTree257.TreeNode leftChild;
        bTree257.TreeNode rightChild;

        public TreeNode(int data) {
            this.data = data;
        }
    }

二叉树的构建

/**
     * 前序遍历的链表节点的顺序.来创建二叉树
     * @param inputList
     * @return
     */
    public static bTree257.TreeNode precreatBinaryTree(LinkedList<Integer> inputList){
        bTree257.TreeNode node = null;
        if(inputList==null||inputList.isEmpty()){
            return null;
        }
        Integer data = inputList.removeFirst();
        if(data!=null){
            //根左右。。。。
            node = new bTree257.TreeNode(data);
            node.leftChild=precreatBinaryTree(inputList);
            node.rightChild = precreatBinaryTree(inputList);
        }
        //将根节点返回（用于遍历，不返回根节点，这个树怎么找。。。。。）
        return node;
    }

前序遍历代码（写着玩玩）

    /**
     * 前序遍历
     * @param node
     */
    public static void preOrderTraveral(bTree257.TreeNode node){
        if(node==null){
            return;
        }
        System.out.println(node.data);
        preOrderTraveral(node.leftChild);
        preOrderTraveral(node.rightChild);
    }

遍历所有路径:

    public static void dfs(TreeNode root,String path,List<String> ans){
        if(root!=null){
            StringBuffer sb = new StringBuffer(path);
            sb.append(root.data);
            if(root.leftChild==null&&root.rightChild==null){
                ans.add(sb.toString());
                return ;
            }else {
                sb.append("->");
                dfs(root.leftChild,sb.toString(),ans);
                dfs(root.rightChild,sb.toString(),ans);
            }
        return ;
        }

    }

    public List<String> binaryTreePaths(TreeNode root) {
        List<String> ans = new ArrayList<>();
        dfs(root,"",ans);
        return ans;
    }

递归出口1：if(root.leftChildnull&&root.rightChildnull)
也就是达到这个条件回溯到前面的状态。。。。。
递归出口2：return ;
也就是遍历完成了左右孩子，则回溯到上一个状态

测试方法：

    public static void main(String[] args) {
        //前序创建二叉树
        //LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.asList(new Integer[]{1,2,4,null,null,5,null,null,3,null,6}));
        //LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.asList(new Integer[]{8,5,1,null,null,2,null,null,7}));

        LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.asList(new Integer[]{}));
//        inputList.add(8);
//        inputList.add(5);
//        inputList.add(1);
//        inputList.add(null);
//        inputList.add(null);
//        inputList.add(2);
//        inputList.add(null);
//        inputList.add(null);
//        inputList.add(7);
        System.out.println("请按照前序输入二叉树节点:");
        Scanner in =new Scanner(System.in);
        int a=0;
        Scanner sc = new Scanner(System.in);
        String inputString = sc.nextLine();
        String stringArray[] = inputString.split(" ");
        int num[] = new int[stringArray.length];
        for (int i = 0; i < stringArray.length; i++) {
            if(Integer.parseInt(stringArray[i])==0){
                inputList.add(null);
            }else {
                inputList.add(Integer.parseInt(stringArray[i]));
            }
        }

        System.out.println("二叉树构建成功！");

        bTree257.TreeNode treeNode = precreatBinaryTree(inputList);

		System.out.println("前序遍历如下：");
        preOrderTraveral(treeNode);
        
        System.out.println("遍历所有路径");
        //1 2 4 0 0 5 0 0 3 0 6
        //ans存储所有的路径
        List<String> ans = new ArrayList<>();
        dfs(treeNode,"",ans);
        for (int i =0;i<ans.size();i++){
            System.out.println(ans.get(i));
        }
    }

前序遍历如下：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

力扣提交

力扣提交代码：

class Solution {

    public static void dfs(TreeNode root,String path,List<String> ans){
        if(root!=null){
            StringBuffer sb = new StringBuffer(path);
            sb.append(root.val);
            if(root.left==null&&root.right==null){
                ans.add(sb.toString());
                return ;
            }else {
                sb.append("->");
                dfs(root.left,sb.toString(),ans);
                dfs(root.right,sb.toString(),ans);
            }
        return ;
        }

    }

    public List<String> binaryTreePaths(TreeNode root) {
        List<String> ans = new ArrayList<>();
        dfs(root,"",ans);
        return ans;
    }
}

在这里插入图片描述
在这里插入图片描述

找到一个和为sum的到达叶子节点的路径

在这里插入图片描述

路径总和

分析

就是在之前的二叉树路径问题上加一点求和代码就行。
将最后的结果（字符串数组，一维度）转为二维数组，遍历求和每一行的值，看其是否等于待求的数。

	    int length = 0;
        for (int i =0;i<ans.size();i++){
            //System.out.println(ans.get(i));
            String str = ans.get(i);
            String[] strs=str.split("->");
            System.out.println(Arrays.toString(strs));
            length = Math.max(length,strs.length);

        }
        System.out.println(length);
        int result[][] = new int[ans.size()][length];
        for (int i =0;i<ans.size();i++){
            //System.out.println(ans.get(i));
            String str = ans.get(i);
            String[] strs=str.split("->");
            for (int j =0;j<strs.length;j++){
                result[i][j]= Integer.parseInt(strs[j]);
            }

        }

        int total = 8;
        int sum = 0;
        for (int i =0;i<ans.size();i++){
            for (int  j=0;j<result[i].length;j++){
                sum += result[i][j];
            }
            if(sum==total){
                System.out.println("找到了");
            }
            if(i==ans.size()-1&&sum!=total){
                System.out.println("没找到");
            }
            sum=0;
        }

JAVA实现

package algorithmProblem;

import java.util.*;

public class bTree112 {
    //静态内部类
    //二叉树节点
    public static class TreeNode{
        int data;
        bTree112.TreeNode leftChild;
        bTree112.TreeNode rightChild;

        public TreeNode(int data) {
            this.data = data;
        }
    }

    /**
     * 前序遍历的链表节点的顺序.来创建二叉树
     * @param inputList
     * @return
     */
    public static bTree112.TreeNode precreatBinaryTree(LinkedList<Integer> inputList){
        bTree112.TreeNode node = null;
        if(inputList==null||inputList.isEmpty()){
            return null;
        }
        Integer data = inputList.removeFirst();
        if(data!=null){
            //根左右。。。。
            node = new bTree112.TreeNode(data);
            node.leftChild=precreatBinaryTree(inputList);
            node.rightChild = precreatBinaryTree(inputList);
        }
        //将根节点返回（用于遍历，不返回根节点，这个树怎么找。。。。。）
        return node;
    }

    /**
     * 前序遍历
     * @param node
     */
    public static void preOrderTraveral(bTree112.TreeNode node){
        if(node==null){
            return;
        }
        System.out.println(node.data);
        preOrderTraveral(node.leftChild);
        preOrderTraveral(node.rightChild);
    }

    public static void dfs(bTree112.TreeNode root, String path, List<String> ans){

        if(root!=null){
            StringBuffer sb = new StringBuffer(path);
            sb.append(root.data);
            if(root.leftChild==null&&root.rightChild==null){
                ans.add(sb.toString());
                return ;
            }else {
                sb.append("->");
                dfs(root.leftChild,sb.toString(),ans);
                dfs(root.rightChild,sb.toString(),ans);
            }
            return ;
        }

    }

    public ArrayList<LinkedList<Integer>> binaryTreePaths(bTree112.TreeNode root) {
        List<String> ans = new ArrayList<>();
        ArrayList<LinkedList<Integer>> list = new ArrayList<LinkedList<Integer>>();
        LinkedList<Integer> mylist = new LinkedList<Integer>();
        dfs(root,"",ans);
        return list;
    }

    public static boolean hasPathSum(TreeNode root, int targetSum) {
        System.out.println("遍历所有路径");
        //1 2 4 0 0 5 0 0 3 0 6
        //ans存储所有的路径
        List<String> ans = new ArrayList<>();
        dfs(root,"",ans);
        int length = 0;
        for (int i =0;i<ans.size();i++){
            //System.out.println(ans.get(i));
            String str = ans.get(i);
            String[] strs=str.split("->");
            System.out.println(Arrays.toString(strs));
            length = Math.max(length,strs.length);

        }
        System.out.println(length);
        int result[][] = new int[ans.size()][length];
        for (int i =0;i<ans.size();i++){
            //System.out.println(ans.get(i));
            String str = ans.get(i);
            String[] strs=str.split("->");
            for (int j =0;j<strs.length;j++){
                result[i][j]= Integer.parseInt(strs[j]);
            }

        }

        int total = targetSum;
        int sum = 0;
        for (int i =0;i<ans.size();i++){
            for (int  j=0;j<result[i].length;j++){
                sum += result[i][j];
            }
            if(sum==total){
                System.out.println("找到了");
                return true;
            }
            if(i==ans.size()-1&&sum!=total){
                System.out.println("没找到");
                return false;
            }
            sum=0;
        }
        return false;
    }

    public static void main(String[] args) {
        //前序创建二叉树
        //LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.asList(new Integer[]{1,2,4,null,null,5,null,null,3,null,6}));
        //LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.asList(new Integer[]{8,5,1,null,null,2,null,null,7}));

        LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.asList(new Integer[]{}));
//        inputList.add(8);
//        inputList.add(5);
//        inputList.add(1);
//        inputList.add(null);
//        inputList.add(null);
//        inputList.add(2);
//        inputList.add(null);
//        inputList.add(null);
//        inputList.add(7);
        System.out.println("请按照前序输入二叉树节点:");
        Scanner in =new Scanner(System.in);
        int a=0;
        Scanner sc = new Scanner(System.in);
        String inputString = sc.nextLine();
        String stringArray[] = inputString.split(" ");
        int num[] = new int[stringArray.length];
        for (int i = 0; i < stringArray.length; i++) {
            if(Integer.parseInt(stringArray[i])==0){
                inputList.add(null);
            }else {
                inputList.add(Integer.parseInt(stringArray[i]));
            }
        }

        System.out.println("二叉树构建成功！");

        bTree112.TreeNode treeNode = precreatBinaryTree(inputList);

        System.out.println("前序遍历如下：");
        preOrderTraveral(treeNode);


        System.out.println("遍历所有路径");
        //1 2 4 0 0 5 0 0 3 0 6
        //ans存储所有的路径
        List<String> ans = new ArrayList<>();
        dfs(treeNode,"",ans);
        int length = 0;
        for (int i =0;i<ans.size();i++){
            //System.out.println(ans.get(i));
            String str = ans.get(i);
            String[] strs=str.split("->");
            System.out.println(Arrays.toString(strs));
            length = Math.max(length,strs.length);

        }
        System.out.println(length);
        int result[][] = new int[ans.size()][length];
        for (int i =0;i<ans.size();i++){
            //System.out.println(ans.get(i));
            String str = ans.get(i);
            String[] strs=str.split("->");
            for (int j =0;j<strs.length;j++){
                result[i][j]= Integer.parseInt(strs[j]);
            }

        }

        int total = 8;
        int sum = 0;
        for (int i =0;i<ans.size();i++){
            for (int  j=0;j<result[i].length;j++){
                sum += result[i][j];
            }
            if(sum==total){
                System.out.println("找到了");
            }
            if(i==ans.size()-1&&sum!=total){
                System.out.println("没找到");
            }
            sum=0;
        }

        //System.out.println(hasPathSum(treeNode,8));


    }
}

在这里插入图片描述
找和为8的路径，找到了。（1，2，5）
在这里插入图片描述

力扣提交

力扣代码如下：

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {

    public static void dfs(TreeNode root, String path, List<String> ans){

        if(root!=null){
            StringBuffer sb = new StringBuffer(path);
            sb.append(root.val);
            if(root.left==null&&root.right==null){
                ans.add(sb.toString());
                return ;
            }else {
                sb.append("->");
                dfs(root.left,sb.toString(),ans);
                dfs(root.right,sb.toString(),ans);
            }
            return ;
        }

    }

    public boolean hasPathSum(TreeNode root, int targetSum) {
        System.out.println("遍历所有路径");
        //1 2 4 0 0 5 0 0 3 0 6
        //ans存储所有的路径
        List<String> ans = new ArrayList<>();
        dfs(root,"",ans);
        int length = 0;
        for (int i =0;i<ans.size();i++){
            //System.out.println(ans.get(i));
            String str = ans.get(i);
            String[] strs=str.split("->");
            System.out.println(Arrays.toString(strs));
            length = Math.max(length,strs.length);

        }
        System.out.println(length);
        int result[][] = new int[ans.size()][length];
        for (int i =0;i<ans.size();i++){
            //System.out.println(ans.get(i));
            String str = ans.get(i);
            String[] strs=str.split("->");
            for (int j =0;j<strs.length;j++){
                result[i][j]= Integer.parseInt(strs[j]);
            }

        }

        int total = targetSum;
        int sum = 0;
        for (int i =0;i<ans.size();i++){
            for (int  j=0;j<result[i].length;j++){
                sum += result[i][j];
            }
            if(sum==total){
                System.out.println("找到了");
                return true;
            }
            if(i==ans.size()-1&&sum!=total){
                System.out.println("没找到");
                return false;
            }
            sum=0;
        }
        return false;
    }
}

在这里插入图片描述
在这里插入图片描述

求路径（中间一段）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

C++实现

#include <iostream>
#include <cstring>
using namespace std;
const int N = 10010;
int T[N];
int dis;
int p[N];

int a[] = {0, 8, 5, 7, 1, 2};

void printPath(int j){
	for(int i = 0; i <= j; i ++){
		if(p[i] == 0){
            continue;
        }
        printf("%d ", p[i]);
	}
	printf("\n");
	return;
}

void findPath(int i, int j, int d, int length){
	if (a[i] == dis){
		printf("%d\n", a[i]);
		return;
	}
	d += a[i];
	p[j] = a[i];
	if (d == dis){
		
		printPath(j);
		return;
	}
	if (d < dis){
		if(2 * i <= length){
			findPath(2 * i, j + 1, d, length);
		}
		if(2 * i + 1 <= length){
			findPath(2 * i + 1, j + 1, d, length);
		}
	}
	return;
	
}

int main(){
	scanf("%d", &dis);
	int length = 5;
	for(int i = 1; i <= length; i ++){
		memset(p, 0, sizeof p);
		findPath(i, 0, 0, length);
	}
    system("pause");
}

在这里插入图片描述

打印根节点到任意节点的路径

在这里插入图片描述
例如1 到18路径为：1 9 14 15 17 18

JAVA实现

package algorithmProblem;

import java.util.*;

public class bTree112Re {
    //静态内部类
    //二叉树节点
    public static class TreeNode{
        int data;
        bTree112Re.TreeNode leftChild;
        bTree112Re.TreeNode rightChild;

        public TreeNode(int data) {
            this.data = data;
        }
    }

    /**
     * 前序遍历的链表节点的顺序.来创建二叉树
     * @param inputList
     * @return
     */
    public static bTree112Re.TreeNode precreatBinaryTree(LinkedList<Integer> inputList){
        bTree112Re.TreeNode node = null;
        if(inputList==null||inputList.isEmpty()){
            return null;
        }
        Integer data = inputList.removeFirst();
        if(data!=null){
            //根左右。。。。
            node = new bTree112Re.TreeNode(data);
            node.leftChild=precreatBinaryTree(inputList);
            node.rightChild = precreatBinaryTree(inputList);
        }
        //将根节点返回（用于遍历，不返回根节点，这个树怎么找。。。。。）
        return node;
    }

    /**
     * 前序遍历
     * @param node
     */
    public static void preOrderTraveral(bTree112Re.TreeNode node){
        if(node==null){
            return;
        }
        System.out.println(node.data);
        preOrderTraveral(node.leftChild);
        preOrderTraveral(node.rightChild);
    }

    public static void dfs(bTree112Re.TreeNode root, String path, List<String> ans){

        if(root!=null){
            StringBuffer sb = new StringBuffer(path);
            sb.append(root.data);
            if(root.leftChild==null&&root.rightChild==null){
                ans.add(sb.toString());
                return ;
            }else {
                sb.append("->");
                dfs(root.leftChild,sb.toString(),ans);
                dfs(root.rightChild,sb.toString(),ans);
            }
            return ;
        }

    }

    public ArrayList<LinkedList<Integer>> binaryTreePaths(bTree112Re.TreeNode root) {
        List<String> ans = new ArrayList<>();
        ArrayList<LinkedList<Integer>> list = new ArrayList<LinkedList<Integer>>();
        LinkedList<Integer> mylist = new LinkedList<Integer>();
        dfs(root,"",ans);
        return list;
    }


    /**
     * 打印根节点到任意节点的路径
     * @param root 根引用（指针）
     * @param rootData 根节点数据值
     * @param leafData 任意子节点数据值
     * @return
     */
    public static LinkedList<Integer> findPath(bTree112Re.TreeNode root, int rootData,int leafData) {
        System.out.println("遍历所有路径");
        //1 2 4 0 0 5 0 0 3 0 6
        //ans存储所有的路径
        List<String> ans = new ArrayList<>();
        dfs(root,"",ans);
        int length = 0;
        for (int i =0;i<ans.size();i++){
            //System.out.println(ans.get(i));
            String str = ans.get(i);
            String[] strs=str.split("->");
            System.out.println(Arrays.toString(strs));
            length = Math.max(length,strs.length);

        }
        //System.out.println(length);
        int result[][] = new int[ans.size()][length];
        for (int i =0;i<ans.size();i++){
            //System.out.println(ans.get(i));
            String str = ans.get(i);
            String[] strs=str.split("->");
            for (int j =0;j<strs.length;j++){
                result[i][j]= Integer.parseInt(strs[j]);
            }
        }

        int start = rootData;
        int end = leafData;
        LinkedList<Integer> resultList = new LinkedList<Integer>();
        for (int i =0;i<ans.size();i++){
            resultList.clear();
            int path = 100000;
            for (int  j=0;j<result[i].length;j++){
                //sum += result[i][j];
                if(start==result[i][j]){
                    resultList.add(result[i][j]);
                    path = j;
                }
                if(path<j){
                    resultList.add(result[i][j]);
                }
                if(end==result[i][j]){
                    return resultList;
                }

            }
        }
        return null;
    }

    public static void main(String[] args) {
        //前序创建二叉树
        //LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.asList(new Integer[]{1,2,4,null,null,5,null,null,3,null,6}));
        //LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.asList(new Integer[]{8,5,1,null,null,2,null,null,7}));

        LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.asList(new Integer[]{}));
//        inputList.add(8);
//        inputList.add(5);
//        inputList.add(1);
//        inputList.add(null);
//        inputList.add(null);
//        inputList.add(2);
//        inputList.add(null);
//        inputList.add(null);
//        inputList.add(7);
        System.out.println("请按照前序输入二叉树节点:");
        Scanner in =new Scanner(System.in);
        int a=0;
        Scanner sc = new Scanner(System.in);
        String inputString = sc.nextLine();
        String stringArray[] = inputString.split(" ");
        int num[] = new int[stringArray.length];
        for (int i = 0; i < stringArray.length; i++) {
            if(Integer.parseInt(stringArray[i])==0){
                inputList.add(null);
            }else {
                inputList.add(Integer.parseInt(stringArray[i]));
            }
        }

        System.out.println("二叉树构建成功！");

        bTree112Re.TreeNode treeNode = precreatBinaryTree(inputList);

        System.out.println("前序遍历如下：");
        preOrderTraveral(treeNode);


        LinkedList<Integer> list = new LinkedList<Integer>();

        Scanner sin =new Scanner(System.in);
        int exit=0;
        int rootData=0;
        int leafData=0;
        while (exit!=-1){

            System.out.println("请输入起始查找节点的值");
            rootData=sin.nextInt();//输入一个整数

            System.out.println("请输结束位置节点的值");
            leafData=sin.nextInt();//输入一个整数

            list = findPath(treeNode,rootData,leafData);
            if(list!=null){
                System.out.print("路径为: ");
                for (int i =0;i<list.size();i++){
                    System.out.print(list.get(i)+" ");
                }
            }else {
                System.out.println("路径不存在.....请重新输入");
            }

            System.out.println("如果退出，请输入-1......");
            System.out.println("如果继续查找，按任意键继续.....");
            exit=sin.nextInt();//输入一个整数
            System.out.println("请继续输入节点值...");
        }



    }
}

在这里插入图片描述
在这里插入图片描述

二叉树的路径和
└┼﹡keep it simple,stupid■┐＊…
12-10 172
给定一棵二叉树和一个和，确定该树是否有根到叶的路径，以便将路径上的所有值相加等于给定的值，这就是路径和。其中的叶指的是叶结点(没有孩子)。代码首先，定义结点信息：struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} };...
129.求根到叶子节点数字之和(给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。)
Adyczb的博客
10-29 829
129.求根到叶子节点数字之和 给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。 例如，从根到叶子节点路径 1->2->3 代表数字 123。 计算从根到叶子节点生成的所有数字之和。 说明: 叶子节点是指没有子节点的节点。 ...
二叉树的路径
xiaoshe的专栏
04-14 1080
1，二叉树所有路径 来源：257. 二叉树的所有路径 从根节点到叶子节点的路径，使用回溯思想，代码如下： class Solution { public: vector<string> binaryTreePaths(TreeNode* root) { vector<string> result; visit(root, "", &result); return result; } void vi
二叉树之路径
qq_43218521的博客
09-30 819
二叉树之路径
5.C-数据结构-二叉树
09-19
在计算机科学中，二叉树是一种常见的数据结构，用于组织和存储数据以便于执行高效的查找、插入和删除操作。二叉树的每个节点最多有两个子节点，通常被称为左子节点和右子节点。这种数据结构之所以称为“二叉”，是...
数据结构课程设计报告-最短路径算法-二叉树的三种遍历.docx
06-28
数据结构课程设计报告的核心主题是实现最短路径算法，...以上就是“数据结构课程设计报告-最短路径算法-二叉树的三种遍历”所涵盖的主要知识点，它不仅涵盖了图论和算法的理论知识，也强调了实际编程和问题解决的能力。
数据结构-树和二叉树篇.html
最新发布
12-29
树和二叉树的数据结构在算法设计中扮演着核心的角色，从基础的遍历算法到复杂的平衡二叉树、红黑树等高级结构，都在数据处理和存储领域中发挥着巨大作用。理解并掌握树和二叉树的基本概念与操作，对于学习高级数据...
数据结构-二叉树基础.pdf
04-15
### 数据结构之二叉树基础知识点详解 #### 一、二叉树基本概念 **二叉树**是一种特殊的树形结构，在计算机科学中被广泛应用于数据存储和检索中。二叉树具有以下特点： 1. **节点（Node）**：二叉树中的每一个元素...
二叉树路径问题
qq_35985044的博客
07-04 606
问题分类 二叉树路径的问题大致可以分为两类： 1、自顶向下： 顾名思义，就是从某一个节点(不一定是根节点)，从上向下寻找路径，到某一个节点(不一定是叶节点)结束 具体题目如下： 257. 二叉树的所有路径 面试题 04.12. 求和路径 112. 路径总和 113. 路径总和 II 437. 路径总和 III 988. 从叶结点开始的最小字符串 而继续细分的话还可以分成一般路径与给定和的路径 2、非自顶向下： 就是从任意节点到任意节点的路径，不需要自顶向下 124. 二叉树中的最大路径和 687. 最
二叉树的所有路径
qq_56012214的博客
05-08 1046
提示：兰有秀兮菊有芳，怀佳人兮不能忘
二叉树之路径问题
StackOverflow的博客
10-14 306
1.二叉树的所有路径 Leetcode 257；medium； 二叉树的路径问题很常见，递归的思路不难理解，但也需要手写过程熟悉思路！ package tree; import java.util.ArrayList; import java.util.List; public class Main0257二叉树的所有路径 { public static void main(String[]...
二叉树的路径问题
weixin_53310322的博客
02-25 440
二叉树的路径问题1.二叉树的所有路径 1.二叉树的所有路径 二叉树的所有路径 递归+回溯 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeN
leet-code 所有二叉树路径问题
yanerhao的专栏
06-06 489
二叉树路径的问题大致可以分为两类： 1、自顶向下： 顾名思义，就是从某一个节点(不一定是根节点)，从上向下寻找路径，到某一个节点(不一定是叶节点)结束 具体题目如下：
数据结构与算法-动态数据结构：二叉树遍历解析
"二叉树遍历-T13.2_数据结构(下) java 经典教程 经典教材" 二叉树遍历是数据结构中的重要概念，特别是对于理解动态数据结构如链表、堆栈、队列以及二叉树等至关重要。在Java编程中，二叉树是一种非线性数据结构，由...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值