weixin_45479946的博客

283.移出0给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。示例:输入: [0,1,0,3,12]输出: [1,3,12,0,0]说明:必须在原数组上操作，不能拷贝额外的数组。尽量减少操作次数。首先确立思想，既然不能使用额外空间，那就使用两个指针。关注点在,不为零的情况下的操作，一旦不为0，就把该元素赋给以k为指针的下标数组中。最后把多余的空间单独放成0。class Solution {public: void moveZeroes

给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。示例:输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3输出: [3,3,5,5,6,7]解释:滑动窗口的位置 最大值[1 3 -1] -3 5 3 6 7 31 [3 -1 -3] 5 3 6 7 31 3 [-1 -3 5] 3 6 7 51 3 -1 [-3 5 3] 6

1.什么是KMP算法？KMP是一种改进后的字符串匹配算法。例如判断字符串1中是否包含字符串2，如果使用暴力算法需要将字符串的每一个字符都一一进行对比，耗时耗力，时间复杂度是O(N*M)。N是比对次数，M是字符串2的长度。而KMP算法体提供了另一种判断是否为子字符串的方法。可以将时间复杂度压缩到O（n）的级别。首先理解前缀后缀：如下图：abcabck中k的前缀为1就是a，后缀为1就是c，依次类推，前缀为2–ab,后缀为2–bc等。前缀就是该字母前面字符串的第一个字母开始起，后缀就是前面字符串的最

动态规划的入门可以先看这篇文章:动态规划入门背包问题是动态规划中最经典的一个问题，要是比较难的一个问题。题目：有一个背包，它的容量为C（Capacity），现在有n种不同的物品，编号为0…n-1，其中每一件物品的重量为w（i），价值为v（i）。问可以向这个背包中盛放哪些物品，使得在不超过背包容量的基础上，物品的总价值最大。题目解析：变量： C（容量） i（第i个物品） w(i) （第i件物品的重量） v(i)(第i件物品的价值)要求：(1) w(0)+w(1)+…w(i-1)<=C

在网上看到一道ACM竞赛题，很巧妙的运用了并查集解决了一个现实生活的问题，然而网上的解析太少，在这里贴出来我的思考：题目：S 城现有两座监狱，一共关押着N 名罪犯，编号分别为1~N。他们之间的关系自然也极不和谐。很多罪犯之间甚至积怨已久，如果客观条件具备则随时可能爆发冲突。我们用“怨气值”（一个正整数值）来表示某两名罪犯之间的仇恨程度，怨气值越大，则这两名罪犯之间的积怨越多。如果两名怨气值为c 的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并造成影响力为c 的冲突事件。每年年末，警察局会将本年内监狱中

动态规划是由递归一步步优化出来的递归–>记忆化递归–>动态规划动态规划与其说是一个算法，不如说是一种方法论。该方法论主要致力于将合适的问题拆分成三个子目标——击破：1.建立状态转移方程2.缓存并复用以往结果3.按顺序从小往大算比如：一、斐波那契额数列（剑指offer10-I）写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。斐波那契数列的定义如下：F(0) = 0, F(1) = 1F(N) = F(N - 1) + F(N - 2), 其中 N

跳表就是一种特殊的单链表，这个单链表的头节点有很多层，从每一层头节点往后看去，它都是一个有序的单链表。那么跳表怎样增删改查呢？1.插入节点的时候，先利用随机函数随机产生该节点的层数，如果跳表中不存在这一层，就创建到这一层，然后对新创建的每一层都进行插入，如果存在这一层，依次往后遍历，找到前一个小于它，后一个大于它的节点位置进行插入。2.删除节点同理，不过需要注意的是，如果删除掉该节点之后，这一层为空，就把这一层链表整个删除掉。3.查找节点的时候，从最高层开始遍历，找到该值就依次向下遍历，返回第一层的该

输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串"I am a student. “，则输出"student. a am I”。示例 1：输入: “the sky is blue”输出: “blue is sky the”示例 2：输入: " hello world! "输出: “world! hello”解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。示例 3：输入: “a good

1.二分查找法二分搜索树的前身是二分查找法，大致的思想就是，先找到这个有序数列（注意是有序的）中间的那个元素mid进行比较，如果目标元素比该元素大，就在（mid+1，末尾）这个区间进行查找，如果比1小，就在（首元素，mid-1)这个区间进行查找，直到找到最终的元素。二分查找既可以用迭代法，也可以用递归法，下面是这两种方法：#include <iostream>#include <cassert>#include <ctime>using namespace

