h1429541165的博客

36、Pow(x,n)题目36.0、无脑解法我反手一个pow//无脑解法double myPow0(double x, int n){ return pow(x, n);}时间复杂度：不知道，有兴趣可以去查空间复杂度：不知道，有兴趣可以去查实际上，这种直接调pow是没有下面两种方法好的36.1、快速幂+递归对于30次方，可以看作是15次方的平方15次方是7次方的平方再乘以1次方7次方是3次方的平方再乘以1次方3次方是1次方的平方再乘以1次方1次方就是1次方。。

35、Excel表列序号题目35.0、进制转换这题其实很简单。。。写的时候注意不要超出int范围，要***先减后加***int titleToNumber0(string columnTitle){ int result = 0; for (auto& i : columnTitle) result = result * 26 + (int)(i - 'A') + 1; return result;}时间复杂度：O（n）空间复杂度：O

34、阶乘后的零题目34.0、暴力比如对于1000，你就从1乘到1000呗，当遇到超出int长度的时候（提前用除法判断是否超出），把结尾的零清掉，顺便把后几位全部砍掉，比如当数是1783233200，先去掉0，得到17832332，直接砍掉后5位得到178。其实这种做法好像是有问题的，我没有试过，有兴趣的可以去写一写。时间复杂度：我只能说有点高空间复杂度：O（1）没有使用额外空间34.1、提取因子很容易发现，只有当一个数以5或者0结尾的时候才会出现乘积为0的情况对于30，其中以0或5

33、快乐数题目33.0、暴力解法先写一个函数来计算每个位置的平方和，该函数对于下列三种方法通用int calculate(int n){ int m = 0; while (n) { m += (int)pow(n % 10, 2); n /= 10; } return m;}暴力解法比较实际，用一个哈希集合来记录每次的数从而来判断是否存在循环//暴力解法bool isHappy0(int n) {

32、单词搜索题目32.0、暴力解法（回溯）这个我没有找到其他的更优的解法（即使有，也是相当复杂），只能用一般的深度优先搜索来解题了，把标记数组套上回溯的壳子，就OK了。public: //暴力解法 bool exist(vector<vector<char>>& board, string word) { int rows = board.size(), cols = board[0].size(); v

31、子集题目30.0、迭代法实现子集枚举因为题目中限定条件是数组大小不大于10，所以可以用二进制的方法来解题对于序列【1，3，6，7，8】大小为5，所有的组合是2的5次方，也就是32种那么用二进制来表示32就是100000，其中00000表示空数组00010表示数组里只有3（不是7）11111表示数组里有8，7，6，3，1遍历小于100000的所有二进制，找到为1位置对应的数，添加到数组里//迭代法实现子集枚举vector<vector<int>> su

