xiji333的博客

https://leetcode-cn.com/problems/lru-cache/思路：使用双向链表模拟队列，当执行获取或者写入操作时，将对应的节点放到头节点之后(队头)。为了做到O(1)O(1)O(1)获取数据、O(1)O(1)O(1)写入数据，我们还需要一个哈希表，建立从keykeykey到双向链表节点的映射。class LRUCache {public: LRUCache(int capacity):c(capacity) { } int get(int

https://leetcode-cn.com/problems/design-linked-list/思路：没啥好说的，手写一个单向链表就行了。我这边多记录了一下链表的长度和尾节点。class MyLinkedList {public: /** Initialize your data structure here. */ MyLinkedList():head(new node()),tail(head),size(0) {} /** Get the value

https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/思路：双指针。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {publ

https://leetcode-cn.com/problems/linked-list-in-binary-tree/思路：很自然的想到一种解法，即对树中的每个节点都做一次判断。双dfsdfsdfs即可。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {}

https://leetcode-cn.com/problems/rotate-list/思路：其实就是把链表循环右移kkk步，首先计算出链表长度nnn，令k%=nk\%=nk%=n，然后找到倒数第kkk个链表作为头节点即可，那么需要把链表从k−1k-1k−1处断开，并把末尾连接到头部。注意特判kkk为000的情况。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode

https://leetcode-cn.com/problems/remove-zero-sum-consecutive-nodes-from-linked-list/comments/思路一：暴力。枚举起始点lll，找到一个终结点rrr，使得[l,r)[l,r)[l,r)元素之和等于000，然后修改节点之间的关系即可。最差情况下时间复杂度为O(n2)O(n^2)O(n2)。注意此题不能使用deletedeletedelete回收空间。/** * Definition for singly-link

https://leetcode-cn.com/problems/sum-lists-lcci/思路：反向存放比较简单，模拟就行了。考虑进阶怎么做？(1)(1)(1)先翻转链表，再利用相同的办法处理；(2)(2)(2)利用栈。注意(1)(1)(1)会对原链表进行修改。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(i

https://leetcode-cn.com/problems/remove-linked-list-elements/思路一：迭代。注意需要删除头节点的情况(可以新增一个伪头节点，方便操作)。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * };

https://leetcode-cn.com/problems/palindrome-linked-list-lcci/思路：如果是O(n)O(n)O(n)的空间复杂度，那么很好写，存到数组中判断即可。我们考虑怎么做到O(1)O(1)O(1)的空间复杂度。可以利用快慢指针得到链表的中点，然后把前半部分翻转，再与后半部分...

https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/思路：注意看清题意，是删除所有含有重复数字的节点。那么当cur−>valcur->valcur−>val与nxt−>valnxt->valnxt−>val相等时，这两个节点都要删除，这意味着我们需要记录curcurcur的前驱preprepre。那么用这三个指针模拟一下就行了，注意细节即可。/** * Definition

https://leetcode-cn.com/problems/linked-list-cycle-lcci/思路：详见https://blog.youkuaiyun.com/xiji333/article/details/105547321，差不多同一道题目。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) :

https://leetcode-cn.com/problems/flatten-a-multilevel-doubly-linked-list/思路一：递归。其实我们可以把它想象成树形结构，node−>childnode->childnode−>child为树形结构中的左儿子，node−>nextnode->nextnode−>next为树形结构中的右儿子。那么对这棵树进行先序遍历，即可得到结果。当我们使用递归处理一个链表时，可以很容易的得到这个链表的尾节点(非空)

https://leetcode-cn.com/problems/reverse-linked-list-ii/思路：首先找到第m−1m-1m−1个节点设为preprepre，然后反转mmm到nnn的链表，假设第n+1n+1n+1个节点为curcurcur，由于pre−>nextpre->nextpre−>next最初指向第mmm个节点，且在反转过程中没有修改它的值，所以在反转结束后pre−>nextpre->nextpre−>next指向第nnn个节点，那么此时还需

https://leetcode-cn.com/problems/merge-k-sorted-lists/思路一：暴力合并，即利用mergemergemerge算法，逐一合并两个链表。为方便分析复杂度，我们假设有kkk个链表，每个链表的最大长度为nnn，那么该算法的时间复杂度为O(n∗k2)O(n*k^2)O(n∗k2)。/** * Definition for singly-linked list. * struct ListNode { * int val; * List

https://leetcode-cn.com/problems/split-linked-list-in-parts/思路：假设链表长度为nnn，要将其分成kkk部分，我们可以先使得每部分的节点个数为n/kn/kn/k(向下取整)，那么还有n%kn\%kn%k个节点没有处理，为了满足题意，我们需要将这n%kn\%kn%k个节点分散到链表的前几部分，即前n%kn\%kn%k个链表每个都具有n/k+1n/k+1n/k+1个元素，剩下的k−n%kk-n\%kk−n%k个链表每个都具有n/kn/kn/k个元素

https://leetcode-cn.com/problems/copy-list-with-random-pointer/思路一：首先忽略randomrandomrandom指针，遍历给定链表h1h_1h1​，同时建立出它的深拷贝h2h_2h2​，并建立从h1h_1h1​到h2h_2h2​的映射。然后我们再次遍历链表h1h_1h1​，有了映射关系，就可以修改randomrandomrandom指针了。/*// Definition for a Node.class Node {public:

https://leetcode-cn.com/problems/next-greater-node-in-linked-list/思路：简而言之，就是求每个节点右侧大于它的第一个节点的值。单调栈可解，首先把链表转为普通的数组就行了。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), n

https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/submissions/思路：简单模拟。比较当前节点curcurcur和下一节点nxtnxtnxt的值，再做删除或移动操作即可。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int

https://leetcode-cn.com/problems/reverse-nodes-in-k-group/思路：没啥好办法，只能模拟了。kkk个节点kkk个节点的翻转即可，注意一下细节问题。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }

https://leetcode-cn.com/problems/reorder-list/思路：首先通过快慢指针得到链表的中点，从中点处断开再将后半部分翻转一下，那么问题就很简单了，逐一合并两个链表即可。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} *

https://leetcode-cn.com/problems/linked-list-components/思路：哈希一下GGG中出现的值，然后遍历链表判断就行了。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solu

https://leetcode-cn.com/problems/add-two-numbers-ii/思路：加法自然要从最低位开始搞，那么可以先把给定的链表翻转一下再处理，但是这样做太麻烦了。用栈就可以了，注意进位问题。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NU

https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof/思路一：迭代法，特判一下头节点的情况就可以了。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */cl

https://leetcode-cn.com/problems/odd-even-linked-list/思路：一个链表存奇数节点，另外一个存偶数节点，再把他们连起来即可。注意哨兵的作用。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * List

https://leetcode-cn.com/problems/partition-list-lcci/思路：这题做法也很多的，最蠢的应该就是排序了，我们来说以下线性复杂度的做法。搞一个smallsmallsmall链表把<x<x<x的节点连接起来，再搞一个bigbigbig链表把>=x>=x>=x的节点连接起来，然后把smallsmallsmall的尾部指向bigbigbig的头部，再把bigbigbig的尾部指向空即可。搞两个哨兵，方便操作。/** * De

https://leetcode-cn.com/problems/insertion-sort-list/思路：实现链表的插排即可，由于单向链表没有preprepre指针，所以找插入位置时只能从前往后找，搞一个哨兵方便操作。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(N

https://leetcode-cn.com/problems/merge-two-sorted-lists/思路一：迭代做法。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nul

https://leetcode-cn.com/problems/swap-nodes-in-pairs/思路一：顺着做，这样也有两种做法。第一种就是直接两个两个交换，那么需要记录前驱和后继。第二种就是先把链表分成两个小的链表，一个存储奇数位置的树，一个存储偶数位置的数，然后再把他们合起来。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; *

https://leetcode-cn.com/problems/sort-list/思路一：由于链表这种数据结构的特殊性，想要在O(nlgn)O(nlgn)O(nlgn)时间复杂度下完成排序，就只能选择归并排序啦。递归版的很简单，利用快慢指针计算出链表中点，将链表一分为二然后递归下去即可。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; *

https://leetcode-cn.com/problems/middle-of-the-linked-list/思路：三种思路，(1)(1)(1)把每个节点(指针)都存到数组中，那么可以直接得到中间节点。(2)(2)(2)先遍历一遍得到链表的长度，然后再从头开始遍历到中间位置。(3)(3)(3)双指针，快指针每次走222步，慢指针每次走111步，快指针走到头的时候慢指针即为所求。以下是(3)(3)(3)的实现代码。/** * Definition for singly-linked list.

https://leetcode-cn.com/problems/remove-duplicate-node-lcci/思路：因为元素范围在[0,20000][0,20000][0,20000]内，所以搞一个数组哈希存一下出现过的值即可。剩下的操作就是简单的删除单向链表的某个节点辣(当然可以暴力O(n2)O(n^2)O(n2)搞，这样空间复杂度是O(1)O(1)O(1)的)。/** * Definition for singly-linked list. * struct ListNode {

https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof/思路一：正着做，假设当前节点为curcurcur，前一节点为preprepre，那么只需要把curcurcur接到preprepre前面即可，当然需要一个临时变量预先存储下一节点nxtnxtnxt。注意细节，需要把尾节点的nextnextnext设为空。/** * Definition for singly-linked list. * struct ListNode { *

https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/思路一：顺序存储后反向一下再返回即可。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */cla

https://leetcode-cn.com/problems/kth-node-from-end-of-list-lcci/思路：搞两个指针p1、p2p_1、p_2p1​、p2​，p1p_1p1​先前进kkk步，这样保证了两个指针差距为kkk，那么当p1p_1p1​走到链表尾时，p2p_2p2​即为倒数第kkk个节点。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListN

https://leetcode-cn.com/problems/convert-binary-number-in-a-linked-list-to-integer//** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Soluti

https://leetcode-cn.com/problems/delete-middle-node-lcci/思路：因为是单向链表，所以无法直接删除当前节点，那么将下一节点的值赋给当前节点，然后删除下一节点即可。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL)

https://pintia.cn/problem-sets/994805046380707840/problems/994805072641245184L2-002 链表去重 （25 分)给定一个带整数键值的链表 L，你需要把其中绝对值重复的键值结点删掉。即对每个键值 K，只有第一个绝对值等于 K 的结点被保留。同时，所有被删除的结点须被保存在另一个链表上。例如给定 L 为 21→-15...

https://www.luogu.org/problemnew/show/P1996题目背景约瑟夫是一个无聊的人！！！题目描述n个人(n&lt;=100)围成一圈,从第一个人开始报数,数到m的人出列,再由下一个人重新从1开始报数,数到m的人再出圈,……依次类推,直到所有的人都出圈,请输出依次出圈人的编号.输入输出格式输入格式： n m 输出格式： ...