输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。示例 1：输入：nums = [2,7,11,15], target = 9输出：[2,7] 或者 [7,2]示例 2：输入：nums = [10,26,30,31,47,60], target = 40输出：[10,30] 或者 [30,10]思路：利用数组排好序的特性。x，y分别指向数组的两端。当nums[x] + nums[y] == target时，有解{num

输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。示例 1：输入：target = 9输出：[[2,3,4],[4,5]]示例 2：输入：target = 15输出：[[1,2,3,4,5],[4,5,6],[7,8]]滑动窗口详解class Solution {public: vector<vector<int>> findContinuousSeq

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。示例 1:给定二叉树 [3,9,20,null,null,15,7]3/ 9 20/ 15 7返回 true 。示例 2:给定二叉树 [1,2,2,3,3,null,null,4,4] 1 / \ 2 2/ \3 3/ 4 4返回 false 。有两个注意点！/** * Definition for a bin

统计一个数字在排序数组中出现的次数。示例 1:输入: nums = [5,7,7,8,8,10], target = 8输出: 2示例 2:输入: nums = [5,7,7,8,8,10], target = 6输出: 0class Solution {public: int search(vector<int>& nums, int target) { if(nums.empty()) return 0; int count=

剑指 Offer 52. 两个链表的第一个公共节点输入两个链表，找出它们的第一个公共节点。如下面的两个链表：在节点 c1 开始相交。示例 1：输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3输出：Reference of the node with value = 8输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为

1.为什么会有并查集？如上图，任意两个节点是否连接？这如同所有的网络节点中，任意的两个节点的用户是否通过多层关系相互认识？为了探讨这个问题，发明了并查集这种数据结构。（并查集只是探讨了众多节点中的两个节点是否相连，但是没有探讨这两个节点具体的连接路径，这一点交给后面的图进行处理解决！）2.什么是并查集？百度解释：并查集是一种树型的数据结构，用于处理一些不相交集合（disjoint sets）的合并及查询问题。3.怎样用代码表示并查集？1.最原始的并查集先在这个unionfind1.h问文件

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”例如，给定如下二叉树: 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

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。一般来说，删除节点可分为两个步骤：首先找到需要删除的节点；如果找到了，删除它。说明： 要求算法时间复杂度为 O(h)，h 为树的高度。示例:root = [5,3,6,2,4,null,7]key = 35/ 3 6/ \ 2 4 7给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后

给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。假定 BST 有如下定义：结点左子树中所含结点的值小于等于当前结点的值结点右子树中所含结点的值大于等于当前结点的值左子树和右子树都是二叉搜索树例如：给定 BST [1,null,2,2],12/2返回[2]./** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。为了让您更好地理解问题，以下面的二叉搜索树为例：我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于双向循环链表，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。下图展示了上面的二叉搜索树转化成的链表。“head” 表示指向链表中有最小元素的节点。特别地，我们希望可以就地完成转换操作。当转化完成以后，树中节点的左指针需要指向前驱

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。参考以下这颗二叉搜索树： 5/ \2 6/ 1 3示例 1：输入: [1,6,3,2,5]输出: false示例 2：输入: [1,3,2,6,5]输出: trueclass Solution {public: bool pdecsss(vector<int>& postorder, int le

层序遍历其实很简单，就是建立一个队列，然后把二叉搜索树的根节点放进去，对队列不为空进行循环，循环里依次把队列的头部拿出即可。void levelOrder(){ queue<Node*>q; q.push(root);//使下面可以进入循环 while(!q.empty()){ //把头节点保存在一个临时变量里，以便后面循环 //必须要有不能用root,否则无法对左右子树的左右子树遍历 Node*node=q.front(); q.pop(); cout&l..

给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。示例 1:给定数组 nums = [1,1,2],函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。你不需要考虑数组中超出新长度后面的元素。示例 2:给定 nums = [0,0,1,1,1,2,2,3,3,4],函数应该返回新的长度 5, 并且原数组 nums 的

前面对选择排序，快速排序，希尔排序，归并排序，冒泡排序都进行了分析，最后一个是堆排序，刚开始实在不想写这个，感觉太麻烦了，无奈搜了一些面经，发现什么百度、腾讯、阿里等，他们都问到了堆排序，所以还是得认真聊一聊堆排序！为什么要有堆排序？堆非常典型的一个应用是优先队列，普通队列是先进先出，优先队列则出队和入队无关，和他们各自的优先级有关！算法可以动态的选择优先级最高的任务执行！而任务的排序使用之前静态的排序方法是做不到的！还有一个好处是，在N个元素里面选出前M个元素，用前面静态的方法，先排序再提取它的时间

第一种最常用的就是1.选择排序：时间复杂度：O(N*N)大致思想为：从第一个数开始，依次从后面所有数中挑出最小的那个数（包括比较第一个数），然后与第一个数进行数值交换。自己写代码总会出现或多或少的小问题：注意：（1）swap函数记得加上头文件#include（2）自己写交换函数记得用引用传递，int temp = a;a=b;b=temp;这个交换顺序自己在纸上写一写。（3）为了可以容纳多种类型数组，加入模板T，同时包装成一个函数，这样float型数组（小数），string型数组（字符串）

class Solution {public: vector<vector<int>> imageSmoother(vector<vector<int>>& M) { //牛逼方法 //注意：矩阵不是方阵，长宽不一定相等 int W=M.size(); int L=M[0].size(); //初始化容器大小，并把每个元素初始化为-1 vector<vector<int&g.

class Solution {public: vector<vector<int>> generate(int numRows) { //第n行的数组有n个数 vector<vector<int>>v; for(int i=0; i<numRows;i++) { //把第i+1行元素都设置成1 v.push_back.

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。示例:输入: [0,1,0,3,12]输出: [1,3,12,0,0]说明:必须在原数组上操作，不能拷贝额外的数组。尽量减少操作次数。牛逼的双指针方法！class Solution {public: void moveZeroes(vector<int>& nums) { int i=0,j=0; for(i=0; i&l

给你一个长度为 n 的整数数组，请你判断在 最多 改变 1 个元素的情况下，该数组能否变成一个非递减数列。我们是这样定义一个非递减数列的： 对于数组中所有的 i (0 <= i <= n-2)，总满足 nums[i] <= nums[i + 1]。示例 1:输入: nums = [4,2,3]输出: true解释: 你可以通过把第一个4变成1来使得它成为一个非递减数列。示例 2:输入: nums = [4,2,1]输出: false解释: 你不能在只改变一个元素的情况下将

给定一个长度为 n 的非空整数数组，找到让数组所有元素相等的最小移动次数。每次移动将会使 n - 1 个元素增加 1。示例:输入:[1,2,3]输出:3解释:只需要3次移动（注意每次移动会增加两个元素的值）：[1,2,3] => [2,3,3] => [3,4,3] => [4,4,4]掌握了一个思想，这道题瞬间变简单了：数组的移动次数或者说两个元素增加1的次数，等于一个元素减去1的次数！也就是说，你只要看各个元素减1减多少次都等于最小值就可以了！cla

给定一位研究者论文被引用次数的数组（被引用次数是非负整数）。编写一个方法，计算出研究者的 h 指数。h 指数的定义：h 代表“高引用次数”（high citations），一名科研人员的 h 指数是指他（她）的 （N 篇论文中）总共有 h 篇论文分别被引用了至少 h 次。（其余的 N - h 篇论文每篇被引用次数 不超过 h 次。）例如：某人的 h 指数是 20，这表示他已发表的论文中，每篇被引用了至少 20 次的论文总共有 20 篇。示例：输入：citations = [3,0,6,1,5]输出

在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。示例:s = “abaccdeff”返回 “b”s = “”返回 " "本来想先进行一个排序，然后把第一个重复的输出，后来发现错了，因为人家求的是在不打乱顺序的前提下的第一个字符错误代码：class Solution {public: char firstUniqChar(string s) { char a='s'; if(s=="") return ' '

输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)。示例1:输入: nums = [-2,1,-3,4,-1,2,1,-5,4]输出: 6解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。之前的思考：//子数组意味着必须是连续的，不能排序//要求连续的和最大//特殊情况，全部为大于等于0的数，全部相加//如果全为负数，那就排序后，返回第一个//一旦出现穿插负数,先找有正数的位置//有一个思想非常重要：最大子数组的第

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。你可以假设数组是非空的，并且给定的数组总是存在多数元素。示例 1:输入: [1, 2, 3, 2, 2, 2, 5, 4, 2]输出: 2解：用两种方法class Solution {public: int majorityElement(vector<int>& nums) { //方法1：排序后中间的元素一定是出现超过一半的数字 sort(nums.begin(),nu

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。例如:给定二叉树: [3,9,20,null,null,15,7],3/ 9 20/ 15 7返回其层次遍历结果：[[3],[9,20],[15,7]]解：解析都说用BFS遍历，先搞清楚啥是BFS遍历:BFS叫广度优先算法，全程是 breadth First Search，（也称宽度优先搜索）这篇文章讲的相对详细一点：https://blog.csdn.net/g11d111/articl

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。示例:MinStack minStack = new MinStack();minStack.push(-2);minStack.push(0);minStack.push(-3);minStack.min(); --> 返回 -3.minStack.pop();minStack.top(); --> 返回 0.min

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。示例 1：输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]输出：[1,2,3,6,9,8,7,4,5]示例 2：输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]输出：[1,2,3,4,8,12,11,10,9,5,6,7]class Solution {public: vector<int> spiralOrder(vector<vec

给你一个未排序的整数数组，请你找出其中没有出现的最小的正整数。示例 1:输入: [1,2,0]输出: 3示例 2:输入: [3,4,-1,1]输出: 2示例 3:输入: [7,8,9,11,12]输出: 1解：先把大于0的数都拿出来放到一个容器中，然后排序，排序后将每一个数组中的数和它的序号比较，把第一个不相等的输出来，请问哪里有问题？？？？执行都是正确的，但是每次提交都会出错，想不通为什么？class Solution {public: int firstMissingP

给定一个范围在 1 ≤ a[i] ≤ n ( n = 数组大小 ) 的 整型数组，数组中的元素一些出现了两次，另一些只出现一次。找到所有在 [1, n] 范围之间没有出现在数组中的数字。您能在不使用额外空间且时间复杂度为O(n)的情况下完成这个任务吗? 你可以假定返回的数组不算在额外空间内。示例:输入:[4,3,2,7,8,2,3,1]输出:[5,6]解：这个大神的方法简直绝了！！！！！！往下看：class Solution {public: vector<int&g

给定一个非空且只包含非负数的整数数组 nums, 数组的度的定义是指数组里任一元素出现频数的最大值。你的任务是找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度。示例 1:输入: [1, 2, 2, 3, 1]输出: 2解释:输入数组的度是2，因为元素1和2的出现频数最大，均为2.连续子数组里面拥有相同度的有如下所示:[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]最短连续子数组[

集合 S 包含从1到 n 的整数。不幸的是，因为数据错误，导致集合里面某一个元素复制了成了集合里面的另外一个元素的值，导致集合丢失了一个整数并且有一个元素重复。给定一个数组 nums 代表了集合 S 发生错误后的结果。你的任务是首先寻找到重复出现的整数，再找到丢失的整数，将它们以数组的形式返回。示例 1:输入: nums = [1,2,2,4]输出: [2,3]方法：排序后找到重复的元素，缺失的元素分为了两类，一类中间，一类在首尾，分别对两类获取值。找缺失元素这里真的非常巧妙，原来是分为两种情况