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

news2024/11/15 15:29:10

二叉树路径问题

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

二叉树所有路径

在这里插入图片描述
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("请继续输入节点值...");
        }



    }
}

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/138513.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

容器化——Centos下部署最后一版支持Docker的k8s集群

容器化——Centos下部署最后一版支持Docker的k8s集群

部署版本 首先要确定部署的版本 查询Kubernetes对Docker支持的情况 kubernetes/dependencies.yaml at master kubernetes/kubernetes (github.com) 查询Kubernetes Dashboard对Kubernetes支持的情况 Releases kubernetes/dashboard (github.com) 名称版本kubernetes1.23Doc…
阅读更多...
如何对CentOS7配置静态IP

如何对CentOS7配置静态IP

CentOS配置静态IP一、检测配置成功的方法1.虚拟机能访问互联网2.虚拟机和物理机可以相互ping通二、配置步骤1.查看物理机IP2.配置虚拟机网络模式3.设置NAT模式网段4.编辑修改配置文件5.测试三、报错解决方案1.网络重启失败2.ping不通一、检测配置成功的方法 1.虚拟机能访问互联…
阅读更多...
MyBatis的五种批量查询

MyBatis的五种批量查询

一.直接循环插入 RestController RequestMapping("/mybatis3/user") RequiredArgsConstructor public class UserController {private final IUserService iUserService;GetMapping("/one")public Long one(){return iUserService.add();} }Long add();Se…
阅读更多...
intel更新13代桌面处理器产品线，更多核心更贵价格

intel更新13代桌面处理器产品线，更多核心更贵价格

intel 13代酷睿产品线更新带来了更多低于125w TDP的处理器。intel确认了10个65wTDP的SKU和6个35wTDP的SKU。13代酷睿包含新的Raptor Lake和旧的Alder Lake(Refresh)处理器。因为桌面处理器型号序列比较乱&#xff0c;这是SKU命名方式的列表&#xff1a;1XX00KS – 特别(灰烬)版…
阅读更多...
【回答问题】ChatGPT上线了！给我推荐比较流行的音频处理算法模型

【回答问题】ChatGPT上线了！给我推荐比较流行的音频处理算法模型

给我推荐比较流行的音频处理算法模型 音频处理算法模型有很多种&#xff0c;我给你列举一些比较流行的&#xff1a; 声音分类&#xff1a;用于将声音信号分成不同的类别&#xff0c;比如人声、自然声、机器声等。 声音分离&#xff1a;用于从混合的声音信号中分离出单独的声…
阅读更多...
PDF可以转Word吗？3种方法建议收藏

PDF可以转Word吗？3种方法建议收藏

PDF文件是很常见的文件传输格式&#xff0c;大部分的时候我们会将常见的办公文件格式转换成PDF。PDF文件占存较小&#xff0c;传输的速度比较快&#xff0c;而且文件的固定性强&#xff0c;不会轻易发生改动让排版和文本错乱&#xff0c;是很好用的文件格式。但常常对于我们所需…
阅读更多...
乐维监控keycloak单点登录实操（上篇）

乐维监控keycloak单点登录实操（上篇）

Keycloak为Web应用和Restful服务提供了一站式的单点登录解决方案&#xff0c;为登录、注册、用户管理提供了可视化管理界面&#xff0c;用户可以借助于该界面来配置符合自身需要的安全策略和进行用户管理。下面让我们来看看乐维监控如何实现keycloak单点登录&#xff0c;乐维ke…
阅读更多...
反编译Method（反编译类中的方法）

反编译Method（反编译类中的方法）

package com.javase.reflect;import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.util.ResourceBundle;/*** 反编译Method 这里我们暂时还不能获取方法体中的内容* 通过读取属性配置文件来对不同的类进行反编译*/ public class ReflectMethodTe…
阅读更多...
【机器学习】李宏毅-预测PM2.5

【机器学习】李宏毅-预测PM2.5

李宏毅-预测PM2.51 实验目的 巩固课堂所学知识&#xff0c;学习使用Linear Regression中梯度下降预测模型&#xff0c;并将所学运用至实践&#xff0c;根据从空气质量监测网下载的观测数据&#xff0c;使用Linear Regression 预测出空气污染指数(即PM2.5) 的数值。 2 实验要求…
阅读更多...
【算法】超详细哈夫曼编码JAVA解释

【算法】超详细哈夫曼编码JAVA解释