30、全排列题目30.0、回溯法直接枚举所有可能，在递归的的时候通过哈希集合来判断，该数是否已经使用public: vector<vector<int>> permute0(vector<int>& nums) { vector<vector<int>> result; unordered_set<int> data; vector<int&gt

29、括号生成题目29.0、暴力解法枚举出所有的可能，符合条件的写入结果集里面public: //暴力解法 vector<string> generateParenthesis0(int n) { vector<string> result; string temp = ""; depth(result, 2 * n, temp); return result; }priv

28、电话号码的字母组合题目28.0、回溯（深度优先）和树的深度优先遍历很像 vector<string> letterCombinations0(string digits) { vector<string> result; if (digits.empty())return result; unordered_map<char, string> data = { {'2',"abc"},{'3

27、最长上升子序列题目27.0、动态规划用data[i]记录以nums[i]为结尾的序列的最长上升子序列长度状态转移方程为：data[i] = nums[i] > nums[x] && data[i] = max(data[i], data[x] + 1)其中x表示0-i-1，左右都为闭区间int lengthOfLIS0(vector<int>& nums){ int size = nums.size(); vector&lt

26、零钱兑换题目26.0、记忆化搜索其实就是暴力解法，比如对于金额20，硬币面值为【1，2，5】看看15需要多少硬币，再看看10需要多少硬币，再看看5需要多少硬币。算出需要4枚看看18需要多少硬币，再看看13需要多少硬币，再看看8需要多少硬币，再看看3需要多少硬币，再看看1需要多少硬币。算出6枚看看19需要多少硬币，再看看14需要多少硬币，再看看9需要多少硬币，再看看4需要多少硬币，再看看2需要多少硬币。算出6枚所以结果是4枚。上述例子可以正好凑够金额，所以没有分支，如果金额是20，

23、前K个高频元素题目23.0、基于快排先遍历一遍数组，用哈希映射来记录每个值对应的频率。把哈希映射转化为vector<pair<int,int>>或者二维数组的格式。然后就可以使用和查找数组中第K大元素相同的方法来找到前K大频率的分割下标。private://产生随机数，将该随机下标的数与最后一个数调换位置，然后将数组分为左右两部分，返回分界线的下标int randomPartition(vector<pair<int, int>>&

25、不同路径题目25.0、动态规划f（x，y）表示到（x，y）的位置有多少种走法状态转移方程为f（x，y） = f（x - 1，y） + f（x，y - 1）所以你可以创建一个m*n大的数组来记录到每一个位置有多少种走法但是这种方法太亏了，因为对于3*3的序列【【1，1，1】【1，2，3】【1，3，6】】一行一行从左向右遍历，会发现，每一行的数组只用了一次，那为什么不循环利用呢int uniquePaths0(int m, int n) { vector<i

24、跳跃游戏题目24.0、贪心算法对于序列【2，3，1，1，4】，维护一个rightMost，表示能够到达的最右端的坐标rightMost = max（rightMost， nums[i] + i）在遍历的过程中注意当rightMost < i时，返回falsebool canJump0(vector<int>& nums){ int size = nums.size(); int rightMost = 0; for (int i =

1、搜索二维矩阵 II题目1.0、暴力解法直接遍历整个二维数组，看一下有没有目标数bool searchMatrix0(vector<vector<int>>& matrix, int target){ for (auto& i : matrix) for (auto& j : i) if (j == target)return true; return false;}时间复杂度：O

21、搜索旋转排序数组题目21.0、暴力解法直接遍历一遍找答案int search0(vector<int>& nums, int target) { for (size_t i = 0; i < nums.size(); i++) if (nums[i] == target)return i; return -1;}时间复杂度：O（n）空间复杂度：O（1）21.1、二分查找虽然旋转了，但是还是两部分有序的序列啊只不

20、在排序数组中查找元素的第一个和最后一个位置题目20.0、暴力解法这道题真滴非常简单，遍历一遍数组，记录目标数的第一个和最后一个就OK了，不会一遍遍历，那就两遍遍历，一遍找开始，一遍找结束。vector<int> searchRange0(vector<int>& nums, int target) { if (nums.empty())return { -1,-1 }; vector<int> result; for

19、合并区间题目19.0、暴力解法对每一个区间都进行和其他区间比较，最后筛选不重复集合即可时间复杂度：O（n平方）空间复杂度：O（1）不考虑答案占用空间19.1、对子数组进行排序按照子数组的第一个数字对大数组进行排序，然后就可以通过简单的判断来进行合并数组vector<vector<int>> merge1(vector<vector<int>>& intervals) { int size = intervals

18、数组中的第K个最大元素题目18.0、暴力解法直接sort排序int findKthLargest0(vector<int>& nums, int k) { sort(nums.begin(), nums.end()); return nums[nums.size() - k];}时间复杂度：O（n平方）空间复杂度：O（1）18.1、基于快速排序的选择方法利用sort排序的原理，进行快速选择，对于数组【3，2，3，1，2，4，5，5，6

17、寻找峰值题目17.0、暴力解法先判断第一个和最后一个，然后判断每一个是不是峰值（正常人一般都会这么写）int findPeakElement0(vector<int>& nums) { int size = nums.size(); if (size == 1 || nums[0] > nums[1])return 0; if (nums[size - 1] > nums[size - 2])return size - 1;

15、从前序与中序遍历序列构造二叉树题目15.0、递归解法先序序列【3，9，20，15，7】中序序列【9，3，15，20，7】先序的第一个就是整个树的根中序中以根为分界线，左边为左子树的中序，右边为右子树的中序根据在先序序列里找到的根，把中序序列分为两个子树的中序序列然后重复上述步骤至于怎么在先序序列中找到子树的根先序序列可以拆分为【3】，【9】，【20，15，7】第一块是整个树的根，第二块是左子树的根，第三块是右子树的根可以根据中序序列来判断左子树有多少个节点，这样就可

16、颜色分类题目16.0、暴力你可以直接用sort（）函数排序，或者自己写一个冒泡排序或者其他什么的排序。时间复杂度：O（n平方）或者是log n空间复杂度：O（1）16.1、单指针遍历两次第一遍遍历把所有的0都移动到开头（记得设置一个变量来记录最后一个0到哪个位置了）第二遍遍历把所有的2都移动到结尾（记得设置一个变量来记录最前一个2到哪个位置了）时间复杂度：O（n）空间复杂度：O（1）16.2、双指针遍历一次对于上面的遍历两次，完全可以只遍历一次时实现0移到开头，2

14、填充每个节点的下一个右侧节点指针题目14.0、广度优先搜索借用二叉树的层次遍历，在队列里把保存值去掉，换成连接指针即可Node* connect0(Node* root) { if (!root)return root; Node* resultNode = root; queue<Node*> data; data.push(root); while (!data.empty()) { int dataSiz

13、二叉搜索树中第K小的元素题目13.0、记录子树的节点数就像名字一样，记录每个节点的子节点有多少个（包括自己），然后就可以判断目标在哪里了这种方法其实挺鸡肋，完全可以中序遍历生成数组，方便频繁查询。int kthSmallest0(TreeNode* root, int k){ MyBst myBst(root); return myBst.kthSmallest(k);}class MyBst{ private: unordered_map&lt

12、岛屿数量题目12.0、广度优先遍历从一个点开始，进行广播一样的遍历，比如示例1，发现第一个数是一个岛，那么从【0，0】开始广播，广播依次经过【0，1】，【1，0】【0，2】，【1，1】，【2，0】【0，3】，【2，1】【1，3】每到一个地方，就把那个坐标对应的位置变为0使用队列或者栈来存储下次广播到达的坐标int numIslands0(vector<vector<char>>& grid) { stack <pair<i

11、二叉树的锯齿形层序遍历题目给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。例如：给定二叉树 [3,9,20,null,null,15,7],​ 3/ \9 20/ \ / \nn 15 7返回锯齿形层序遍历如下：[[3],[20,9],[15,7]]11.0、一般解法正常的层序遍历，然后如果是偶数层的话就反转一下数组，非暴力不合作。vector<vector<

10、二叉树的中序遍历题目给定一个二叉树的根节点 root ，返回它的 中序 遍历。示例 1：输入：root = [1,null,2,3]输出：[1,3,2]示例 2：输入：root = []输出：[]示例 3：输入：root = [1]输出：[1]示例 4：输入：root = [1,2]输出：[2,1]示例 5：输入：root = [1,null,2]输出：[1,2]10.0、无脑递归最简单的方法就是使用递归，只需要考虑边界条件即可，也就是节点为不为空。这里说明

9、相交链表题目给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。题目数据 保证 整个链式结构中不存在环。注意，函数返回结果后，链表必须 保持其原始结构 。示例 1：输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3输出：Intersected at ‘8’解释：相交节点的值为 8 （注

8、奇偶链表题目给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。示例 1:输入: 1->2->3->4->5->NULL输出: 1->3->5->2->4->NULL示例 2:输入: 2->1->3->5-&

7、两数相加题目给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。请你将两个数相加，并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外，这两个数都不会以 0 开头。struct ListNode { int val; ListNode *next; ListNode() : val(0), next(nullptr) {} ListNode(int x) : val(x), next(nu

6、字母异位词分组题目给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母都恰好只用一次。示例 1:输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]示例 2:输入: strs = [""]输出: [[""]]示例 3:输入: strs

5、无重复字符的最长子串题目给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。示例 1:输入: s = “abcabcbb”输出: 3解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。示例 2:输入: s = “bbbbb”输出: 1解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。示例 3:输入: s = “pwwkew”输出: 3解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。请注意，你的答案必须是 子串

4、矩阵置零题目给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。进阶：一个直观的解决方案是使用 O(m n) 的额外空间，但这并不是一个好的解决方案。一个简单的改进方案是使用 O(m + n) 的额外空间，但这仍然不是最好的解决方案。你能想出一个仅使用常量空间的解决方案吗？m == matrix.lengthn == matrix[0].length1 <= m, n <= 200-2^31 <=

3、三数之和题目给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。注意：答案中不可以包含重复的三元组。示例 1：输入：nums = [-1,0,1,2,-1,-4]输出：[[-1,-1,2],[-1,0,1]]示例 2：输入：nums = []输出：[]示例 3：输入：nums = [0]输出：[]0 <= nums.length <= 3000

2、递增的三元子序列题目给你一个整数数组 nums ，判断这个数组中是否存在长度为 3 的递增子序列。如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ，使得 nums[i] < nums[j] < nums[k] ，返回 true ；否则，返回 false 。示例 1：输入：nums = [1,2,3,4,5]输出：true解释：任何 i < j < k 的三元组都满足题意示例 2：输入：nums = [5,4,3,2,1]

1、最长回文子串题目给你一个字符串 s，找到 s 中最长的回文子串。示例 1：输入：s = “babad”输出：“bab”解释：“aba” 同样是符合题意的答案。示例 2：输入：s = “cbbd”输出：“bb”示例 3：输入：s = “a”输出：“a”示例 4：输入：s = “ac”输出：“a”1 <= s.length <= 1000s 仅由数字和英文字母（大写和/或小写）组成1.0、两边向中间缩进（暴力）这个其实就是暴力解法的优化一点点的玩意儿