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

2023-10-27

二叉树路径问题

二叉树所有路径
找到一个和为sum的到达叶子节点的路径
求路径（中间一段）
- C++实现
打印根节点到任意节点的路径
- JAVA实现

二叉树所有路径

分析

前序遍历二叉树+递归实现回溯
深度优先搜索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("请继续输入节点值...");
        }



    }
}

在这里插入图片描述

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

数据结构和算法

数据结构

深度优先

Java

数据结构---二叉树路径问题的相关文章

在 Java 中捕获（捕获）窗口中的鼠标光标

我正在寻找一种方法在鼠标进入窗口后捕获或捕获该窗口中的鼠标就像鼠标被捕获在虚拟机窗口中一样直到用户按 CTRL ALT DEL 或以其他方式释放鼠标我如何在 Java 中实现这一点全屏显示不是一个选择 EDIT 这里有一些 SSC
“JSONArray 文本必须在 null 的第 1 个字符处以 '[' 开头”

只是想知道这个错误可能意味着什么我从下面的代码中得到它 try JSONArray jArray new JSONArray result for int i 0 i
使用 java 删除 XML 根的子级

这是我的 xml 文件
如何在ArrayList中的特定位置插入对象

假设我有一个大小为 n 的对象的 ArrayList 现在我想在特定位置插入另一个对象假设在索引位置 k 大于 0 且小于 n 并且我希望索引位置 k 处及其之后的其他对象向前移动一个索引位置那么有没有什么方法可以直接在Java中做到这
Java，顺序流在哪个线程中执行？

在阅读有关流的文档时我遇到了以下句子 attempting to access mutable state from behavioral parameters presents you with a bad choice if you
Hashset - 创建 Set 后使对象相同

如果我们在 HashSet 中添加两个不同的对象可变的然后通过调用 setter 更改对象的值使它们相同则大小仍然是 hashSet 的 2 我无法理解其原因 public static void main String args
H2数据库：如何进行加密保护，而不暴露文件加密密钥

我们在服务器模式下使用Java H2数据库因为我们不希望用户访问数据库文件为了对数据库文件添加更多保护我们计划使用 AES 加密将 CIPHER AES 添加到数据库 URL 以防存储被盗但是每个用户在连接时还需要提供文件保护密
获取Android库中的上下文

我正在编写一个 Android 应用程序它的一些功能封装在内部库中但是要使此功能发挥作用库需要一个应用程序上下文的实例为图书馆提供这种上下文的最佳方式是什么我看到了一些选择但没有一个有吸引力 Have my library c
使用全局变量从内部函数获取空字符串

请帮助我解决一些小问题我确信你能做到 D 我试图在 firestore 文档 user cases information 上设置一个字段其中包含一个字段 case number 首先我声明这个全局变量 private String c
如何避免Eclipse在将类名放在注释中时导入类，以便checkstyle稍后不会抱怨？

有时我将类名放在方法或类的注释中只是为了引用但是 Eclipse 会自动执行导入并在文件中留下导入语句这会导致稍后出现未使用的导入检查样式错误当我在注释中输入类名时是否可以更改一些配置以避免 Eclipse 自动导入人们不同意
绘制平滑曲线

我想创建更平滑的曲线而不仅仅是线角这是我现在画的图这是我的代码 case FREEHAND float pts float ptk ptk new float 2 imageMatrix invert inv if mCurrentS
for循环中更新JLabel的问题

我的程序的想法是从之前在其他 JFrame 中保存的列表中选择一个名称我想在标签中一个接一个地打印所有名称它们之间有很小的延迟然后停在其中一个名称上问题是lbl setText String 如果有多个则不起作用setText co
如何在 Eclipse 中获得完全限定的类名？

有没有一种快速方法可以在 Eclipse 中单击 Java 类并获取其完全限定名称或将其复制到剪贴板 2016年6月29日编辑正如 Jeff 所指出的您只需要执行以下第二步 1 Double click on the class na
从 CLI 部署 Maven 项目？

在 IDE 中构建并运行良好 cd home thufir NetBeansProjects HelloMaven JAVA HOME usr lib jvm java 8 openjdk amd64 home thufir local s
RxJava android mvp 单元测试 NullPointerException

