Dedication_的博客

树剑指offer1、先序中序重建二叉树——构建中序哈希加快搜索，先序找根，中序划分左右子树2、树的子结构——遍历树，看当前节点是否为子树结构，子树结构要求根左右均相等直至匹配完毕3、生成二叉树的镜像——交换节点的左右子树，递归处理左右子树4、对称的二叉树——递归判断左右子树交叉是否相等，注意递归结构true and false 的条件5、二叉搜索树与双向链表——中序遍历逻辑，cur->right=root，cur->right->left=cur，cur=cur->rig

二、高频题目88. 合并两个有序数组——双指针1、防止nums元素被改写，先摘录大的元素放入nums空白处2、交叉摘录数组元素3、单方摘录某数组元素

133. 克隆图——DFS1、特判2、递归条件，结点访问过，返回map对应的val3、克隆当前节点4、遍历当前节点邻居，进行邻居更新，同时邻居克隆5、返回当前节点——BFS1、特判结点为空时，返回nullptr2、申请哈希表，key用于记录原结点，value用于记录新结点3、克隆当前结点，放入队列4、广度遍历，访问队列头的邻居，若未访问过则克隆并加入队列，克隆当前结点的邻居5、返回克隆后key对应的val200. 岛屿数量——BFS1、遍历二维矩阵2、遇到1时，压入队列，对其进

二、高频题目973. 最接近原点的 K 个点——排序1、sort，修改cmp根据x2+y2对坐标点进行排序2、返回数据排序好的前k个元素——优先队列1、建立大根堆，将数据前k个元素放入堆，first为计算结果，second为坐标索引2、从第k+1个元素扫描，小于当前堆顶，则代替堆顶3、将堆转向量，这里需要建堆带上向量的索引23. 合并K个升序链表——分治合并1、写出两链表合并逻辑2、编写分治合并，根据数组的left和right进行递归结束，二分，合并操作3、调用分治合并——利用堆

一、基础介绍无序容器二、高频题目两数之和——哈希表记录数字与索引1、遍历数字，哈希表中查找target-nums[i]2、找不到，count[nums[i]]=i3、找得到，返回{i，count[target-nums[i]]}350. 两个数组的交集 II——哈希表记录数字与出现次数1、哈希表记录nums1数字出现次数2、遍历nums2，如果元素在hashtable出现次数大于0，计数-1，加入ans128. 最长连续序列——哈希集合去重1、哈希集合去重nums2、遍历哈希集合3

一、实现代码#include <iostream>#define MAXSIZE 100using namespace std;struct stack { int* base; int* top; int stacksize; stack() { base = new int[MAXSIZE]; top = base; stacksize = MAXSIZE; } //压入——top所指位置赋值，top++ int push(int e

一、实现代码#include <iostream>#define MAXSIZE 100using namespace std;struct Queue { int *data; int front; int rear; Queue() { data = new int[MAXSIZE]; front = 0; rear = 0; } //压入——rear+1 int push(int elem) { if ((rear + 1) % MAXSIZE == fron

一、链表创建struct ListNode { int val; ListNode* next; ListNode() : val(0), next(nullptr) {} ListNode(int x) : val(x), next(nullptr) {} ListNode(int x, ListNode* next) : val(x), next(next) {}};二、高频题目206. 反转链表——链表原地反转1、初始化前驱pre为nullptr2、创建遍历指针cur3、wh

