qq_37397653的博客

【代码】C++中常用的STL容器及使用方法整理。

与二叉树,二叉搜索树相关模板

.

void dfs(int top,int numsSize,int** result,int*returnSize,int*temp,int** returnColumnSizes,int startIndex,int* nums){ if(top==numsSize){//本轮收集的数组内元素数量达标，则收割结果 result[*returnSize]=malloc(sizeof(int)*top); for(int i=0;i<top;i++){

参考代码随想录代码int isValue(char* s,int left,int right){ if(left>right) return 0; if(s[left]=='0'&&left!=right) return 0; int sum=0; for(int i=left;i<=right;i++){ if(s[i]<'0'||s[i]>'9') retu

一道题迷迷糊糊做了一天，等理清楚了再更新…bool isHuiWen(char* s){ int length=strlen(s); for(int i=0;i<length/2;i++) if(s[i]!=s[length-1-i]) return false; return true; }char* cut(char* s,int left,int right){ int length=0; char*

void backtracking(int *sum,int **returnColumnSizes,int target,int **result,int *returnSize,int *length,int* temp,int index,int *candidates,int candidatesSize){//sum用于每轮保存当轮数字组合的和，result是最终主函数要返回的指针数组，每个指针指向一个符合要求的数字组合//temp用于每轮保存当轮数字组合，length是temp中数字的数量，

void QuickSort(int *candidates,int left,int right){//快排排序，之后在回溯中便于排除相同的数字 if(left>right) return; int i=left; int j=right; int key=candidates[i]; int temp; while(i<j){ while(candidates[j]>=key&&amp

跟着大佬的答案敲了一下，懵懵懂懂，待更新char *letterMap[]={"0","0","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};void backTrack(char* digits,int *returnSize,char **returnStr,int index,char *stack,int top){ int len=strlen(digits); if(len<=top){ retur

题目：找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：1.只使用数字1到92.每个数字 最多使用一次3.返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。代码：void dfs(int left,int right,int k,int n,int **ans,int *returnSize,int *temp,int *temp_index){//left和1right为左右指针，即数字的范围1-9，n和k为题目给定的参数//ans为最终要返

题目：给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。你可以按 任何顺序 返回答案。void dfs(int cur,int n,int k,int *temp_index,int *returnSize,int **ans,int *temp){//cur是每轮遍历要加入的数字，n和k为题目要求的从1-n里挑k个数字//temp是存放每次遍历挑k个数字时的数组，ans是存放数组的数组//returnSize是数组的数组的下标，temp_index是temp数组的

题目：给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。提醒一下，二叉搜索树满足下列约束条件：节点的左子树仅包含键 小于 节点键的节点。节点的右子树仅包含键 大于 节点键的节点。左右子树也必须是二叉搜索树。大致思路：这道题的题意就是，执行过后，本结点的值，等于把原来所有大于本结点值的结点的值相加起来的和。由于二叉搜索树的中序遍历是有序且非减的，因为题目写明

题目：给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。思路：由于数组已经排序好，我们可以直接递归建树，只要每次递归都将当前递归范围中间的数字作为根节点，根节点左右两边的范围各作为左右子树，就可以实现平衡且满足二叉搜索树的性质（即左结点的值<根节点的值<右节点的值）struct TreeNode* build(int *nums,int left,i

题目：给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。 可以证明，存在 唯一的答案 。所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。![举例](https://img-blog.csdnimg.cn/339ec440282545868f894823dab4494

题目：给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。一般来说，删除节点可分为两个步骤：1.首先找到需要删除的节点；2.如果找到了，删除它。大致思路：先用pre和T遍历分别找到要删除的结点的父结点和要删除的结点，遍历之后可分为以下几种情况：1.要删除的结点是根节点2.要删除的几点不是根节点2.1要删除的结点是pre的右子树2.1.1要删除的结点的右子树非空2.1.2要

struct TreeNode* insertIntoBST(struct TreeNode* root, int val){ struct TreeNode* head; struct TreeNode* pre; if(root!=NULL){//根节点非空 head=root;//用head暂存根结点的位置 while(root!=NULL){ //遍历寻找该结点应该在的位置root和父结点位置pre if

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) { if(root->val>p->val&&root->val<q->val) return root; //若p结点的值<q结点的值，而根节点的值位于两者之间，说明是最近公共祖先 else if(ro

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) { if(root->val>p->val&&root->val<q->val) return root; //若p结点的值<q结点的值，而根节点的值位于两者之间，说明是最近公共祖先 else if(ro

大致思路：采用双指针，对树进行中序遍历，当前后指针指向的结点的值相等时，临时频率（temp_freq）自增。当临时频率等于目前的最大频率（freq）时，说明该值也为众数，加入众数数组；当临时频率超过目前的最大频率时，临时频率成为最大频率，更新最大频率的值（*freq=temp_freq）,并清空众数数组，令数组的指针returnSize指向0就好啦，并将该最大频率对应的值作为第一个众数加入数组。void Find_many(struct TreeNode* root,struct TreeNode** p

刚开始看到这道题，习惯性的找了搜索树的最左下和最右下的结点进行计算。结果发现要求返回的是“任意两个结点”的差的绝对值中最小的值。思路：看了答案，因为二叉搜索树的中序遍历是有序数组，因此可以采用中序遍历对相邻结点之间进行两两计算，返回其中的最小值。void Find_min(struct TreeNode *root,int *pre,int *min){ if(root==NULL) return; Find_min(root->left,pre,min);

大致思路：二叉搜索树，需满足：右子树的最大值>根节点的值>左子树的最大值，因此我们从上往下遍历。初始化时将最大值赋值为库里规定的最大值LONG_MAX，最小值赋值为库里规定的最小值LONG_MIN，并传入递归函数。从根节点开始，每次递归遍历左子树时，用现递归层次的根节点的值作为最大值传入递归函数；每次递归遍历右子树时，用现递归层次的根节点的值作为最小值传入递归函数。因为return的值采用&&，因此所有结点中只要有一个不满足条件，即返回false，那么返回到最上层的根节点时一

struct TreeNode* searchBST(struct TreeNode* root, int val){ if(root==NULL) return NULL;//该递归层次的根节点为空，则返回NULL if(root->val==val) return root;//若目标值跟该递归层次的值相等，则直接返回该结点 else if(root->val>val) return searchBST(root-

struct TreeNode* mergeTrees(struct TreeNode* root1, struct TreeNode* root2){ if(root1==NULL&&root2==NULL)//如果两个结点全空，则什么都不用做，返回 return NULL; else if(root1==NULL||root2==NULL){//如果有一个结点为空，合并到子树1 if(root1==NULL)//若结点1为空，说明结点2非空

这道题刚开始没看举例，还以为让我们构建一个大顶堆。后面才发现，题目的意思是：每次遍历数组范围中的最大值，将其作为根节点，然后将该数组最大值的左边区域作为左子树，右边的区域作为右子树，依次进行上述遍历。因为对左右子树横向的大小没有要求排序，所以不能在刚开始就对整个数组进行排序，否则会打乱横向子树的顺序。struct TreeNode* buildTree(int *nums,int left,int right){ //如果数组的左指针大于右指针，说明该区域为空，无需遍历 if(left&

思路：通过队列对树进行层序遍历，每层记录该层的第一个结点，最后一层的第一个结点的值则是该树左下角的值int findBottomLeftValue(struct TreeNode* root){ struct TreeNode *Nodes[10001]; struct TreeNode *temp; int right=0;//队列的右指针，指向最后一个元素的下一个位置 int left=0;//队列的左指针 int last=1;//记录每层的第一个结点，初始化

bool IsLeafNode(struct TreeNode *root){//用于判断是否是叶子结点 if(root!=NULL&&root->right==NULL&&root->left==NULL) //结点非空且左右子树为空，则为叶子结点 return true; else return false;}int sum(struct TreeNode *root){//用于计算左叶子之和，也可以不用单独写这

void creatPath(struct TreeNode*root,char **path,int *nodes,int *returnSize,int top){ if(root!=NULL){ if(root->left==NULL&&root->right==NULL){ char *nodes_path=malloc(101*sizeof(char)); int len=0;

int Maxhigh(struct TreeNode *root){//计算树高 if(root==NULL) return 0; else{ int left=Maxhigh(root->left)+1; int right=Maxhigh(root->right)+1; return left>right?left:right; }}bool isBalanced(struct TreeNo

递归法：int countNodes(struct TreeNode* root){ if(root==NULL) return 0; else{ int left=countNodes(root->left); int right=countNodes(root->right); return left+right+1;//左子树结点数+右子树结点数+本结点（也就是根节点）的数，再返回 }}迭代法

方法一：迭代法int minDepth(struct TreeNode* root){ if(root==NULL)return 0; struct TreeNode *Nodes[10000];//队列 struct TreeNode *node=root; int depth=1; int left=0;//左指针 int right=0;//右指针 Nodes[right++]=root;//right指向最后一个元素的下一个位置

int Depth(struct TreeNode*root){ if(root==NULL)return 0; else{ int left=Depth(root->left)+1; int right=Depth(root->right)+1; return left>right?left:right;//返回左右子树中最高的高度 }}int maxDepth(struct TreeNode* root){

bool IsTrue(struct TreeNode *left,struct TreeNode *right){ if(right==NULL&&left==NULL)return true;//如果左右子树都为空，则对称 else if(right==NULL||left==NULL)return false;//如果只有一个子树为空，这不对称 else{ if(right->val==left->val){

方法一：递归法struct TreeNode* invertTree(struct TreeNode* root){ if(root==NULL) return NULL; else{ struct TreeNode *temp; invertTree(root->left); invertTree(root->right); temp=root->right; root->right

方法一：递归法void in(struct TreeNode* root, int *num,int* returnSize){ if(root==NULL)return; else{ in(root->left,num,returnSize); num[(*returnSize)++]=root->val; in(root->right,num,returnSize); }}int* inorderTrave

方法一：递归法void post(struct TreeNode *root,int *num,int *returnSize){ if(root==NULL)return; else{ post(root->left,num,returnSize); post(root->right,num,returnSize); num[(*returnSize)++]=root->val; }}int* postord

方法一：递归法：void prior(struct TreeNode*root,int *num,int *returnSize){ if(root==NULL) return; else{ num[(*returnSize)++]=root->val; prior(root->left,num,returnSize); prior(root->right,num,returnSize); } }

struct HashNode{ int val; int index; UT_hash_handle hh;};int cmp(struct HashNode*a,struct HashNode*b){ return b->index-a->index;}/** * Note: The returned array must be malloced, assume caller calls free(). */int* topKFrequent(

首先，我先解释一下候选的最大值的结点的队列是怎么一回事。如果数组nums中的元素为223211，窗口为3，那么初始窗口框住的元素为2、2、3，此时3为最大值。那我们如何对这个候选的最大值的结点的队列进行初始化呢？我们可以把2、2、3依次入队，并规定一条规则：如果新入队的值比原先队列中队尾的值都大，则将这些值弹出后再入队。那为什么要定义这条原则呢？这是因为在初始化的时候，如果新入队的值比原先所有值都大，那这个新入队的值就是暂时的最大值，前面的值已经不再有候补意义。就像这里的2、2、3，等到3入队，那么窗

这题其实可以直接在主函数中声明一个大小为10000的char类型的数组，在声明一个i作为栈顶指针就可以解决，但我想练习一下栈的几个主要函数，所以还是打了出来#define Maxsize 10000typedef struct{ char data[Maxsize]; int top;}Stack;Stack* initStack(){//初始化函数 Stack *s=(Stack *)malloc(sizeof(Stack)); s->top=0;//栈

#define MaxSize 10typedef struct { int data[MaxSize]; int prior;//尾指针 int last;//头指针} MyStack;MyStack* myStackCreate() { MyStack *ms=(MyStack *)malloc(sizeof(MyStack)); ms->prior=0; ms->last=0; return ms;}//我们将队列的头指