- 博客(41)
- 收藏
- 关注
RSS订阅原创 分红酒（有4个红酒瓶子，它们的容量分别是：9升, 7升, 4升, 2升 开始的状态是 [9,0,0,0]，也就是说：第一个瓶子满着，其它的都空着）
分红酒有4个红酒瓶子，它们的容量分别是：9升, 7升, 4升, 2升开始的状态是 [9,0,0,0]，也就是说：第一个瓶子满着，其它的都空着。允许把酒从一个瓶子倒入另一个瓶子，但只能把一个瓶子倒满或把一个瓶子倒空，不能有中间状态。这样的一次倒酒动作称为1次操作。假设瓶子的容量和初始状态不变，对于给定的目标状态，至少需要多少次操作才能实现？本题就是要求你编程实现最小操作次数的计算。输入：最终状态（逗号分隔）输出：最小操作次数（如无法实现，则输出-1）例如：输入：9,0,0,0应该输出：
2020-08-25 09:23:16
398
原创 城市建设（最小生成树与并查集的应用）
题目描述栋栋居住在一个繁华的C市中，然而，这个城市的道路大都年久失修。市长准备重新修一些路以方便市民，于是找到了栋栋，希望栋栋能帮助他。C市中有n个比较重要的地点，市长希望这些地点重点被考虑。现在可以修一些道路来连接其中的一些地点，每条道路可以连接其中的两个地点。另外由于C市有一条河从中穿过，也可以在其中的一些地点建设码头，所有建了码头的地点可以通过河道连接。栋栋拿到了允许建设的道路的信息，包括每条可以建设的道路的花费，以及哪些地点可以建设码头和建设码头的花费。市长希望栋栋给出一个方案，使得任意两个
2020-08-24 17:54:35
231
原创 并查集及其应用（以POJ1611为例）
The Suspects POJ - 1611Severe acute respiratory syndrome (SARS), an atypical pneumonia of unknown aetiology, was recognized as a global threat in mid-March 2003. To minimize transmission to others, the best strategy is to separate the suspects from others
2020-08-24 12:08:57
186
原创 图的最短路问题之bellman-ford算法
bellman-ford算法： 遍历所有的边，边有起点i和终点j，如果源点到顶点的最短距离d[i]已经算出来，就比较d[j]和d[i]+distance，如果前者比后者大，就可以更新d[j]，如此往复，直到没有数据可更新，这样源点到所有顶点的最短距离就算出来了。代码实现：import java.util.Arrays;public class Main { static int[][] graph = { {0, 2, 5, 0, 0, 0, 0},
2020-08-23 19:39:20
155
原创 最小生成树之Kruskal算法实现(基于并查集)
Kruskal算法简单易懂的描述： 假设有如下图: 将上图按边的权值从小到大排序： 按边的权值从小到大取边加入生成树，注意：最小生成树是不能有环的，所以每取一条边都要检查所取边的两个端点是否在之前取边时都取过，如果都取过则不能取该条边（需要继续往下检查看接下来的边能否取），如果只有一个端点曾经取过，那么这条边依然是可以加入生成树的。当取到的边总数等于顶点总数减1时，最小成生树就生成了。如图：代码实现：边集：/** * 边集的封装 * 边集可以用来表示图 * @param &
2020-08-23 17:45:20
320
原创 图的dfs_二分图着色
把相邻顶点染成不同颜色的问题叫做图的着色问题。对图进行染色所需的最小颜色数,称为最小着色数。 最小着色数为2的图称为二分图。 给定一个具有n个顶点的图，要给图上每个顶点染色，并且要使相邻的顶点的颜色不同、问能否最多用2种颜色进行染色?没有重边和自环。参考代码：import java.util.ArrayList;import java.util.List;//邻接表class GraphNode { public int val; private List<
2020-08-23 13:58:36
297
原创 图的dfs_欧拉道路（打印欧拉道路的路径）
欧拉道路和欧拉回路： 从无向图中的一个结点出发走出一条道路，每条边恰好经过一次，这样的路线称为欧拉道路。 如果一个无向图是连通的，且最多只有两个奇点（度数为奇数），则一定存在欧拉道路。 如果有两个奇点，它们必须是起点和，如果奇点不存在，可以从任意点出发，最终一定会回到该点，称为欧拉回路。参考代码：import java.util.Stack;public class Main { //在递归回溯时把路径依次存入栈中 static Stack<String>
2020-08-23 11:24:04
424
原创 图的dfs_拓扑排序(可以检测出图中是否有环)
图的dfs_拓扑排序(可以检测出图中是否有环)参考代码：public class Main { //顶点数 static final int n = 4; static String[] v = {"a", "b", "c", "d"}; static int[][] graph = { {0, 1, 0, 0}, {0, 0, 0, 0}, {0, 1, 0, 0}, {0
2020-08-23 00:09:02
549
原创 图的dfs_八连通检测(输入一个m行n列的字符矩阵，统计字符“@”组成多少个八连块。如果两个字符“@”所在的格子相邻（横、竖或者对角线方向），就说它们属于同一个八连块)
输入一个m行n列的字符矩阵，统计字符“@”组成多少个八连块。 如果两个字符“@”所在的格子相邻（横、竖或者对角线方向），就说它们属于同一个八连块。参考代码：import java.util.Scanner;public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int M = sc.nextInt();
2020-08-22 21:44:48
661
原创 图的dfs_四连通检测（判断图中的两点是否连通）
给定一个方阵，定义连通：上下左右相邻，并且值相同。可以想象成一张地图，不同的区域被涂以不同颜色。输入：整数N, (N<50)表示矩阵的行列数接下来N行，每行N个字符，代表方阵中的元素接下来一个整数M，(M<1000)表示询问数接下来M行，每行代表一个询问，格式为4个整数，y1,x1,y2,x2，表示询问(第y1行,第x1列) 与 (第y2行,第x2列) 是否连通。连通输出true，否则false例如：10001000000000111000000000111110
2020-08-22 14:11:20
1213
原创 leetcode437路径总和III（给定一个二叉树，它的每个结点都存放着一个整数值。 找出路径和等于给定数值的路径总数）
给定一个二叉树，它的每个结点都存放着一个整数值。找出路径和等于给定数值的路径总数。 路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。 二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。示例：root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8返回 3。和等于 8 的路径有:5 -> 35 -> 2 -> 1-3 -> 1
2020-08-22 09:45:41
983
原创 leetcode1676检查子树(检查子树。你有两棵非常大的二叉树：T1，有几万个节点；T2，有几万个节点。设计一个算法，判断 T2 是否为 T1 的子树)
检查子树。你有两棵非常大的二叉树：T1，有几万个节点；T2，有几万个节点。设计一个算法，判断 T2 是否为 T1 的子树。 如果 T1 有这么一个节点 n，其子树与 T2 一模一样，则 T2 为 T1 的子树，也就是说，从节点 n 处把树砍断，得到的树与 T2 完全相同。示例1:输入：t1 = [1, 2, 3], t2 = [2]输出：true示例2:输入：t1 = [1, null, 2, 4], t2 = [3, 2]输出：false提示：树的节点数目范围为[0, 20000]
2020-08-21 09:46:14
251
原创 leetcode1674首个共同祖先（设计并实现一个算法，找出二叉树中某两个节点的第一个共同祖先。不得将其他的节点存储在另外的数据结构中。注意：这不一定是二叉搜索树）
设计并实现一个算法，找出二叉树中某两个节点的第一个共同祖先。不得将其他的节点存储在另外的数据结构中。注意：这不一定是二叉搜索树。 例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]示例 1:输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1输出: 3解释: 节点 5 和节点 1 的最近公共祖先是节点 3。示例 2:输入: root = [3,5,1,6,2,0,8,null,null
2020-08-21 08:16:34
738
原创 leetcode160后继者（设计一个算法，找出二叉搜索树中指定节点的“下一个”节点（也即中序后继）。 如果指定节点没有对应的“下一个”节点，则返回null）
设计一个算法，找出二叉搜索树中指定节点的“下一个”节点（也即中序后继）。 如果指定节点没有对应的“下一个”节点，则返回null。示例 1:示例 2: 思路： 首先本题中的二叉树还是个二叉搜索树，也就是中序遍历是单调递增的，所以我们可以利用这个性质来简化查找过程。 如果结点 p 的值大于等于 root 的值，说明p 的后继结点在 root 右子树中，那么就递归到右子树中查找。 如果结点 p 的值小于 root 的值，说明 p的后继结点有两种可能，要么在左子树中，要么就是 roo
2020-08-20 15:56:05
323
原创 二叉树中序遍历的递归和非递归形式
其实递归的本质就是入栈和出栈操作，模拟中序遍历时递归形式的栈操作，即可得到二叉树的非递归形式代码。 递归形式： private void inOrder(TreeNode<K, V> p, Consumer<K> con) { if (p != null) { //遍历左子树 inOrder(p.left, con); //处理根节点（处理方式也可以直接把值输出）
2020-08-20 09:20:29
197
原创 leetcode98验证二叉搜索树(给定一个二叉树，判断其是否是一个有效的二叉搜索树)
给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。示例 1:示例 2: 思路：有效的二叉搜索树的中序遍历是一个递增的序列，中序遍历二叉树，在遍历时用一个变量pre来保存当前节点的前一个值（即存放历史序列的最大值），如果接下来遍历的值小于或等于pre，就说明不是有效的二叉搜索树，如果大于pre就用当前值更新pre的值。
2020-08-19 18:59:21
1241
原创 leetcode1670特定深度节点链表(给定一棵二叉树，设计一个算法，创建含有某一深度上所有节点的链表（比如，若一棵树的深度为 D，则会创建出 D 个链表）。返回一个包含所有深度的链表的数组)
给定一棵二叉树，设计一个算法，创建含有某一深度上所有节点的链表（比如，若一棵树的深度为 D，则会创建出 D 个链表）。返回一个包含所有深度的链表的数组。示例： 思路：使用BFS对二叉树进行层次遍历，每层都使用一个链表来存储。ListNode[ ]中的元素存放着每一层的第一个节点。/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; *
2020-08-19 13:30:13
316
原创 leetcode108将有序数组转换为二叉搜索树(将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1)
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。示例:给定有序数组: [-10,-3,0,5,9],一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树： 思路：构造一棵树的过程可以拆分成无数个这样的子问题：构造树的每个节点以及节点之间的关系。对于每个节点来说，都需要：选取节点构造该节点的左子树构造该节点的右子树因题目要求构造一
2020-08-19 09:31:56
178
2
原创 leetcode1671检查平衡性(实现一个函数，检查二叉树是否平衡。在这个问题中，平衡树的定义如下：任意一个节点，其两棵子树的高度差不超过 1)
实现一个函数，检查二叉树是否平衡。在这个问题中，平衡树的定义如下：任意一个节点，其两棵子树的高度差不超过 1。示例 1:示例 2：思路：在求树的高度时就开始判断，只要遇到某个节点的左右子树高度差大于1，就不要继续递归了，可以直接认为整棵树不平衡。 代码实现：/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; *
2020-08-18 19:45:10
267
原创 leetcode129求根到叶子节点数字之和(给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字)
给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。例如，从根到叶子节点路径 1->2->3 代表数字 123。计算从根到叶子节点生成的所有数字之和。说明: 叶子节点是指没有子节点的节点。示例 1:输入: [1,2,3]输出: 25解释:从根到叶子节点路径 1->2 代表数字 12.从根到叶子节点路径 1->3 代表数字 13.因此，数字总和 = 12 + 13 = 25.示例 2:输入: [4,9,0,5,1]
2020-08-18 11:19:39
813
原创 leetcode111 二叉树的最小深度(给定一个二叉树，找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量)
给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。说明: 叶子节点是指没有子节点的节点。示例:给定二叉树 [3,9,20,null,null,15,7],返回它的最小深度 2.思路：叶子节点的定义是左孩子和右孩子都为 null 时叫做叶子节点当 root 节点左右孩子都为空时，返回 1当 root 节点左右孩子有一个为空时，返回不为空的孩子节点的深度当 root 节点左右孩子都不为空时，返回左右孩子较小深度的节点值 代码实现：/*
2020-08-16 17:59:49
800
原创 字典树(前缀树)的简单实现
实现类：public class Trie { private class TrieNode { //元素的序号 int level; //子节点信息 TrieNode[] children = new TrieNode[26]; //是否是最后一个节点 public boolean isLast; //出现的频率 public int fre = 1; }
2020-08-16 14:25:23
149
原创 二叉搜索树(Binary Search Tree)的JAVA实现
节点定义：public class TreeNode<K, V> { //关键字 public K key; //值 public V value; //左孩子节点 public TreeNode<K, V> left; //右孩子节点 public TreeNode<K, V> right; //父节点 public TreeNode<K, V> parent;
2020-08-14 17:41:03
402
原创 树的层次遍历（BFS宽度优先搜索）
思路：先把根节点root加进队列，然后遵循“队头弹出一个节点，队尾加入该节点的所有孩子，循环此操作直至所有节点都弹出”的规律，把弹出的节点依次存入结果列表，最后将列表返回。public class Main { public <E> List<List<TreeNode<E>>> levelOrder(TreeNode<E> x) { //存放结果的list List<List<TreeNod
2020-08-13 10:56:43
301
原创 树的JAVA实现
节点定义import java.util.List;public class TreeNode<E> { //数据 public E key; //父节点 public TreeNode<E> parent; //所有子节点 public List<TreeNode<E>> children; public TreeNode(E key, TreeNode<E> parent) {
2020-08-12 21:09:31
184
原创 猫狗收容所(有家动物收容所只收留猫和狗，但有特殊的收养规则，收养人有两种收养方式，第一种为直接收养所有动物中最早进,入收容所的,第二种为选择收养的动物类型(猫或狗)，并收养该种动物中最早进,入收容所)
有家动物收容所只收留猫和狗，但有特殊的收养规则，收养人有两种收养方式，第一种为直接收养所有动物中最早进,入收容所的,第二种为选择收养的动物类型(猫或狗)，并收养该种动物中最早进,入收容所的。 给定一个操作序列int口[2] ope代表所有事件。 若第一个元素为1，则代表有动物进入收容所，第二个元素为动物的编号，正数代表狗，负数代表猫; 若第一个元素为2，则代表有人收养动物，第二个元素若为0,则采取第一种收养方式(最早),若为1,则指定收养狗，若为-1则指定收养猫。 请按顺序返回收养的序列
2020-08-10 08:37:40
1910
原创 将一个栈内的元素排序，只能再使用一个辅助的栈，不能再使用其他数据结构
将一个栈内的元素排序，只能再使用一个辅助的栈，不能再使用其他数据结构import java.util.ArrayList;import java.util.Stack;public class Main { public ArrayList<Integer> solve(int[] arr) { Stack<Integer> source = new Stack<>(); //将数组中的元素存入栈中 f
2020-08-09 13:54:53
448
原创 leetcode232用栈实现队列（使用栈实现队列的下列操作： push(x) -- 将一个元素放入队列的尾部。 pop() -- 从队列首部移除元素。 peek() -- 返回队列首部的元素 ）
使用栈实现队列的下列操作：push(x) – 将一个元素放入队列的尾部。pop() – 从队列首部移除元素。peek() – 返回队列首部的元素。empty() – 返回队列是否为空。示例:MyQueue queue = new MyQueue();queue.push(1);queue.push(2);queue.peek(); // 返回 1queue.pop(); // 返回 1queue.empty(); // 返回 false说明: 你只能使用标准的栈操作 – 也
2020-08-09 10:56:52
633
原创 leetcode1649堆盘子(堆盘子。设想有一堆盘子，堆太高可能会倒下来。因此，在现实生活中，盘子堆到一定高度时，我们就会另外堆一堆盘子。请实现数据结构SetOfStacks，模拟这种行为)
ens堆盘子。设想有一堆盘子，堆太高可能会倒下来。因此，在现实生活中，盘子堆到一定高度时，我们就会另外堆一堆盘子。请实现数据结构SetOfStacks，模拟这种行为。SetOfStacks应该由多个栈组成，并且在前一个栈填满时新建一个栈。此外，SetOfStacks.push()和SetOfStacks.pop()应该与普通栈的操作方法相同（也就是说，pop()返回的值，应该跟只有一个栈时的情况一样）。 进阶：实现一个popAt(int index)方法，根据指定的子栈，执行pop操作。...
2020-08-08 21:57:14
247
原创 leetcode1648栈的最小值(请设计一个栈，除了常规栈支持的pop与push函数以外，还支持min函数，该函数返回栈元素中的最小值。执行push、pop和min操作的时间复杂度必须为O(1))
请设计一个栈，除了常规栈支持的pop与push函数以外，还支持min函数，该函数返回栈元素中的最小值。执行push、pop和min操作的时间复杂度必须为O(1)。示例：MinStack minStack = new MinStack();minStack.push(-2);minStack.push(0);minStack.push(-3);minStack.getMin(); --> 返回 -3.minStack.pop();minStack.top(); -->
2020-08-07 21:54:52
425
原创 leetcode234回文链表(请判断一个链表是否为回文链表)
请判断一个链表是否为回文链表。示例 1:输入: 1->2输出: false示例 2:输入: 1->2->2->1输出: true进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？思路：可以使用快慢指针和栈的数据结构来解决些题，一开始慢指针slow和快指针fast同时指同第一个节点，然后慢指针每次前进一步，快指针每次前进两步，慢指针前进时把扫过的...
2020-08-06 10:55:04
241
原创 leetcode1645环路检测(给定一个链表，如果它是有环链表，实现一个算法返回环路的开头节点。有环链表的定义：在链表中某个节点的next元素指向在它前面出现过的节点，则表明该链表存在环路)
给定一个链表，如果它是有环链表，实现一个算法返回环路的开头节点。有环链表的定义：在链表中某个节点的next元素指向在它前面出现过的节点，则表明该链表存在环路。示例 1：输入：head = [3,2,0,-4], pos = 1输出：tail connects to node index 1解释：链表中有一个环，其尾部连接到第二个节点。示例 2：输入：head = [1,2], pos = 0输出：tail connects to node index 0解释：链表中有一个环，其尾部连接到第一
2020-08-05 17:19:56
403
原创 leetcode1642链表求和(给定两个用链表表示的整数，每个节点包含一个数位。 这些数位是反向存放的，也就是个位排在链表首部。 编写函数对这两个整数求和，并用链表形式返回结果)
给定两个用链表表示的整数，每个节点包含一个数位。这些数位是反向存放的，也就是个位排在链表首部。编写函数对这两个整数求和，并用链表形式返回结果。这些数位是反向存放的，也就是个位排在链表首部。编写函数对这两个整数求和，并用链表形式返回结果。示例：输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295输出：2 -> 1 -> 9，即912进阶：假设这些数位是正向存放的，请再做一遍。示例：输入：(6 -> 1 -> 7) +
2020-08-05 10:10:07
7037
1
原创 leetcode86分隔链表（给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前）
给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前。你应当保留两个分区中每个节点的初始相对位置。示例:输入: head = 1->4->3->2->5->2, x = 3输出: 1->2->2->4->3->5思路：将链表拆分为两个链表leftHead和rightHead，小于 x 的节点都放在leftHead，大于或等于 x 的节点都放在rightHead，然后将这两个链表连接起来就是答
2020-08-03 18:35:27
495
2
原创 leetcode237删除链表中的节点(请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点)
请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。现有一个链表 - - head = [4,5,1,9]，它可以表示为:示例 1:输入: head = [4,5,1,9], node = 5输出: [4,1,9]解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.示例 2:输入: head = [4,5,1,9], node = 1输出: [4,5,9]解释: 给定你链表中值为 1
2020-08-03 11:07:18
657
原创 leetcode1666返回倒数第 k 个节点(实现一种算法，找出单向链表中倒数第 k 个节点，返回该节点的值)
实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。示例：输入： 1->2->3->4->5 和 k = 2输出： 4说明：给定的 k 保证是有效的。解题思路这是典型的双指针游走题目，设有两个指针 p1，p2 ：初始时，两个指针均指向 head。先将p2向后移动 k 次。此时p1，p2的距离为 k。同时移动 p1，p2, 直到 p2 指向null。此时p1.val即为答案。如下图所示：代码/** * Definition for singly-
2020-08-03 08:42:46
468
原创 leetcode1661移除重复节点（移除未排序链表中的重复节点，保留最开始出现的节点）
编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。示例1:输入：[1, 2, 3, 3, 2, 1]输出：[1, 2, 3]示例2:输入：[1, 1, 1, 1, 2]输出：[1, 2]提示：链表长度在[0, 20000]范围内。链表元素在[0, 20000]范围内。进阶：如果不得使用临时缓冲区，该怎么解决？ 思路：我们最容易想到的就是用集合去重，从链表的头开始遍历，如果在HashSet集合中有出现重复的元素，我们直接过滤（删除）掉 链表节点定义
2020-08-02 23:42:18
638
原创 双链表的java实现
线性表的接口定义/** * 线性表（列表）的接口定义 */public interface MyList { /** * 新增一个元素 * * @param element 要新增的那个元素 */ public void add(Object element); /** * 删除相同元素 * * @param element 要删除的那个元素 */ void delete(Object
2020-08-01 19:03:15
2283
原创 单链表的java实现
线性表的接口定义/** * 线性表（列表）的接口定义 */public interface MyList { /** * 新增一个元素 * * @param element 要新增的那个元素 */ public void add(Object element); /** * 删除相同元素 * * @param element 要删除的那个元素 */ void delete(Object
2020-08-01 14:30:34
160
2
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人