我是 mvp 单元测试的新手我想对演示者进行一个非常基本的测试它负责登录我只想断言 view onLoginSuccess 这是演示者代码 public LoginPresenter LoginViewContract loginVi
如何使用 Java 在 selenium webdriver 中打开新选项卡或如何使用使用 selenium webdriver 的操作类在 selenium 中按 ctrl +T [重复]

这个问题在这里已经有答案了如何使用 Java 在 Selenium Webdriver 中按 CTRL T 或者如何使用 Java 在 selenium webdriver 中打开新选项卡简单步骤 1 打开google com 不必触
了解Kafka流groupBy和window

我无法理解 kafka 流中的 groupBy groupById 和窗口的概念我的目标是聚合一段时间内例如 5 秒的流数据我的流数据看起来像 value 0 time 1533875665509 value 10 time 153
无法连接到docker中的elasticsearch容器

我正在尝试使用 docker 的官方 elasticsearch 镜像我遵循了本指南 https www elastic co guide en elasticsearch reference current docker html但是当
Spring - 如何在不匹配列名的情况下使用 BeanPropertyRowMapper

我正在开发一个应用程序该应用程序已使用行映射器从纯 JDBC 转换为 Spring 模板我遇到的问题是数据库中的列与属性名称不匹配这阻止我使用BeanPropertyRowMapper容易地我看到一些关于在查询中使用别名的帖子这会
在java中执行匿名pl/sql块并获取结果集

我想执行匿名 PL SQL 并需要获取结果集对象我得到了可以通过在 PL SQL 块内使用游标来完成的代码但 PL SQL 块本身将以文本形式来自数据库所以我无法编辑该 PL SQL 块并且它只会返回两个值其列名始终相同它将返回

随机推荐

Java项目:网上电商项目(前后端分离+java+vue+Springboot+ssm+mysql+maven+redis)

源码获取博客首页资源里下载一项目简述本系统功能包括一款基于Springboot Vue的电商项目前后端分离项目前台后台都有前台商品展示购买购物车分类订单查询等等后台商品管理订单管理信息维护用户管理等等本期
【第十四届蓝桥杯三月真题刷题训练——第 11 天（3.14）& 卡片 & 路径 & 字符统计 & 费用报销】

第一题卡片问题描述小蓝有很多数字卡片每张卡片上都是数字0到9 小蓝准备用这些卡片来拼一些数他想从1开始拼出正整数每拼一个就保存起来卡片就不能用来拼其它数了小蓝想知道自己能从1拼到多少例如当小蓝有30张卡片其中0到9各
解决Could not load dynamic library 'libcudart.so.10.0'; dlerror: libcudart.so.10.0: cannot open ...

安装TensorFlow2 0 GPU版本后检测是否支持GPU时tf test is gpu available 出现以下信息 2019 11 19 02 52 53 934654 W tensorflow stream executor
Maven下载jar是关联源码

好多用 Maven 的时候会遇到这样一个棘手的问题就是添加依赖后由于没有下载并关联源码导致自动提示无法出现正确的方法名而且不安装反编译器的情况下不能进入方法内部看具体实现其实 eclipse 的 Maven 插件就提供了这个功能但
pycharm运行不报错，用cmd运行code报错

1 pycharm运行不报错用cmd运行code报错可以参考 Pycharm里面都能运行为什么在CMD中就不能运行解决方法将要执行的模块或者 py文件加入环境变量中 import sys sys path append 需要导入的
day08-JS组成和基本结构（补充）/网页引入JS的三种方式/JavaScript核心语法

0目录 1 JS组成和基本结构补充 2 网页引入JS三种方式 3 JavaScript核心语法 1 JS组成和基本结构补充 1 5 JavaScript执行原理第一步用户端发送请求到服务器端第二步将JS解析出来的数据用户身份标
asp.net core ABP模板本地化设置

ABP的语言本地化设置非常方便甚至地区图标ABP框架都已经有了先看看结果吧英文的界面中文的界面配置流程如下首先在Localization目录下新建一个对应的json文件里面存放对应变量的本地化字符串命名规则就是应用名本地
ThreadLocal 原理总结

