qq_24447809的博客

复制测试用例数据：[1,2,3,null,null,4,5],根据此用例生成二叉树。代码#include <iostream>#include<string>#include <sstream>#include<vector>#include<queue>using namespace std;struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeN

给出一个字符串数组words组成的一本英语词典。从中找出最长的一个单词，该单词是由words词典中其他单词逐步添加一个字母组成。若其中有多个可行的答案，则返回答案中字典序最小的单词。若无答案，则返回空字符串。示例 1：输入： words = [“w”,“wo”,“wor”,“worl”, “world”]输出：“world”解释： 单词"world"可由"w", “wo”, “wor”, 和 "worl"添加一个字母组成。示例 2：输入： words = [“a”, “banana”,

题目不使用任何内建的哈希表库设计一个哈希集合，具体地说，你的设计应该包含以下的功能add(value)：向哈希集合中插入一个值。contains(value) ：返回哈希集合中是否存在这个值。remove(value)：将给定值从哈希集合中删除。如果哈希集合中没有这个值，什么也不做。示例:MyHashSet hashSet = new MyHashSet();hashSet.add(1);hashSet.add(2);hashSet.contains(1); // 返回 true

给定一个非空特殊的二叉树，每个节点都是正数，并且每个节点的子节点数量只能为 2 或 0。如果一个节点有两个子节点的话，那么该节点的值等于两个子节点中较小的一个。更正式地说，root.val = min(root.left.val, root.right.val) 总成立。给出这样的一个二叉树，你需要输出所有节点中的第二小的值。如果第二小的值不存在的话，输出 -1 。迭代版本根据题意，根节点的值就是最小值，建立一个队列，只有小于等于根节点的节点才放进队列处理，另一个节点的值暂时存为secon

递归版本虽然简单快速,但破坏了原本两颗树的结构/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public: TreeNo

给定一个 N 叉树，找到其最大深度。最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。例如，给定一个我们应返回其最大深度，3。说明:树的深度不会超过 1000。树的节点总不会超过 5000。递归（深搜）class Solution {public: int maxDepth(Node* root) { if(!root) return 0; int n=root->children.size();

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。示例 :给定二叉树返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。注意：两结点之间的路径长度是以它们之间边的数目表示。递归/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * Tr

给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。假定 BST 有如下定义：结点左子树中所含结点的值小于等于当前结点的值结点右子树中所含结点的值大于等于当前结点的值左子树和右子树都是二叉搜索树例如：给定 BST [1,null,2,2],提示：如果众数超过1个，不需考虑输出顺序进阶：你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不被计算在内）思路二叉搜索树的中序遍历是递增序列。普通中序遍历/** * Definition fo

给定两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。示例 1:输入: nums1 = [4,1,2], nums2 = [1,3,4,2].输出: [-1,3,-1]解释:对于num1中的数字4，你无法在第二个数组中找到下一个更大的数字，因

给定一个整数，编写一个算法将这个数转换为十六进制数。对于负整数，我们通常使用 补码运算 方法。注意:十六进制中所有字母(a-f)都必须是小写。十六进制字符串中不能包含多余的前导零。如果要转化的数为0，那么以单个字符'0'来表示；对于其他情况，十六进制字符串中的第一个字符将不会是0字符。 给定的数确保在32位有符号整数范围内。不能使用任何由库提供的将数字直接转换或格式化为十六进制的方法。示例 1：输入: 26输出: “1a”示例 2：输入:-1输出: “ffffffff”位运算

题目二进制手表顶部有 4 个 LED 代表 小时（0-11），底部的 6 个 LED 代表 分钟（0-59）。每个 LED 代表一个 0 或 1，最低位在右侧。例如，上面的二进制手表读取 “3:25”。给定一个非负整数 n 代表当前 LED 亮着的数量，返回所有可能的时间。示例：输入: n = 1返回: [“1:00”, “2:00”, “4:00”, “8:00”, “0:01”, “0:02”, “0:04”, “0:08”, “0:16”, “0:32”]提示：输出的顺序没有要求。

不使用运算符 + 和 - ​​​​​​​，计算两整数 ​​​​​​​a 、b ​​​​​​​之和。示例 1:输入: a = 1, b = 2输出: 3示例 2:输入: a = -2, b = 3 输出: 1位运算a^b异或运算，可以在各位中计算没有进行进位计算的值；比如1010^0101 = 1111;1011^0111 =1100; //略去了第1,2位1+1的进位；(a&b)<<1可以算出进位的值；(1011&0111) << 1

给定两个数组，编写一个函数来计算它们的交集。示例 1：输入：nums1 = [1,2,2,1], nums2 = [2,2] 输出：[2]示例 2：输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4] 输出：[9,4]两个unordered_set 用法unordered_set 是无序存放，但查找更加效率。class Solution {public: vector<int> intersection(vector<int>&a

给定一个整数数组 nums，求出数组从索引 i 到 j (i ≤ j) 范围内元素的总和，包含 i, j 两点。示例：给定 nums = [-2, 0, 3, -5, 2, -1]，求和函数为 sumRange()sumRange(0, 2) -> 1sumRange(2, 5) -> -1sumRange(0, 5) -> -3说明:你可以假设数组不可变。会多次调用 sumRange 方法。hash表用map表存所有的（i,j）的区域和，但会超出时间限制cl

你和你的朋友，两个人一起玩 Nim 游戏：桌子上有一堆石头，每次你们轮流拿掉 1 - 3 块石头。 拿掉最后一块石头的人就是获胜者。你作为先手。你们是聪明人，每一步都是最优解。 编写一个函数，来判断你是否可以在给定石头数量的情况下赢得游戏。示例:输入: 4 输出: false 解释: 如果堆中有 4 块石头，那么你永远不会赢得比赛；因为无论你拿走 1 块、2 块 还是 3 块石头，最后一块石头总是会被你的朋友拿走。DPdp[i]表示i个石子时是否能获胜。转移方程：dp[i]=!(dp[i

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。示例1:输入: pattern = “abba”, str = “dog cat cat dog”输出: true示例 2:输入:pattern = “abba”, str = “dog cat cat fish”输出: false示例 3:输入: pattern = “aaa.

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。示例:输入: [0,1,0,3,12] 输出: [1,3,12,0,0]暴力版本class Solution {public: void moveZeroes(vector<int>& nums) { vector<int>::iterator it; it=nums.begin(); int n=nums.siz.

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。示例:给定 n = 5，并且 ver.

给定一个包含 0, 1, 2, …, n 中 n 个数的序列，找出 0 … n 中没有出现在序列中的那个数。示例 1:输入: [3,0,1] 输出: 2示例 2:输入: [9,6,4,2,3,5,7,0,1] 输出: 8排序法class Solution {public: int missingNumber(vector<int>& nums) { sort(nums.begin(),nums.end()); if(nums[0].

编写一个程序判断给定的数是否为丑数。丑数就是只包含质因数 2, 3, 5 的正整数。示例 1:输入: 6 输出: true 解释: 6 = 2 × 3示例 2:输入: 8 输出: true 解释: 8 = 2 × 2 × 2示例 3:输入: 14 输出: false 解释: 14 不是丑数，因为它包含了另外一个质因数 7。class Solution {public: bool isUgly(int num) { if(num<=0) .

给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。示例:输入: 38 输出: 2 解释: 各位相加的过程为：3 + 8 = 11, 1 + 1 = 2。 由于 2 是一位数，所以返回 2。递归class Solution {public: int addDigits(int num) { if(num/10==0) return num; int cur=0; while(num)

给定一个二叉树，返回所有从根节点到叶子节点的路径。说明: 叶子节点是指没有子节点的节点。DFS深度优先搜索，暴力搜索每一个节点的分支/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {}

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。示例 1:输入: s = “anagram”, t = “nagaram” 输出: true示例 2:输入: s = “rat”, t = “car” 输出: false说明: 你可以假设字符串只包含小写字母。sort排序class Solution {public: bool isAnagram(string s, string t) { int slen=s.size();

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]示例 1:输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 输出: 6 解释: 节点 2

请判断一个链表是否为回文链表。示例 1:输入: 1->2 输出: false示例 2:输入: 1->2->2->1 输出: true数组判断/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class S

给定一个整数，编写一个函数来判断它是否是 2 的幂次方。示例 1:输入: 1 输出: true 解释: 20 = 1示例 2:输入: 16 输出: true 解释: 24 = 16示例 3:输入: 218 输出: false版本1class Solution {public: bool isPowerOfTwo(int n) { if(n<=0) return false; if(n==1)

给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。示例 1:输入: nums = [1,2,3,1], k = 3 输出: true示例 2:输入: nums = [1,0,1,1], k = 1 输出: true示例 3:输入: nums = [1,2,3,1,2,3], k = 2 输出: falsemap映射class Solution {public:

翻转一棵二叉树。队列队列对每一层节点，交换左右节点。/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public: T

给定一个整数数组，判断是否存在重复元素。如果任意一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。示例 1:输入: [1,2,3,1] 输出: true示例 2:输入: [1,2,3,4] 输出: false示例 3:输入: [1,1,1,3,3,4,3,2,4,2] 输出: trueset映射class Solution {public: bool containsDuplicate(vector<int>&amp

反转一个单链表。示例:输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULLstack栈利用栈的后进先出特性。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL

给定两个字符串 s 和 t，判断它们是否是同构的。如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。示例 1:输入: s = “egg”, t = “add” 输出: true示例 2:输入: s = “foo”, t = “bar” 输出: false示例 3:输入: s = “paper”, t = “title” 输出: true标题class So

统计所有小于非负整数 n 的质数的数量。示例:输入: 10 输出: 4 解释: 小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。暴力法class Solution {public: bool prime(int n) { for(int i=2;i*i<=n;i++) { if(n%i==0) return false; } retu

删除链表中等于给定值 val 的所有节点。示例:输入: 1->2->6->3->4->5->6, val = 6 输出: 1->2->3->4->5简单删除注意头结点的处理和节点回收。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) :

编写一个算法来判断一个数 n 是不是快乐数。「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。如果 n 是快乐数就返回 True ；不是，则返回 False 。示例：输入：19 输出：true 解释： 12 + 92 = 82 82 + 22 = 68 62 + 82 = 100 12 + 02 + 02= 1Hashclass Solutio

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。示例 1：输入：[1,2,3,1] 输出：4 解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。偷窃到的最高金额 = 1 + 3 = 4 。示例 2：输入：[2,7,9,3

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。示例 1:输入: [1,2,3,4,5,6,7] 和 k = 3输出: [5,6,7,1,2,3,4]解释:向右旋转 1 步: [7,1,2,3,4,5,6]向右旋转 2 步: [6,7,1,2,3,4,5]向右旋转 3 步: [5,6,7,1,2,3,4]示例 2:输入: [-1,-100,3,99] 和 k = 2输出: [3,99,-1,-100]解释:向右旋转 1 步: [99,-1,-100,3]向右旋

颠倒给定的 32 位无符号整数的二进制位。示例 1：输入: 00000010100101000001111010011100输出: 00111001011110000010100101000000解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596，因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。示例 2：输入：11111111111111111111111

给定一个整数 n，返回 n! 结果尾数中零的数量。示例 1:输入: 3输出: 0解释: 3! = 6, 尾数中没有零。示例 2:输入: 5输出: 1解释: 5! = 120, 尾数中有 1 个零.说明: 你算法的时间复杂度应为 O(log n) 。数学思想因为0都是5和偶数相乘产生的，所以要找出因子中有多少个5，因为25,125,625…含有多个5，要加上这些额外的5，即res=n/5+n/25+n/125+n/625…举个栗子：计算130,（1）130/5=26,说明有26个包

Boyer-Moore 投票算法（1）字面理解就是候选人是众数，所以给他投票的人是最多的，赞成票肯定大于反对票，最终众数胜出。（2）投票算法个人思路，数组中众数和其他数分成几队人在一个擂台上打架，每次擂台随机上一队的人，如果擂台没人则留在擂台上当擂主等待挑战者；如果是同队则一起留在擂台上；如果不是一队的人，就干一架，因为打的比较狠，挑战者和擂台上一个人一起被抬下去；最后，因为众数人多，所以最后站在擂台上的擂主一定是众数队，众数，永远滴神！同时可以发现其他队不懂团结，他们的内斗消耗更有利于众数获

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。示例 1:输入: [3,2,3]输出: 3示例 2:输入: [2,2,1,1,1,2,2]输出: 2mapclass Solution {public: int majorityElement(vector<int>& nums) { map<int,int> mp;