思路——动态规划无需打印路径的使用动态规划代替回溯dp[j]含义：target为j时，使用[0~i]的排列数递推公式：dp[j]+=dp[j-num[i]]dp初始化，第一个元素为1，其他元素为0遍历顺序：先背包后物体（排列） 先物体后背后（组合）代码class Solution {public: int combinationSum4(vector<int>& nums, int target) { vector<int> d

思路——动态规划dp[i][j]含义：代表以i为结尾下标，与以j结尾下标的字母之间的最小编辑距离递推方程：4个操作，不动，word1增，word2增，替换元素if(word[i-1]==word[j-1]) dp[i][j]=dp[i-1][j-1];else dp[i][j]=min(dp[i-1][j],dp[i][j-1],dp[i-1][j-1])+1;dp数组初始化：空字符与word1 word2的最小编辑距离遍历顺序：从左至右，从上至下返回结果：dp[word1.siz

思路——回溯单层分割路径 如“abc” 则有 a，ab，abcsubstr(begin,len)——记住第二个参数为len回文串判断，只需对size=1特殊处理，其他进行反转判断是否相等代码class Solution { vector<vector<string>> ans; vector<string> path; void backtracing(string& s, int startindex) {

思路全排列基础上多加一个条件返回答案长度，只需要申请一个变量计数，并动态记录path的长度代码class Solution { int count = 0; void backtracing(int n, vector<int>& used,int path_len) { if (path_len == n) { count++; return; } for (i

思路无需去重——无需排序剪枝——当前路径的最大深度需大于等于k不变的参数 使用 引用参数代码class Solution { vector<vector<int>> ans; vector<int> path; void backtracing(int& n,int& k,int idx){ //递归终止条件 if(path.size()==k){ ans.emp

思路需要对当前序列未访问索引进行标记需要去重，同层重复元素不能取传入参数最好为引用，减少内存开销代码class Solution { vector<vector<int>> ans; vector<int> path; void backtracing(vector<int>& nums,vector<int>&used){ //递归终止条件 if(path.size(

思路如何去重？——同层重复元素不再选取，同一条路的重复元素可选取如何实现？——对当前使用的元素作used=1，used=0即同层相同元素代码class Solution {private: vector<vector<int>> result; vector<int> path; void backtracking(vector<int>& nums, int startIndex, vector<bool&

思路——BFS如何剪枝？——排序、sum与target判断、大于target及时剪枝如何去重？——保证后元素 大于等于 前元素代码class Solution {public: vector<vector<int>> combinationSum(vector<int>& candidates, int target) { sort(candidates.begin(),candidates.end());

思路——BFS将第一个数字对应的字母序列依次入队对剩余数字进行遍历，获取其int值，再定位到指定的字母序列若队列头元素长度小于目标长度-1，则进行广度搜索数字序列遍历完毕，当前队列剩余的元素即答案代码class Solution {public: vector<string> ans; vector<string> sList={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"}; //字

思路计算前缀和滑动窗口，不使用存储空间，使用擂台法模拟L在M前，或M在L前，取最大值例子0 6 5 2 2 5 1 9 4 L=1 M=2那么以L为滑动窗口 依次得到 <0> <6> <5> <2> <2> <5>...模拟L在M前,M为 <6,5> <5,2> <2,2>...以M为滑动窗口 依次得到<0,6> <6,5> <5,2> &l

思路存储每个下标前的和——即前缀和 的%k余数为什么存储和%k余数？——若两个下标和的余数相等，则被减去，和就为k的倍数要判断当前下标与第一次出现对应余数的下标之差，是否大于等于2对于k余数为0如何处理？——要求长度大于等于2，则初始压入 map[0]=-1代码class Solution {public: bool checkSubarraySum(vector<int>& nums, int k) { int m = nums.size()

思路不断取头尾，最终剩下的是连续的数组取头尾的最大值，也就是取连续序列的最小值滑动窗口大小为n-k，初始化滑动窗口sum，之后移动 减左窗口值 加右窗口值累加某部分向量可以使用 acumulate()函数代码class Solution {public: int maxScore(vector<int>& cardPoints, int k) { int n = cardPoints.size(); // 滑动窗口大小为 n-k

思路递归终止条件？如何确定根结点？——数组中心如何确定数组范围递归建立左子树？如何确定数组范围递归建立右子树？递归返回需根节点代码class Solution {public: TreeNode* dfs(vector<int>& nums,int p_left,int p_right){ if(p_left>=p_right) return NULL; int mid = (p_right+p_

思路递归结束条件？何时递归寻找左子树？何时递归寻找右子树？何时算找到答案？找不到答案返回什么？代码class Solution {public: TreeNode* searchBST(TreeNode* root, int val) { if(root==nullptr) return nullptr; if(root->val > val) return searchBST(root->left,va

思路何时只修剪左子树？——右子树全部超出范围，即根节点大于上界何时只修剪右子树？——左子树全部超过范围，即根节点小于上界何时共同修建左右子树？——根节点未超出范围，进行共同修建并连接代码class Solution {public: TreeNode* trimBST(TreeNode* root, int low, int high) { if(root==nullptr) return nullptr; if(root->val >hi

思路若两个目标值均小于根节点的值，那么目标一定在左子树若两个目标值均大于根节点的值，那么目标一定在右子树其他情况，即当前根节点 为答案代码class Solution {public: TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { //在左子树上 if(root->val > p->val && root->val &gt

思路——确定上下界当前结点，大于左子树，小于右子树的值那么左子树呢？——也需要大于它的左子树，小于它的右子树那么右子树呢？——也需要大于它的左子树，小于它的右子树如何定义递归的参数？——上界与下届递归结束条件？——true？ false？——超过上下界范围代码class Solution {public: bool helper(TreeNode* root, long long lower, long long upper) { if (root == null

思路深度优先，中序遍历不存储，直接通过索引判断是否找到了答案申请两个遍历，一个代表索引号，一个代表结点的值代码class Solution { int i=0,res=0; void inorder(TreeNode* root,int k){ if(root==nullptr) return ; inorder(root->left,k); //索引加1 找到答案停止 i++; if(

思路——深度遍历+广度遍历建立结点的父亲索引——通过递归实现从target出发，进行广度搜索查找depth为K的所有结点需要建立访问记录，防止死循环（因为遍历会向上也会向下走）代码步骤：1. 建立父亲索引2. 将target放入队列3. 对target左右孩子、父亲结点进行广度搜索4. 找到depth 进行队列全弹出5. 输出答案class Solution {private: // 递归方式来构建父节点信息 unordered_map<TreeNode*

思路——双重递归检查是否相等——true false check检查根节点是否相等 左子树 右子树呢？ check dfs dfs代码class Solution {public: //检查是否相等 bool check(TreeNode *o, TreeNode *t) { if (!o && !t) return true; if ((o && !t) || (!o &&am

思路广度优先遍历根结点入队，计算其左右孩子列坐标，进行答案压入[col]={depth,val}对答案进行先depth排序 后val排序代码class Solution {public: vector<vector<int>> verticalTraversal(TreeNode* root) { if (root == NULL) return {{}}; // col, depth, val

思路寻找递归结束条件 true——两结点相等寻找递归结束条件false——某一结点为空，或两结点值不相等确定返回值——左子树与左子树相等且右子树与右子树相等 || 左右子树交叉相等代码class Solution {public: bool flipEquiv(TreeNode* root1, TreeNode* root2) { if(root1==root2) return true; if(root1==nullptr||

思路递归结束条件——空结点 深度为0返回左右子树深度的较大值 加1代码class Solution {public: int maxDepth(TreeNode* root) { if(root==nullptr) return 0; return max(maxDepth(root->left),maxDepth(root->right))+1; }};...

思路前序遍历序列确定根结点——开头第一个元素中序遍历序列 定位根结点——建立哈希加快查找获得中序遍历的分割点，也获取了左子树的个数——用于分割的位置根据获得的信息进行左右子树的序列区域分割 和 建立左右子树代码class Solution {private: unordered_map<int, int> index;public: TreeNode* myBuildTree(const vector<int>& preorder, co

思路递归——深度遍历根结点的左右两棵子树是否 孩子对称相等代码class Solution {public: bool isSymmetric(TreeNode* root) { //特殊情况 if(root == NULL) return true; //调用递归 return isSymmetric(root->left, root->right); } bool

题目给定一个1~n的序列，判断其在seqs是否能被唯一重构seqs为org的子序列，即部分路径思路seqs需要包含所有orgs中的结点 —— 数组记录seqs不能包含orgs以外的结点 —— 结点索引范围判断需要唯一建立org —— 队列弹出每次的size为1需要与org相同 —— 一边队头弹出 一边扫描对比代码步骤：1. 建图2. 入队3. 广度搜索class Solution {public: bool sequenceReconstruction(vect

思路与210. 课程表 II类似，少了答案存储空间代码class Solution {public: bool canFinish(int numCourses, vector<vector<int>>& prerequisites) { //建图 vector<vector<int>> edge(numCourses); vector<int>indu(numCourses,

思路建立有向图，记录节点入度将入度为0的结点放入队列进行广度优先搜索，将队头放入答案相邻结点入度-1，入度更新为0则放入队列代码class Solution {private: // 存储有向图 vector<vector<int>> edges; // 存储每个节点的入度 vector<int> indeg; // 存储答案 vector<int> result;public: v

思路递归条件——结点为空 返回false递归左右子树判断 p q 是否分布在两旁如果不是 则集中在左边 或 右边 或 一个结点即当前根代码class Solution {public: TreeNode* ans; bool dfs(TreeNode* root, TreeNode* p, TreeNode* q) { //递归条件判断 if (root == nullptr) return false; //递归左右子树

思路——深度遍历递归条件——结点为空递归左右子树，寻找最大贡献路径计算当前结点最大路径，更新答案返回以当前结点 贡献较大那条路径代码class Solution {private: int maxSum = INT_MIN; int maxGain(TreeNode* node) { //递归结束条件 if (node == nullptr) return 0; //递归左右子树 获取正贡献度

思路——深度遍历递归终止条件——结点为空 无法交换递归左右子树交换左右子树代码优化——空孩子不必交换代码class Solution {public: TreeNode* invertTree(TreeNode* root) { //递归终止条件 if (root == nullptr) return nullptr; //代码优化，空孩子不必交换 if(root->left==nullp

思路对树进行深度搜索直径——两个树结点的最长路径以根出发，搜索两个孩子的最大深度，结果为两最大深度相加递归返回以结点深度搜索得到的 子树最大深度代码步骤：1. 根为空 返回02. 递归寻找左右孩子的最大深度相加——更新最大ans3. 返回以该根的最大深度 记得加1——按结点计算class Solution { int ans=0; int depth(TreeNode* rt){ if (rt == NULL) return 0;// 访问到空节点