- 博客(143)
- 收藏
- 关注
RSS订阅原创 MFC将二维数组写入文件中并进行读取
当前项目需要将二维数组写入到本地文件中，并在另一个对话框中进行读取。网上查了很多资料，基本都是写字符串到文件中的，想依葫芦画瓢仿照字符串的写法来写二维数组，发现在写文件状态下，能够正常的将字符串写入，但在读文件状态下，读出来的数据两个字符之间总会插入一个**‘/0’**,后面经过测试，发现是用CString作为缓冲区类型导致的，使用DOUBLE **就能规避。下面代码演示将二维数组写入文件中，并进行读取，读取内容显示在MessageBox上。
2023-06-27 08:58:52
917
原创 LeetCode# 131 分割回文串
给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。public class Solution { public List<List<String>> partition(String s) { int len = s.length(); List<List<String>> res = new ArrayList<>(); if (len == 0) {
2020-12-10 10:07:28
105
原创 LeetCode#130 被围绕的区域
给定一个二维的矩阵，包含 ‘X’ 和 ‘O’（字母 O）。找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。方法一：深度优先遍历+递归算法class Solution { public void solve(char[][] board) { if (board == null || board.length == 0) return; int m = board.length; int n = board[0]
2020-12-07 15:08:45
121
原创 #109 有序链表转换二叉搜索树
给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。方法一：递归算法+二分法用快慢指针找到链表中间节点，再分别对中间节点左右两边进行递归建树。class Solution { public TreeNode sortedListToBST(ListNode head) { if (head == null) { return null;
2020-12-07 14:26:13
85
原创 LeetCode#124 二叉树中的最大路径和
给定一个非空二叉树，返回其最大路径和。本题中，路径被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。方法一：递归算法+贪心算法int max = Integer.MIN_VALUE; public int maxPathSum(TreeNode root) { if (root == null) { return 0; } dfs(root);
2020-12-06 16:11:22
71
原创 LeetCode#99 恢复二叉搜索树
给你二叉搜索树的根节点 root ，该树中的两个节点被错误地交换。请在不改变其结构的情况下，恢复这棵树。进阶：使用 O(n) 空间复杂度的解法很容易实现。你能想出一个只使用常数空间的解决方案吗？方法一：中序遍历+指针用中序遍历的方式遍历这颗二叉搜索树，我们增加一个辅助的pre指针，记录 上一个 节点的值。如果 当前节点的值，小于 上一个节点的值，这就找到了需要交换的节点。利用这种方式，就不需要额外的数组空间了。class Solution { //用两个变量x，y来记录需要交换的节点
2020-12-06 15:25:42
67
原创 LeetCode#199 二叉树的右视图
给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。方法一：层序遍历标准层序遍历，取每组最后一个数添加到总集合中即可。class Solution { public List<Integer> rightSideView(TreeNode root) { List<Integer> res = new ArrayList<>(); if(root == null)return res;
2020-12-04 09:13:07
55
原创 LeetCode#129 求根到叶子节点数字之和
给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。例如，从根到叶子节点路径 1->2->3 代表数字 123。计算从根到叶子节点生成的所有数字之和。说明: 叶子节点是指没有子节点的节点。方法一：递归+回溯class Solution { List<Integer> reslist = new ArrayList<>(); public int sumNumbers(TreeNode root) {
2020-12-04 08:42:16
56
原创 LeetCode#117 填充每个节点的下一个右侧节点指针II
给定一个二叉树struct Node {int val;Node *left;Node *right;Node *next;}填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。方法一：普通层序遍历与#116做法一致，但效率偏低，这里不做演示。方法二：升级层序遍历class Solution { public Node connect(Node
2020-12-03 10:23:11
48
原创 LeetCode#116 填充每个节点的下一个右侧节点指针
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：struct Node {int val;Node *left;Node *right;Node *next;}填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。方法一：层序遍历典型层序遍历步骤，只不过在将该节点左右子树推入队列之前将每一层遍历节点进行连接。clas
2020-12-03 09:41:42
82
原创 LeetCode#114 二叉树展开为链表
给定一个二叉树，原地将它展开为一个单链表。方法一：前序遍历将二叉树展开为单链表之后，单链表中的节点顺序即为二叉树的前序遍历访问各节点的顺序。因此，可以对二叉树进行前序遍历，获得各节点被访问到的顺序。由于将二叉树展开为链表之后会破坏二叉树的结构，因此在前序遍历结束之后更新每个节点的左右子节点的信息，将二叉树展开为单链表。class Solution { public void flatten(TreeNode root) { List<TreeNode> li
2020-12-01 12:56:07
63
原创 LeetCode#98 验证二叉搜索树
给定一个二叉树，判断其是否是一个有效的二叉搜索树。假设一个二叉搜索树具有如下特征：节点的左子树只包含小于当前节点的数。节点的右子树只包含大于当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1:输入:2/ 1 3输出: true示例 2:输入:5/ 1 4/ 3 6输出: false解释: 输入为: [5,1,4,null,null,3,6]。根节点的值为 5 ，但是其右子节点值为 4 。方法一：中序遍历递归class Solution {
2020-11-29 09:20:56
77
原创 LeetCode#95 不同的二叉搜索树II
给定一个整数 n，生成所有由 1 … n 为节点所组成的 二叉搜索树 。示例：输入：3输出：[[1,null,3,2],[3,2,null,1],[3,1,null,null,2],[2,1,3],[1,null,2,null,3]]解释：以上的输出对应以下 5 种不同结构的二叉搜索树：1 3 3 2 1\ / / / \ 3 2 1 1 3 2/
2020-11-26 10:22:37
42
原创 LeetCode#108 将有序数组转换为二叉搜索树
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。示例:给定有序数组: [-10,-3,0,5,9],一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树： 0 / \-3 9/ /-10 5方法一：深度优先遍历构造二叉搜索树只需要在升序数组中找到任意一位数作为根节点即可，该数左边作为左子树，该数右边作为右子树。题目要求高度平
2020-11-24 10:38:42
44
原创 LeetCode#111 二叉树的最小层数
给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。说明：叶子节点是指没有子节点的节点。示例1：输入：root = [3,9,20,null,null,15,7]输出：2示例 2：输入：root = [2,null,3,null,4,null,5,null,6]输出：5方法一：广度优先遍历class Solution { public int minDepth(TreeNode root) { if (root == n
2020-11-24 10:12:01
185
原创 LeetCode#107 二叉树的层次遍历II
给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）例如：给定二叉树 [3,9,20,null,null,15,7],3/ 9 20/ 15 7返回其自底向上的层次遍历为：[[15,7],[9,20],[3]]方法一：广度优先遍历因为输出的倒序，因此可以考虑使用堆来倒序输出。class Solution { public List<List<Integer>> levelOrde
2020-11-22 10:38:36
52
原创 LeetCode#100 相同的树
给定两个二叉树，编写一个函数来检验它们是否相同。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。示例 1:输入: 1 1/ \ / 2 3 2 3 [1,2,3], [1,2,3]输出: true示例 2:输入: 1 1/ 2 2 [1,2], [1,null,2]输出: false示例 3:输入:
2020-11-21 10:51:34
51
原创 LeetCode#57 插入区间
给出一个无重叠的 ，按照区间起始端点排序的区间列表。在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。示例 1：输入：intervals = [[1,3],[6,9]], newInterval = [2,5]输出：[[1,5],[6,9]]示例 2：输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]输出：[[1,2],[3,10],[12,16]]解释：
2020-11-18 12:13:13
49
原创 LeetCode#179 最大数
给定一组非负整数 nums，重新排列它们每位数字的顺序使之组成一个最大的整数。注意：输出结果可能非常大，所以你需要返回一个字符串而不是整数。示例 1：输入：nums = [10,2]输出：“210”示例 2：输入：nums = [3,30,34,5,9]输出：“9534330”示例 3：输入：nums = [1]输出：“1”示例 4：输入：nums = [10]输出：“10”方法一：自定义Comparator（贪心算法）两个元素进行拼接比较，若str1+str2 > st
2020-11-18 10:46:40
68
原创 LeetCode#148 排序链表
给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。进阶：你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？示例 1：输入：head = [4,2,1,3]输出：[1,2,3,4]示例 2：输入：head = [-1,5,3,4,0]输出：[-1,0,3,4,5]示例 3：输入：head = []输出：[]方法一：分治法分：将链表分为一个一个，通过递归实现。治：一个一个比较，小的排在前面，通过动态规划实现（比递归快了一倍）
2020-11-17 12:48:21
60
原创 LeetCode#147 对链表进行插入排序
插入排序算法：插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。重复直到所有输入数据插入完为止。示例 1：输入: 4->2->1->3输出: 1->2->3->4示例 2：输入: -1->5->3->4->0输出: -1->0->3->4->5遍历链表，当当前元素大于下一个元素时，维护
2020-11-17 10:46:54
74
原创 LeetCode#75 颜色分类
给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。注意:不能使用代码库中的排序函数来解决这道题。示例:输入: [2,0,2,1,1,0]输出: [0,0,1,1,2,2]方法一：快速排序直接套公式class Solution { public void sortColors(int[] nums) { quickSort(
2020-11-16 15:05:56
47
原创 LeetCode#56 合并区间
给出一个区间的集合，请合并所有重叠的区间。示例 1:输入: intervals = [[1,3],[2,6],[8,10],[15,18]]输出: [[1,6],[8,10],[15,18]]解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].示例 2:输入: intervals = [[1,4],[4,5]]输出: [[1,5]]解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。注意：输入类型已于2019年4月15日更改。 请重置默认代码定义以获取新方法
2020-11-16 11:13:47
63
原创 LeetCode#135 分发糖果
老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。你需要按照以下要求，帮助老师给这些孩子分发糖果：每个孩子至少分配到 1 个糖果。相邻的孩子中，评分高的孩子必须获得更多的糖果。那么这样下来，老师至少需要准备多少颗糖果呢？示例 1:输入: [1,0,2]输出: 5解释: 你可以分别给这三个孩子分发 2、1、2 颗糖果。示例 2:输入: [1,2,2]输出: 4解释: 你可以分别给这三个孩子分发 1、2、1 颗糖果。第三个孩子只得到 1 颗
2020-11-13 12:19:17
51
原创 LeetCode#45 跳跃游戏
给定一个非负整数数组，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。你的目标是使用最少的跳跃次数到达数组的最后一个位置。示例:输入: [2,3,1,1,4]输出: 2解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。方法一：贪心算法维护能到达的最远坐标，并且只有在到达边界值才进行跳跃。class Solution { public int jump(int[] num
2020-11-13 10:52:20
58
原创 LeetCode#122 买卖股票的最佳时机
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。示例 1:输入: [7,1,5,3,6,4]输出: 7解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6
2020-11-11 17:10:10
143
原创 LeetCode#134 加油站
在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。说明:如果题目有解，该答案即为唯一答案。输入数组均为非空数组，且长度相同。输入数组中的元素均为非负数。示例 1:输入:gas = [1,2,3,4,5]cost = [3,4,5,1,2]输出:
2020-11-11 10:14:13
48
原创 LeetCode#55 跳跃游戏
给定一个非负整数数组，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个位置。示例 1:输入: [2,3,1,1,4]输出: true解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。示例 2:输入: [3,2,1,0,4]输出: false解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。方法一：贪心算法维护
2020-11-10 10:57:05
64
原创 LeetCode#378 有序矩阵中第k小的元素
给定一个 n x n 矩阵，其中每行和每列元素均按升序排序，找到矩阵中第 k 小的元素。请注意，它是排序后的第 k 小元素，而不是第 k 个不同的元素。示例：matrix = [[ 1, 5, 9],[10, 11, 13],[12, 13, 15]],k = 8,返回 13。方法一：小根堆class Solution { public int kthSmallest(int[][] matrix, int k) { PriorityQueue<int
2020-11-10 09:08:34
88
原创 LeetCode#373 查找和最小的K对数字
给定两个以升序排列的整形数组 nums1 和 nums2, 以及一个整数 k。定义一对值 (u,v)，其中第一个元素来自 nums1，第二个元素来自 nums2。找到和最小的 k 对数字 (u1,v1), (u2,v2) … (uk,vk)。示例 1:输入: nums1 = [1,7,11], nums2 = [2,4,6], k = 3输出: [1,2],[1,4],[1,6]解释: 返回序列中的前 3 对数：[1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6
2020-11-09 10:40:02
173
原创 LeetCode#347 前K个高频元素
给定一个非空的整数数组，返回其中出现频率前 k 高的元素。示例 1:输入: nums = [1,1,1,2,2,3], k = 2输出: [1,2]示例 2:输入: nums = [1], k = 1输出: [1]跟一般的求最大值方法类似，唯一区别就是需要维护一个int数组，分别记录当前数和当前数字的次数，并建立一个小根堆，用次数跟小根堆顶进行比较，存放拥有最大的k个次数的数组，遍历堆，将数组第一项——数字本身加入到返回数组中。class Solution { public int[
2020-11-05 13:40:23
74
原创 LeetCode#313 超级丑数
编写一段程序来查找第 n 个超级丑数。超级丑数是指其所有质因数都是长度为 k 的质数列表 primes 中的正整数。示例:输入: n = 12, primes = [2,7,13,19]输出: 32解释: 给定长度为 4 的质数列表 primes = [2,7,13,19]，前 12 个超级丑数序列为：[1,2,4,7,8,13,14,16,19,26,28,32] 。方法一：动态规划维护一个数组index，用来记录最小值的当前索引，其余跟普通丑数一样算法。class Solution {
2020-11-04 09:23:27
53
原创 LeetCode#394 字符串解码
给定一个经过编码的字符串，返回它解码后的字符串。编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。示例 1：输入：s = “3[a]2[bc]”输出：“aaabcbc”示例 2：输入：s = “
2020-11-02 11:37:50
54
原创 LeetCode#385 迷你语法分析器
给定一个用字符串表示的整数的嵌套列表，实现一个解析它的语法分析器。列表中的每个元素只可能是整数或整数嵌套列表提示：你可以假定这些字符串都是格式良好的：字符串非空字符串不包含空格字符串只包含数字0-9、[、-、,、]示例 1：给定 s = “324”,你应该返回一个 NestedInteger 对象，其中只包含整数值 324。示例 2：给定 s = “[123,[456,[789]]]”,返回一个 NestedInteger 对象包含一个有两个元素的嵌套列表：一个 integer 包
2020-11-01 12:17:37
188
1
原创 LeetCode#331 验证二叉树的前序序列化
序列化二叉树的一种方法是使用前序遍历。当我们遇到一个非空节点时，我们可以记录下这个节点的值。如果它是一个空节点，我们可以使用一个标记值记录，例如 #。 _9_/ \3 2/ \ / 4 1 # 6/ \ / \ / \# # # #例如，上面的二叉树可以被序列化为字符串 “9,3,4,#,#,1,#,#,2,#,6,#,#”，其中 # 代表一个空节点。给定一串以逗号分隔的序列，验证它是否是正确的二叉树的前序序列化。编写一个在不重构树的条件下的可行算法。每
2020-10-30 11:25:20
222
原创 LeetCode#316 去除重复字母
给你一个字符串 s ，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证 返回结果的字典序最小（要求不能打乱其他字符的相对位置）。注意：该题与 1081 https://leetcode-cn.com/problems/smallest-subsequence-of-distinct-characters 相同方法一：栈+贪心用栈来存储最终返回的字符串，并维持字符串的最小字典序。每遇到一个字符，如果这个字符不存在于栈中，就需要将该字符压入栈中。但在压入之前，需要先将之后还会出现，并且字典序比当
2020-10-30 10:17:00
170
原创 LeetCode#173 二叉搜索迭代器
实现一个二叉搜索树迭代器。你将使用二叉搜索树的根节点初始化迭代器。调用 next() 将返回二叉搜索树中的下一个最小的数。示例：BSTIterator iterator = new BSTIterator(root);iterator.next(); // 返回 3iterator.next(); // 返回 7iterator.hasNext(); // 返回 trueiterator.next(); // 返回 9iterator.hasNext(); // 返回 tr
2020-10-29 13:41:23
40
原创 LeetCode#150 逆波兰表达式
根据 逆波兰表示法，求表达式的值。有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。说明：整数除法只保留整数部分。给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。示例 1：输入: [“2”, “1”, “+”, “3”, “*”]输出: 9解释: 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9示例 2：输入: [“4”, “13”, “5”, “/”, “+”]输出: 6解释:
2020-10-27 09:46:50
71
原创 LeetCode#225 用队列实现栈
使用队列实现栈的下列操作：push(x) – 元素 x 入栈pop() – 移除栈顶元素top() – 获取栈顶元素empty() – 返回栈是否为空方法一：用一个队列实现先记下队列的原始长度，再把x加入队列尾部，并将x前面的元素全部取出并加入到队列尾部，实现翻转。此时第一个出队的即为栈顶元素。class MyStack { Queue<Integer> queue; /** Initialize your data structure here. */ p
2020-10-24 14:03:37
37
原创 LeetCode#155 最小栈
设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。push(x) —— 将元素 x 推入栈中。pop() —— 删除栈顶的元素。top() —— 获取栈顶元素。getMin() —— 检索栈中的最小元素。import java.util.Stack;class MinStack { Stack<Integer> stack1; Stack<Integer> stack2; /** initialize your
2020-10-23 16:52:30
46
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人