leetcode(链表专题)

数组模拟链表

#include<iostream>
using namespace std;const int N = 100;
// 单链表
// head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点
int head, e[N], ne[N], idx;// 初始化
void init()
{head = -1;idx = 0;
}// 在链表头插入一个数a
void insert(int a)
{//先对新结点赋值e[idx] = a;//新结点的next指针指向前一个结点的next指针的位置ne[idx] = head;//把head的next位置更新为新结点，并且idx++,因为当前idx已经使用head = idx++;//  e[idx] = a, ne[idx] = head, head = idx ++ ;
}// 将头结点删除，需要保证头结点存在
void remove()
{head = ne[head];
}

19. 删除链表的倒数第 N 个结点

思路

双指针,

第一个点可以能被删除，所以需要一个虚拟头节点。被删除的点位于倒数第n的位置，因为是单链表，即找到倒数n + 1最后，想要删除这个节点必须要保留它的前一个节点使其p->next = p->next->next。返回虚拟头节点的next。可以先使一个指针移动n步，然后两个指针

同时移动，第一个指针到达最后的时候，第二个指针恰好在倒数第n + 1的位置

code

/*** Definition for singly-linked list.* 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) {}* };*/
class Solution {
public:ListNode* removeNthFromEnd(ListNode* head, int n) {auto p1 = new ListNode(-1);p1->next = head;auto p2 = p1 , p3 = p1;//先走n步while(n--)p2 = p2->next;//双指针同时向后移动，两个指针的距离是确定的while(p2->next){p2 = p2->next;p3 = p3->next;}p3->next = p3->next->next;return p1->next;}
};

21. 合并两个有序链表

思路：使用递归合并。口诀判空返，谁小递归谁，谁小返回谁。

/*** Definition for singly-linked list.* 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) {}* };*/
class Solution {
public:ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {if(list1 == nullptr)return list2;if(list2 == nullptr)return list1;if(list1->val <= list2->val){list1->next = mergeTwoLists(list1->next,list2);return list1;}else{list2->next = mergeTwoLists(list1,list2->next);return list2;}   }
};

83. 删除排序链表中的重复元素

思路：相邻指针。使用相邻指针，对相邻两个结点进行对比，按照题意保留一个相同元素，那么就保留靠前的第一个。如果发现相邻的相同，则使用相同结点靠后的一个结点的下一个结点覆盖前面的结点，即p->next = p->next->next ，如果不同则把当前结点更新为下一个结点p = p->next

/*** Definition for singly-linked list.* 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) {}* };*/
class Solution {
public:ListNode* deleteDuplicates(ListNode* head) {if(!head)return nullptr;auto p1 = head;while(p1){if(p1->next && p1->next->val == p1->val)p1->next = p1->next->next;else p1 = p1->next;}return head;}
};

82. 删除排序链表中的重复元素 II

思路

因为要删除所有相同的元素，所以head可能被修改，所以创建一个新的虚拟头节点dump。

需要声明一个结点p使得它为dump,一个结点q为dump->next。

如果q->val等于p-next->val的情况下，q就继续前进，直到找到一个与p->val不等的地方停下，判断当前q与p->next->next是否相等。作用就是（如果相等说明中间只有一个点）,相反执行p->next = q ,删除中间的内容，最后循环完毕返回dump->next。

code

/*** Definition for singly-linked list.* 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) {}* };*/
class Solution {
public:ListNode* deleteDuplicates(ListNode* head) {auto dummy = new ListNode(-1);dummy->next = head;auto p = dummy;while (p->next) {auto q = p->next;while (q && q->val == p->next->val) q = q->next;if (p->next->next == q) p = p->next;else p->next = q;}return dummy->next;}
};

思路

快慢指针算法，边界判断如果(快指针的next为空)则为奇数个，如果（快指针为空）则为偶数个。

code

class Solution {
public:ListNode* middleNode(ListNode* head) {auto p1 = head, p2 = head;while (p1 && p1->next){p2 = p2->next;p1 = p1->next->next;}return p2;}
};

206. 反转链表

思路

双指针算法，前后指针逐个翻转，直到最后一个节点，需要考虑边界问题。

code

//迭代法
class Solution {
public:ListNode* reverseList(ListNode* head) {if(!head)return NULL;auto p1 = head, p2 = p1->next;//定义两个相邻指针while(p2) {auto p3 = p2->next; //p3存储p2的后继节点p2->next = p1; //后面节点指针指向前面的节点p1 = p2;//双指针统一向后偏移p2 = p3;} head->next=NULL;return p1;}
};//递归法
class Solution {
public:ListNode* reverseList(ListNode* head) {if (!head || !head->next) return head;ListNode *tail = reverseList(head->next);head->next->next = head;head->next = nullptr;return tail;}
};

234. 回文链表

思路

使用vector来存储链表，然后来检查其中每一个元素，是否组成回文.。

code

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     ListNode *next;*     ListNode(int x) : val(x), next(NULL) {}* };*/
class Solution {
public:bool isPalindrome(ListNode* head) {vector<int> v;while(head){v.push_back(head->val);head = head->next;}// 判断是否回文for(int i=0; i<v.size()/2; ++i){if(v[i] != v[v.size()-1-i]){return false;}}return true;}
};

141. 环形链表

思路

快慢指针，如果快指针被慢指针追上一定是环形链表。

code

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     ListNode *next;*     ListNode(int x) : val(x), next(NULL) {}* };*/
class Solution {
public:bool hasCycle(ListNode *head) {ListNode *l1,*l2;l1=l2=head;while(l1!=NULL && l2!=NULL &&l1->next !=NULL){l1 = l1->next->next;l2 = l2->next;if(l1 == l2)return true;}return false;}
};

160. 相交链表

思路

1.哈希表，通过把第一个链表的每个结点存入哈希表中，再遍历第二个链表来判断是否在哈希表中存在，入股存在即为相交结点。

2.双指针，即两个指针指向两个链表，同时走，如果相交那么就一定相等；如果不相交那么就是两条指针最后都为空。如图

code

//哈希表
/*** Definition for singly-linked list.* struct ListNode {*     int val;*     ListNode *next;*     ListNode(int x) : val(x), next(NULL) {}* };*/
class Solution {
public:ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {unordered_set<ListNode *> visited;ListNode *temp = headA;while (temp != nullptr) {visited.insert(temp);temp = temp->next;}temp = headB;while (temp != nullptr) {if (visited.count(temp)) {return temp;}temp = temp->next;}return nullptr;}
};//双指针
class Solution {
public:ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {if (headA == nullptr || headB == nullptr) {return nullptr;}ListNode *pA = headA, *pB = headB;while (pA != pB) {pA = pA == nullptr ? headB : pA->next;pB = pB == nullptr ? headA : pB->next;}return pA;}
};

148. 排序链表

思路

(归并排序) 时间：O(nlogn)，空间O(1)
自顶向下递归形式的归并排序，由于递归需要使用系统栈，递归的最大深度是 logn，所以需要额外 O(logn)的空间。
所以我们需要使用自底向上非递归形式的归并排序算法。
基本思路是这样的，总共迭代 logn 次：

第一次，将整个区间分成连续的若干段，每段长度是2：[a0,a1],[a2,a3],…[an−1,an−1]，然后将每一段内排好序，小数在前，大数在后；
第二次，将整个区间分成连续的若干段，每段长度是4：[a0,…,a3],[a4,…,a7],…[an−4,…,an−1]，然后将每一段内排好序，这次排序可以利用之前的结果，相当于将左右两个有序的半区间合并，可以通过一次线性扫描来完成；
依此类推，直到每段小区间的长度大于等于 n 为止；
另外，当 n 不是2的整次幂时，每次迭代只有最后一个区间会比较特殊，长度会小一些，遍历到指针为空时需要提前结束。

时间复杂度分析：整个链表总共遍历 logn 次，每次遍历的复杂度是 O(n)，所以总时间复杂度是 O(nlogn)。
空间复杂度分析：整个算法没有递归，迭代时只会使用常数个额外变量，所以额外空间复杂度是 O(1)

code

/*** Definition for singly-linked list.* 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) {}* };*/
class Solution {
public:ListNode* sortList(ListNode* head) {int n = 0;for (auto p = head; p; p = p->next) n ++ ;for (int i = 1; i < n; i *= 2) {auto dummy = new ListNode(-1), cur = dummy;for (int j = 1; j <= n; j += i * 2) {auto p = head, q = p;for (int k = 0; k < i && q; k ++ ) q = q->next;auto o = q;for (int k = 0; k < i && o; k ++ ) o = o->next;int l = 0, r = 0;while (l < i && r < i && p && q)if (p->val <= q->val) cur = cur->next = p, p = p->next, l ++ ;else cur = cur->next = q, q = q->next, r ++ ;while (l < i && p) cur = cur->next = p, p = p->next, l ++ ;while (r < i && q) cur = cur->next = q, q = q->next, r ++ ;head = o;}cur->next = NULL;head = dummy->next;}return head;}
};

25. K 个一组翻转链表

思路

通过模拟法，模拟整个过程。需要提供双指针来维护修改某一区间的关系（例如相邻节点）,

需要注意在修改节点的指针指向之前，要保存原有指向，以便利用。

解题步骤：

1.头节点可能要被改变，所以需要一个虚拟头节点

2.遍历是否够K个

3.交换K个元素，先将内部反转，然后处理连接前面部分，再处理连接后面部分

code

/*** Definition for singly-linked list.* 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) {}* };*/
class Solution {
public:ListNode* reverseKGroup(ListNode* head, int k) {auto dump = new ListNode(-1);dump->next = head;for(auto p = dump;;){auto q = p;//计算后面是否有足够的k来支撑for(int i = 0; i < k && q;i++) q = q->next;//如果不够直接结束if(!q)break;auto a = p->next,b = a->next;//如果有k个节点，需要把内部反转k - 1次for(int i = 0; i < k -1 ;i++){auto c = b->next;b->next = a;a = b, b = c;}auto c = p->next;p->next = a, c->next = b;p = c;}return dump->next;}
};

Leetcode 146. LRU 缓存机制

思路:使用双链表模拟队列，使用哈希表记录键值对

class LRUCache {
public:struct Node {int key, val;Node *left, *right;Node(int _key, int _val): key(_key), val(_val), left(NULL), right(NULL) {}}*L, *R;unordered_map<int, Node*> hash;int n;void remove(Node* p) {p->right->left = p->left;p->left->right = p->right;}void insert(Node* p) {p->right = L->right;p->left = L;L->right->left = p;L->right = p;}LRUCache(int capacity) {n = capacity;L = new Node(-1, -1), R = new Node(-1, -1);L->right = R, R->left = L;}int get(int key) {if (hash.count(key) == 0) return -1;auto p = hash[key];remove(p);insert(p);return p->val;}void put(int key, int value) {if (hash.count(key)) {auto p = hash[key];p->val = value;remove(p);insert(p);} else {if (hash.size() == n) {auto p = R->left;remove(p);hash.erase(p->key);delete p;}auto p = new Node(key, value);hash[key] = p;insert(p);}}
};/*** Your LRUCache object will be instantiated and called as such:* LRUCache* obj = new LRUCache(capacity);* int param_1 = obj->get(key);* obj->put(key,value);*/

leetcode(链表专题)相关推荐

写出一段代码将链表中的两个节点位置互换位置_面试 leetcode 算法专题系列（二）—— 链表...
前言:只照着常考题去刷题确实是一种方法.但调研之后发现自己还是考虑不周,刷题刷的不应该是题,而是解题的思路和熟练程度.于是我决定重新组织一下刷题笔记的讲解顺序,不再以面试常考题来刷.而是以面试出题频率 ...
leetcode探索专题中的初级算法练习题（python代码+解题思路）
本文记录leetcode探索专题中的初级算法练习题,附python实现代码&解题思路,做题过程不免查阅网络资料,侵删~如有错误,欢迎指正交流! 目录专题一:数组: 26.从排序数组中删除重复 ...
LeetCode——链表
LeetCode--链表目录概述找出两个链表的交点链表反转归并两个有序的链表从有序链表中删除重复节点删除链表的倒数第n个节点交换链表中的相邻节点链表求和回文链表分隔链表链表元素 ...
面试官系列 - LeetCode链表知识点题型总结
文章目录前言知识点什么是链表类别单向链表循环链表双向链表双向循环链表与数组的性能对比优缺点常用技巧题型总结基本操作删除类翻转类题型合并链表环形链表拆分链表排序链表 ...
dummy节点——leetcode链表题必备
做leetcode链表题的时候,需要额外考虑链表头部的特殊情况.但是,往往考虑不够周全,导致最后通过不断试错,修改代码.代码变得臃肿,可读性差. 其实,引入一个dummy节点就可以解决大部分需要考虑头 ...
环形链表(专题，带图示和思路）
环形链表专题1和II 环形链表思路1 代码实现环形链表II 思路1 代码实现思路2 代码实现环形链表给定一个链表,判断链表中是否有环. 为了表示给定链表中的环,我们使用整数 pos 来表示链 ...
每周leetcode - 02链表专题 237/83/234/138/92/142/Offer 22/148/23/24/147/86/61/328/2/Offer06
文章目录 leetcode - 237. 删除链表中的节点 leetcode - 83. 删除排序链表中的重复元素 leetcode - 234. 回文链表 leetcode - 138. 复制带随机 ...
LeetCode Hot100 ---- 链表专题专题
链表力扣109:将有序链表转化为二叉搜素树力扣141:环形链表判断是否有环力扣142:环形链表检测入口位置力扣143:重拍链表力扣160:相交链表力扣206:反转链表力扣21:合并两个有 ...
递增的整数序列链表的插入_每日算法题 | 剑指offer 链表专题（5）链表中倒数第k个节点...
点击上方"Jerry的算法和NLP",选择"星标"公众号重磅干货,第一时间送达题目链表中倒数第k个节点题目要求输入一个链表的头结点,从尾到头反过来打印 ...

leetcode(链表专题)

leetcode(链表专题)相关推荐

最新文章

热门文章