综合实验报告格式 综合实验题目 一、人员和分工 LenckCuak 二、问题描述和基本要求 1、 用哈夫曼编码设计一个压缩软件&#xff1b; 2、 能对输入的任何类型的文件进行哈夫曼编码&#xff0c;产生编码后的文件——压缩文件&#xff1b; 3、 能对输入的压缩文件进行译码&…
阅读更多...
【机器学习】李宏毅-食物图像分类器

【机器学习】李宏毅-食物图像分类器

李宏毅-食物图像分类器1 实验目的 掌握使用Pytorch的使用方法&#xff1a; Pytorch的安装以及环境搭建Pytorch处理数据Pytorch计算梯度以及搭建神经网络Pytorch训练模型 并使用Pytorch来训练CNN模型&#xff0c;实作一个食物的图像分类器。 2 实验要求 可以使用tensorflow或…
阅读更多...
print()函数的使用

print()函数的使用

一、print()函数共三种类型的使用方法二、代码展示
阅读更多...
Excel求解运输问题——以福斯特公司问题为例

Excel求解运输问题——以福斯特公司问题为例

目录 1.1 问题 福斯特问题例 1.2 数学模型 1.3 excel求解 第一步&#xff1a;建立一个工作表 第二步&#xff1a;求解器求解 1.1 问题 运输问题通常出现在计划货物配送机从供给地区到达需求地区之间的服务中&#xff0c;一般供给地区货物数量有限&#xff0c;需求地区货物…
阅读更多...
时间序列分析原理

时间序列分析原理

一、定义 时间序列&#xff0c;是指将某种现象某一个统计指标在不同时间上的各个数值&#xff0c;按时间先后顺序排列而形成的序列 生活中各领域各行业有很多时间序列的数据&#xff0c;销售额&#xff0c;顾客数&#xff0c;访问量&#xff0c;股价&#xff0c;油价&#xff…
阅读更多...
k8s 部署canal admin及server单机服务

k8s 部署canal admin及server单机服务

目录 1. 前言 2. 部署canal-admin 2.1 数据库初始化 2.2 canal-admin k8s yaml部署文件 3. 部署canal-server单机 1. 前言 canal官方文档&#xff1a;https://github.com/alibaba/canal/wiki 主要用途是基于 MySQL 数据库增量日志解析&#xff0c;提供增量数据订阅和消费。…
阅读更多...
一文读懂深度学习中文本处理的4种方式

一文读懂深度学习中文本处理的4种方式

一、序言文本处理方式是深度学习领域中自然语言处理的基础&#xff0c;即把文本转变成计算机识别的语言过程。转变之后才能用算法做后续的文本分析和理解。所以有必要了解文本处理的几种方式&#xff0c;做到对不同的场景采用不同的处理方式。常见的文本处理方式有独热编码(one…
阅读更多...
OSI参考模型与TCP/IP模型比较

OSI参考模型与TCP/IP模型比较

TCP/IP模型 — TCP/IP协议簇 TCP/IP分为两种体系结构&#xff0c;一种是分为四层网络接口层、网络层、传输层和应用层&#xff1b;另外一种是分为五层物理层、数据链路层、网络层、传输层和应用层。这两种体系结构都对。 TCP/IP四层模型 — TCP/IP标准模型 TCP/IP五层模型 — T…
阅读更多...
hive数据仓库搭建

hive数据仓库搭建

一、虚拟机安装CentOS7并配置共享文件夹 二、CentOS 7 上hadoop伪分布式搭建全流程完整教程 三、本机使用python操作hdfs搭建及常见问题 四、mapreduce搭建 五、mapper-reducer编程搭建 六、hive数据仓库安装 hive数据仓库搭建一、hive数据仓库安装1.1下载hive安装包1.2修改配置…
阅读更多...
2022年亚太杯APMCM数学建模大赛C题全球是否变暖求解全过程文档及程序

2022年亚太杯APMCM数学建模大赛C题全球是否变暖求解全过程文档及程序

2022年亚太杯APMCM数学建模大赛 C题 全球是否变暖 为方便各位阅览及了解掌握亚太杯的写作技巧&#xff0c;这里非技术使用中文&#xff0c;公式部分由于翻译过程繁琐使用英文来撰写此文章. 原题再现&#xff1a; 加拿大的49.6C创造了地球北纬50以上地区的气温新纪录&#xf…
阅读更多...
SpringBoot的字符画（banner.txt）

SpringBoot的字符画（banner.txt）

好多小伙伴最近问我如何在启动项目的时候&#xff0c;在控制台打印如下的图案logo 其实很简单&#xff0c;Springboot提供了很方便的操作&#xff0c;在resource目录先新建一个banner.txt 然后将我们想要的图案拼接即可&#xff0c;如下图&#xff1a; 配置完成后正常启动项目…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023