Letcode-Top 100二叉树专题

已于 2024-06-10 19:23:18 修改
阅读量246 收藏
点赞数 3
文章标签： 二叉树
于 2024-06-09 17:07:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43170213/article/details/139563710
版权

94. 二叉树的中序遍历

在这里插入图片描述
方法一：递归法

/**
 * 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 List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> arraylist=new ArrayList<>();
        if(root==null){
            return arraylist;
        }

        Stack<TreeNode> stack=new Stack<TreeNode>();
        TreeNode current=root;
        while(current!=null||!stack.isEmpty()){
            while(current!=null){
                stack.push(current);
                current=current.left;
            }
            current=stack.pop();
            arraylist.add(current.val);
            current=current.right;


        }
        return arraylist;
    }
}

方法二：迭代法

/**
 * 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 List<Integer> inorderTraversal(TreeNode root) {
        // 中序遍历
        List<Integer> res = new ArrayList<Integer>();
        inorderTraversal(root, res);
        return res;
    }

    public void inorderTraversal(TreeNode node, List<Integer> res) {
        if (node == null) {
            return;
        }

        inorderTraversal(node.left, res);
        res.add(node.val);
        inorderTraversal(node.right, res);

    }

}

104. 二叉树的最大深度

在这里插入图片描述
方法一：递归方法

/**
 * 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 int maxDepth(TreeNode root) {
        if(root==null){
            return 0;
        }else {
            int leftLength = maxDepth(root.left)+1;
            int rightLength = maxDepth(root.right)+1;
            return Math.max(leftLength,rightLength);
        }

    }
}

方法二：层序遍历

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        int ans = 0;
        int size = 0;
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while (!queue.isEmpty()) {
            size = queue.size();
            while (size > 0) {
                root = queue.poll();
                if (root.left != null) {
                    queue.offer(root.left);
                }
                if (root.right != null) {
                    queue.offer(root.right);
                }
                size--;
            }
            ans++;
        }

        return ans;

    }
}

226. 翻转二叉树

在这里插入图片描述
方法一：递归

/**
 * 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 int maxDepth(TreeNode root) {
        if(root==null){
            return 0;
        }else {
            int leftLength = maxDepth(root.left)+1;
            int rightLength = maxDepth(root.right)+1;
            return Math.max(leftLength,rightLength);
        }

    }
}

方法二：迭代

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }

        TreeNode node = root;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(node);

        int size = 0;
        while (!queue.isEmpty()) {
            size = queue.size();
            while (size > 0) {
                TreeNode temp = queue.poll();
                TreeNode left = temp.left;
                if (left != null) {
                    queue.offer(left);

                }
                TreeNode right = temp.right;
                if (right != null) {
                    queue.offer(right);

                }
                temp.left = right;
                temp.right = left;
                size--;
            }
        }
        return root;

    }
}

101. 对称二叉树

在这里插入图片描述
方法一：递归

/**
 * 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 boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }

        return isSymmetric(root.left,root.right);

    }



        public boolean isSymmetric(TreeNode left,TreeNode right) {
            if(left==null&&right==null){
                return true;
            }

            if(left==null|| right==null){
                return false;
            }

            if(left.val!=right.val){
                return false;
            }


            return isSymmetric(left.left,right.right)&& isSymmetric(left.right,right.left);

        }

}

方法二：迭代

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }

        return isSymmetric(root.left, root.right);

    }

    public boolean isSymmetric(TreeNode left, TreeNode right) {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(left);
        queue.offer(right);

        while (!queue.isEmpty()) {
            left = queue.poll();
            right = queue.poll();

            if (left == null && right == null) {
                continue;
            }

            if (left == null || right == null || left.val != right.val) {
                return false;
            }

            queue.offer(left.left);
            queue.offer(right.right);

            queue.offer(left.right);
            queue.offer(right.left);

        }

        return true;

    }

}

543. 二叉树的直径

在这里插入图片描述
方法一：递归

class Solution {
    int ans = 0;
    public int diameterOfBinaryTree(TreeNode root) {
        diameterOfBinaryTreePLus(root);
        return ans;


    }


    public int diameterOfBinaryTreePLus(TreeNode root) {
        if(root==null){
            return 0;
        }

        int left =  diameterOfBinaryTreePLus(root.left);
        int right = diameterOfBinaryTreePLus(root.right);
        ans = Math.max(ans,left+right);
        
        return Math.max(left+1,right+1);


    }
}

102. 二叉树的层序遍历

在这里插入图片描述

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        if (root == null) {
            return result;
        }

        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int size = 0;
        while (!queue.isEmpty()) {
            size = queue.size();
            List<Integer> list = new ArrayList<Integer>();

            while (size > 0) {
                TreeNode node = queue.poll();
                list.add(node.val);

                if (node.left != null) {
                    queue.offer(node.left);
                }

                if (node.right != null) {
                    queue.offer(node.right);
                }

                size--;

                if (size == 0) {
                    result.add(list);
                }

            }

        }

        return result;

    }
}

108. 将有序数组转换为二叉搜索树

在这里插入图片描述

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return sortedArrayToBST(nums,0,nums.length-1);
    }


    public TreeNode sortedArrayToBST(int[] nums,int left,int right){
        if(left>right){
            return null;
        }

        int mid = (left+right)/2;

        TreeNode root = new TreeNode(nums[mid]);
        root.left =  sortedArrayToBST(nums,left,mid-1);
        root.right = sortedArrayToBST(nums,mid+1,right);
        return root;

    }
}

98. 验证二叉搜索树

在这里插入图片描述
方法一：递归

初始错误写法

class Solution {
    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }

        if (root.left != null) {
            if (root.left.val >= root.val) {
                return false;
            }
        }

        if (root.right != null) {
            if (root.right.val <= root.val) {
                return false;
            }
        }

        boolean left = isValidBST(root.left);
        boolean right = isValidBST(root.right);
        return left && right;

    }
}

在这里插入图片描述
正确写法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * long val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(long val) { this.val = val; }
 * TreeNode(long val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }

        return isValidBSTPlus(root,Long.MIN_VALUE,Long.MAX_VALUE);

    }


    public boolean isValidBSTPlus(TreeNode root,long min,long max) {
        if (root == null) {
            return true;
        }

        if (root.left != null) {
            if (root.left.val >= root.val) {
                return false;
            }
        }

        if (root.right != null) {
            if (root.right.val <= root.val) {
                return false;
            }
        }

        if(root.val>=max || root.val<=min){
            return false;
        }

        boolean left = isValidBSTPlus(root.left,min,root.val);
        boolean right = isValidBSTPlus(root.right,root.val,max);
        return left && right;

    }
}

方法二：中序遍历

/**
 * 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 boolean isValidBST(TreeNode root) {

        long limit = Long.MIN_VALUE;

        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode currentNode = root;
        while (currentNode != null || !stack.isEmpty()) {
            while (currentNode != null) {
                stack.push(currentNode);
                currentNode = currentNode.left;
            }

            currentNode = stack.pop();
            if (currentNode.val <= limit) {
                return false;
            }

            limit = currentNode.val;
            currentNode = currentNode.right;
        }

        return true;

    }
}

230. 二叉搜索树中第K小的元素

在这里插入图片描述
方法一：排序

class Solution {
    List<Integer> list = new ArrayList<>();
    public int kthSmallest(TreeNode root, int k) {
        sort(root);
        return list.get(k-1);
    }

    void sort(TreeNode root){
        if(root==null){
            return;
        }

        sort(root.left);
        list.add(root.val);
        sort(root.right);



    }
}

方法二：迭代

/**
 * 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 int kthSmallest(TreeNode root, int k) {

        TreeNode curNode = root;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while (!stack.isEmpty()||curNode!=null) {
            while (curNode != null) {
                stack.push(curNode);
                curNode = curNode.left;
            }

            curNode = stack.pop();
            k--;
            if (k == 0) {
                return curNode.val;
            }

            curNode = curNode.right;


        }
        return curNode.val;
    }
}

199. 二叉树的右视图

在这里插入图片描述
方法一：层序遍历

/**
 * 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 List<Integer> rightSideView(TreeNode root) {

        List<Integer> result = new ArrayList<Integer>();
        if (root == null) {
            return result;
        }

        TreeNode curNode = root;
        // 层序遍历
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(curNode);
        int size = 0;
        while (!queue.isEmpty()) {
            size = queue.size();
            while (size > 0) {
                curNode = queue.poll();

                if (curNode.left != null) {
                    queue.offer(curNode.left);
                }

                if (curNode.right != null) {
                    queue.offer(curNode.right);
                }
                size--;

                if (size == 0) {
                    result.add(curNode.val);
                }
            }
        }
        return result;

    }
}

方法二：深度遍历 （根 右 左）

/**
 * 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 {

    List<Integer> result = new ArrayList<Integer>();

    public List<Integer> rightSideView(TreeNode root) {
        sort(root, 0);
        return result;
    }

    public void sort(TreeNode root, Integer length) {
        if (root == null) {
            return;
        }

        if (length == result.size()) {
            result.add(root.val);
        }

        length++;
        sort(root.right, length);
        
        sort(root.left, length);
    }
}

105. 从前序与中序遍历序列构造二叉树

在这里插入图片描述
方法一：递归方法

class Solution {
    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 recur(0,0,inorder.length-1);
    }

    TreeNode recur(int root,int left,int right){
        if(left>right){
            return null;
        }

        TreeNode node = new TreeNode(preorder[root]);
        int i = dic.get(preorder[root]);
        node.left = recur(root+1,left,i-1);
        node.right = recur(root+i-left+1,i+1,right);
        return node;

    }


}

方法二：迭代方法
暂时放弃

迭代方法

437. 路径总和 III

在这里插入图片描述
方法一：常规迭代

/**
 * 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 int pathSum(TreeNode root, int targetSum) {
        if(root==null){
            return 0;
        }

        int ret = rootSum(root,targetSum);
        ret += pathSum(root.left,targetSum);
        ret += pathSum(root.right,targetSum);
        return ret;

    }

    public int rootSum(TreeNode root, long targetSum) {
        int ret = 0;

        if (root == null) {
            return 0;
        }

        int val = root.val;
        if (val == targetSum) {
            ret++;
        }

        ret += rootSum(root.left, targetSum - val);
        ret += rootSum(root.right, targetSum - val);
        return ret;

    }
}

方法二：前缀法

前缀和Letcode链接


/**
 * 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 {
    Map<Long, Integer> prefixMap;
    int target;

    public int pathSum(TreeNode root, int targetSum) {
        prefixMap = new HashMap<>();
        target = targetSum;
        prefixMap.put(0l, 1);
        return recur(root, 0l);

    }

    private int recur(TreeNode node, Long curSum) {
        if (node == null) {
            return 0;
        }

        int res = 0;
        curSum += node.val;

        res += prefixMap.getOrDefault(curSum - target, 0);
        prefixMap.put(curSum, prefixMap.getOrDefault(curSum, 0) + 1);

        int left = recur(node.left, curSum);
        int right = recur(node.right, curSum);

        res = res + left + right;

        prefixMap.put(curSum, prefixMap.get(curSum) - 1);
        return res;

    }
}

236. 二叉树的最近公共祖先

在这里插入图片描述
方法：
核心思路：

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    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){
            return root;
        }

        if(left!=null){
            return left;
        }

        if(right!=null){
            return right;
        }

        return null;

    }
}
丘山一郎
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode跳跃-leetcode-top:leetcode-top
06-30
leetcode-top 记录使用 C++ 刷 leetcode 可使用浏览器页面搜索功能「Ctrl + F / Command + F」 定位题目 进度 点击题号 跳转leetcode 点击题目 跳转解法 题号 题目 难度 备注 easy medium medium medium medium ...
leetcode算法题主函数如何写-leetcode-top_100:leetcode-top_100
06-30
leetcode-top_100 1. 两数之和 问题：给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用...
leetcode-二叉树专题
apple_53406386的博客
05-14 291
【代码】leetcode-二叉树专题
leetcode200题之二叉树专题（二）
ttdss12345678的博客
08-07 126
1. 二叉树的前序、中序、后序遍历 （1）递归解决：根据前序遍历根左右，中序遍历左根右，后序遍历左右根即可。 class Solution { public: vector<int> res; vector<int> preorderTraversal(TreeNode* root) { if(root==nullptr) return {}; recur(root); return res; }
leetcode200题之二叉树专题（四）
ttdss12345678的博客
08-13 163
1. 最大的二叉树 创建方法 construct(nums, l, r)，用于找出在数组 numsnums 中从 ll 到 rr 索引（不包含第 rr 个位置）中最大二叉树的根节点。 算法步骤如下： 首先调用 construct(nums, 0, n)，其中 n是数组 numsnums 的长度。 在索引范围 (l:r−1) 内找到最大值的索引，将 nums[max_idx] 作为根节点。 调用 construct(nums, l, max_idx) 创建根节点的左孩子。递归执行此操作，创建根节点.
★[leetCode] 二叉树专题
weixin_43810348的博客
05-05 791
二叉树的层序遍历 使用一个队列来访问即可，注意每一层的元素个数可以在一开始访问该层的时候，用队列里面的元素个数来表示出来 public class Solution { public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> res =new ArrayList<>(); Queue<TreeNode>
LeetCode 二叉树专题
karry_zzj的博客
06-01 160
这是整理的LeetCode上的二叉树专题，按照codeTop上的频率顺序从高到低进行整理。
zwangZJU#LeetCode-in-python-wznote#LeetCode-python-104-二叉树的最大深度1
07-25
示例解题思路最大的深度是左子树或右子树中深度中更大的一个+1，递归的在子树的子树中寻找代码实现Definition for a binary tree node
leetcode怎么销号-LeetCode-Top-Interview-Questions:LeetCode-Top-Interview-Qu
06-30
leetcode怎么销号 LeetCode便签 Linked List Cycle 问题描述 Given a linked list, determine if it has a cycle in it. Follow up:Can you solve it without using extra space? 解决思路 声明一个慢指针和一个快...
LeetCode-Hot-100
03-25
《LeetCode-Hot-100》是针对程序员面试中热门的100道LeetCode题目集合，主要涉及C++编程语言。LeetCode是一个在线平台，提供了一系列算法问题，旨在帮助开发者提升编程技能，尤其是面试准备阶段。这些题目涵盖了数据...
开发教程文档.docx
08-14
1. Java简介 Java是一门由Sun Microsystems公司于1995年推出的高级编程语言。它具有跨平台的特性，能够在多种操作系统（如Windows、Mac OS和各种Unix版本）上运行。Java的最大特点是“一次编写，到处运行”，这得益于Java虚拟机（JVM）的存在。 2. 环境搭建 在开始Java编程之前，需要先搭建开发环境。你需要安装Java开发工具包（JDK）和一个集成开发环境（IDE），比如IntelliJ IDEA或Eclipse。JDK是Java开发的核心，包括了编译器和标准类库，而IDE则为你提供了一个方便的开发界面。 3. 基本语法 学习Java的第一步是掌握它的基本语法。你需要了解如何定义变量、使用基本数据类型、控制程序流程（如条件语句和循环语句）以及如何定义和使用函数。这些基础知识是编写任何Java程序的基础。 java public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!
全球车载支付服务行业总体规模、主要企业国内外市场占有率及排名（2024版）.docx
08-14
全球车载支付服务行业总体规模、主要企业国内外市场占有率及排名（2024版）.docx
【独家首发】基于斑点鬣狗优化算法SHO-GMDH的锂电池寿命SOC估计算法研究Matlab实现.rar
08-14
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
鲸发卡v11.61发卡系统源码-开心修复版
08-14
鲸发卡系统在发卡圈几乎人人皆知，市面最好发卡系统之一，操作简单界面操作通俗易懂，系统主页UI已进行更换，非市面烂大街首页！ 我们替换了三套最新版模板，详情请看下面图片，市面上所谓的11.61版本就是这，只是改了版本号，新增三套模板。 非常重要的一点是，我们发现此模板使用后，首页首次加在有点慢，原因是首页美化代码的原因，其他页面基本正常，有能力的可以吧图片等资源文件上传到oss等第三方平台 含4套PC端首页模板，含4套手机端首页模板（3套与PC端相同） 修复功能 1、短链接生成，重置 2、客户端新版本UI 3、邀请码无限重复生成(以前的版本后台不?关闭，现在可以了)
ssm_148_mysql_商品信息分类管理系统_.zip
08-14
1、某些模块的代码结构冗余，代码执行效率差，经过思考发现可以使用面向对象思想中的继承和多态进行改进。 2、数据库的设计较为单一，并且书写SQL查询语句时只用了连接查询和相关子查询等，这会造成查询较多数据时查询速度慢的问题。改进的方法就是使用存储过程和视图来替代复杂的查询语句。 3、用户的注册和登录未与QQ或者微信进行连接，这方面的知识自己比较欠缺，但经过了解后发现只要在支付宝和微信的官网下载相关的接口与自己系统进行连接就有可能实现真正的相关账户登录。
基于Android点餐叫号系统设计与实现.docx
08-14
基于Android点餐叫号系统设计与实现.docx
人工智能与机器学习概论+神经网络基础理论+深度学习框架与工具+Transformer模型原理与结构+自注意力机制详解等教程
08-14
人工智能与机器学习概论 神经网络基础理论 深度学习框架与工具 Transformer模型原理与结构 自注意力机制详解 Transformer在自然语言处理中的应用 序列到序列模型与Transformer Transformer的训练与优化技巧 Transformer变体：BERT模型深度解析 Transformer变体：GPT模型深度解析 Transformer变体：T5模型深度解析 Transformer在计算机视觉中的应用 Transformer在语音识别中的应用 Transformer在推荐系统中的应用 Transformer未来趋势与研究方向
【独家首发】基于黑猩猩优化算法Chimp-GMDH的锂电池寿命SOC估计算法研究Matlab实现.rar
最新发布
08-14
【独家首发】基于黑猩猩优化算法Chimp-GMDH的锂电池寿命SOC估计算法研究Matlab实现.rar
基于Android五子棋设计与实现.docx
08-14
基于Android五子棋设计与实现.docx
idea leetcode-edito乱码
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值