1 首先看了 Java并发编程深入剖析ThreadLocal 这篇文章这篇文章首先用用一个数据库连接的例子如多个线程同时进行连接和关闭数据库操作有可能会导致某个线程刚打开的数据库连接操作被另一个线程打开的数据库关闭操作给关闭了然
Hyperledger Fabric区块链浏览器搭建

最近在用Hyperledger Fabric平台做一个项目要使用区块链浏览器以下是我的基础环境的情况以及搭建过程版本 Ubuntu 22 04 1 LTS 运行内存 8 0 GiB 处理器 Intel Core i7 8700 CPU
“对象创建”模式——构建器

动机在软件系统中有时候面临着一个复杂对象的创建工作其通常由各个部分的子对象用一定的算法构成由于需求的变化这个复杂对象的各个部分经常面临着剧烈的变化但是将它们组合在一起的算法却相对稳定如何应对这种变化如何提供一种封装机制
SqlServer的for xml path函数

这两天在处理一个字符串拼接遇到一个问题老师姓名学科张老师语文张老师数学张老师英语李老师体育李老师音乐需要将上面的记录转换成老师姓名学科张老师语文数学英语李老师体育音乐想了一些办法来处理都感觉不
zabbix 之脚本实现企业微信报警及报警升级

文章目录一微信报警一对被检测主机创建指定监控项和触发器二注册企业微信三 zabbix服务段配置四 web监控界面媒介告警配置五验证二报警升级一微信报警目的被监控主机test01的mysql服务不可用时立即发送
kaggle操作入门

pip install kaggle kaggle gt Account gt API gt Create New API Token 下载得到 kaggle json 文件 Linux 存放到 home xxx kaggle 中 xxx表
【软考】-高项-范围管理-重要知识点思维导图

范围管理文章目录范围管理产品范围项目范围范围蔓延镀金范围潜变范围蔓延范围管理计划含义包含内容需求管理内容需求管理计划含义包含内容作用可指导收集需求工具与技术访谈麦肯锡方法含义分类结构化非结构
C++中运算重载和定时器函数的实现

一概念 1 在operate函数内实现你想实现的具体的运算操作这样一来不单单只可以对普通的数进行加减操作可以对类进行加减操作在operate函数内实现的加减的具体实现过程就可以 2 运算符重载就是对已有的运算符重新进行定义赋予其
shell脚本系列：10、快速上手bash脚本：简单有效的shell脚本示例

shell脚本系列 10 快速上手bash脚本简单有效的shell脚本示例文章目录 shell脚本系列 10 快速上手bash脚本简单有效的shell脚本示例前言 1 hello world 2 使用echo打印 3 使用注释 4
python利用matplotlib进行可视化

利用matplotlib进行可视化 1 Matplotlib 基本介绍 Matplotlib 是一个在 python 下实现的类 matlab 的纯 python 的第三方库旨在用 python实现matlab 的功能是python下最
Flutter Json对象和数组解析成实体类

1 解析json对象准备一个json 对象数据 String json res true age 12 Name 张三使用JSON to Dart 工具自动生成实体类也可以自己手动写工具地址 JSON to Dart 将代码复制到类
TCP标志位 FIN和RST的区别

大家都知道TCP释放连接需要四次挥手主动释放端会发送FIN包并且因为TCP是双工的关闭一个方向上的数据流从而TCP连接处于半关闭状态这也是为什么需要四次挥手的原因以上所述四次挥手是一种有序释放即标志位为FIN的TCP报
数据结构---二叉树路径问题

二叉树路径问题二叉树所有路径分析 JAVA实现力扣提交找到一个和为sum的到达叶子节点的路径分析 JAVA实现力扣提交求路径中间一段 C 实现打印根节点到任意节点的路径 JAVA实现二叉树所有路径 257二叉树所有路径

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

二叉树路径问题

二叉树所有路径

分析

JAVA实现

力扣提交

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

分析

JAVA实现

力扣提交

求路径（中间一段）

C++实现

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

JAVA实现

数据结构---二叉树路径问题 的相关文章

随机推荐

热门标签

数据结构---二叉树路径问题的相关文章