effort_study的博客

滑动窗口滑动窗口是一种想象出来的数据结构，窗口有左边界L和右边界R。在数组或者字符串或者一个序列上，记为S，窗口就是S[L…R]这一部分，L往右滑动意味着有样本滑出窗口，R往右划动意味着有样本滑入窗口，L和R都只能往右滑动。窗口定义R边界向右移动，数组中的数从窗口右侧进入窗口L边界向右移动，数组中的数从窗口左侧出窗口左边界不能到右边界的右侧如何找到动态窗口中的最大值准备一个双端队列，数据可以从头部进头部出，也可以从尾部进尾部出。R++时，将数据从双端队列的尾部插入，此时队列为空，可以

并查集是什么是一种含有合并和查找功能的数据结构，用于处理一些不交集的合并和查询问题。主要含有两个功能：判断任意两个元素是否属于同一个集合；按照要求合并不同集合。并查集的基本操作查找：给出一个元素，查找元素属于哪个集合。步骤：不断向上查找，直到找到他的根节点，之后根据根节点是否相同判断两个元素是否属于同一个集合。查询操作完成后，并查集结构还会进行路径压缩操作，就是将查询节点到根节点之间的所有节点都指向根节点，可以有效限制因不断合并造成部分区域不匀称，使其保持较低的树高。合并：将两个子集合并成同一个

规定1和A对应、2和B对应、3和C对应…26和Z对应那么一个数字字符串比如"111”就可以转化为:“AAA”、“KA"和"AK”给定一个只有数字字符组成的字符串str，返回有多少种转化结果暴力递归构建尝试函数，str为数字字符串，index为当前进行到哪个位置，返回值为当前转换结果数主函数中如何调用process(str,index)分析basecase当index==str的长度时，到达字符串的尾部，返回数字1，表示找到一种转换结果分析普通情况当index遇到的字符为0，因为没有以0开

题目给定两个长度都为N的数组weights和values，weights[i]和values[i]分别代表 i号物品的重量和价值给定一个正数bag，表示一个载重bag的袋子，装的物品不能超过这个重量返回能装下的最大价值暴力递归首先建立尝试函数process，参数为w数组、v数组、当前进行到的序号index、背包剩余的容量rest，返回值为包中物品的总价值那么主函数中调用的就是process(w,v,0,bag)首先分析basecase：当index==N时，所有物品都以选完，返回0当res

题目给定一个整型数组arr，代表数值不同的纸牌排成一条线玩家A和玩家B依次拿走每张纸牌规定玩家A先拿，玩家B后拿但是每个玩家每次只能拿走最左或最右的纸牌玩家A和玩家B都绝顶聪明请返回最后获胜者的分数暴力递归首先设置一个尝试函数processf，参数为arr数组，L表示左边界，R表示右边界，返回值为int表示取到数的和。先来看basecase：当只有一张牌的时候，即L==R的时候，拿一张牌，拿到的就是最后这张牌。普通情况拿左边的牌，获得值为arr[L]，但是对方接下来要拿牌 拿的就是[

题目：假设有排成一行的N个位置记为1~N，N一定大于或等于2开始时机器人在其中的M位置上(M一定是1~N中的一个)如果机器人来到1位置，那么下一步只能往右来到2位置；如果机器人来到N位置，那么下一步只能往左来到N-1位置；如果机器人来到中间位置，那么下一步可以往左走或者往右走；规定机器人必须走K步，最终能来到P位置(P也是1~N中的一个)的方法有多少种给定四个参数 N、M、K、P，返回方法数参数分析：N表示一共7个数start表示机器人的起始位置在2aim表示机器人的目标位置在4k

哑结点+非递归class Solution {public: ListNode* deleteDuplicates(ListNode* head) { ListNode dummyhead(-101, head); ListNode* cur = &dummyhead; while (cur->next != NULL && cur->next->next != NULL) { if (cur->next->val == cur-

创建两个节点保存前驱和当前节点，不断比较中向后移动，若相等前驱直接连到后继上，就完成了删除操作。若不相等，则同时后移。class Solution {public: ListNode* deleteDuplicates(ListNode* head) { ListNode dummyhead(999, head); ListNode* cur = head; ListNode* curPre = &dummyhead; while (cur != NULL) { if (

方法一 选择排序 时间复杂度O(N^2)空间复杂度O(1) 超时。。。class Solution {public: ListNode* sortList(ListNode* head) { ListNode* tail = NULL; ListNode* cur = head; ListNode* smallPre = NULL; ListNode* small = NULL; while (cur != NULL) { small = cur; smallPre =

方法一找到中间后，右半区压入栈中，然后将两部分合并class Solution {public: void reorderList(ListNode* head) { ListNode* fast = head; ListNode* slow = head; ListNode* mid; stack<ListNode*> st; while (fast->next != NULL &&amp

class Solution {public: ListNode* removeNthFromEnd(ListNode* head, int n) { ListNode* slow=head; ListNode* fast=head; // if(head->next==NULL){ // if(n==1){ // return NULL; // } // } // if(head->nex

牛客上 题目给出的要比书上的简单，牛客上求的是删除第k个节点，所以只需要找到第k-1个即可。先写牛客上的内容list_node * remove_kth_node(list_node * head, int K){ //////在下面完成代码 list_node* cur=head; list_node* pre=head; if(K==1){ return head->next; } while(--K){ p

打印两个链表的公共部分，因为题目中给出的链表是有序的，所以只需要逐个比较即可void sol(list_node * a_head, list_node * b_head){ //////在下面完成代码 while(a_head!=NULL &&b_head!=NULL){ if(a_head->val<b_head->val){ a_head=a_head->next; }else if(a

class Solution {public: ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { ListNode* head = NULL; ListNode* tail = NULL; int carry = 0; while (l1 || l2) { int n1 = l1 ? l1->val : 0; int n2 = l2 ? l2->val : 0; int sum = n1 + n2+c

方法一 弹栈 笔试做法class Solution {public: ListNode* getKthFromEnd(ListNode* head, int k) { stack<ListNode*>st; ListNode* result=NULL; while(head){ st.push(head); head=head->next; } whi

##方法一 使用set 笔试做法class Solution {public: ListNode* detectCycle(ListNode* head) { set<ListNode*>st; while (head) { if (st.find(head) == st.end()) { st.insert(head); head = head->next; } else { return head; } } retu

class Solution {public: ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) { stack<ListNode*>stA; stack<ListNode*>stB; if (headA == NULL || headB == NULL) { return NULL; } while (headA) { stA.push(headA); headA

class Solution {public: ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { ListNode* newhead = NULL; ListNode* cur = NULL; while (l1 != NULL && l2 != NULL) { if (l1->val <= l2->val) { newhead = newhead == NULL ? l1 : newh

class Solution {public: ListNode* popstack(stack<ListNode*>& st, ListNode* left, ListNode* right) { if (left != NULL) { left->next = st.top(); } ListNode* ccc = st.top(); st.pop(); ListNode* next = NULL; while (!st.empty()) {

class Solution {public: ListNode* reverseBetween(ListNode* head, int left, int right) { int len=right-left+1; ListNode* pre_head=nullptr; ListNode* result=head; while(head&&--left){ pre_head=head;

反转单向链表单向链表的节点只有一个指针指向下一个元素。struct ListNode{ int val; ListNode* next;};ListNode* reverseList(ListNode* head){ ListNode* newhead=nullptr; while(head){ ListNode* next=head->next; head->next=newhead; newhead=head