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);*/

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/335817.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

lagom cqrs_Java和Lagom的CQRS

lagom cqrs_Java和Lagom的CQRS

lagom cqrs我很高兴在Chicago Java User Group上进行了讨论&#xff0c;并讨论了Lagom如何实现CQRS&#xff08;命令查询责任隔离模式&#xff09;。 值得庆幸的是&#xff0c;有一个录音&#xff0c;我还把这些幻灯片发布在slideshare上 。 抽象&#xff1a; 一旦应用程序变…
阅读更多...
python项目管理器 宝塔面板 django 404_宝塔面板成功部署Django项目流程(图文)

python项目管理器 宝塔面板 django 404_宝塔面板成功部署Django项目流程(图文)

上线 Django 项目记录&#xff0c;超简单&#xff0c;避免无意义的踩坑&#xff01;第一步&#xff1a;安装python管理器在宝塔在线面板安装“ python项目管理器 ”第二步&#xff1a;安装适配python版本因为服务器 centos7 系统默认的 python 版本是 2.7而我们项目是基于最新版…
阅读更多...
leetcode(字符串专题)

leetcode(字符串专题)

5. 最长回文子串 思路
阅读更多...
使用Spring boot，Thymeleaf，AngularJS从零开始构建新的Web应用程序–第3部分

使用Spring boot，Thymeleaf，AngularJS从零开始构建新的Web应用程序–第3部分

在之前的博客中&#xff0c;我们使用Thymeleaf&#xff0c;Bower和Bootstrap构建了登录页面&#xff0c;并将其部署到了Heroku。 在此博客中&#xff0c;我们将介绍用于前端的AngularJS和在后端的Spring Boot Web服务的一些功能。 我们将从“登录/注销”部分开始。 让我们开始…
阅读更多...
android的oomkiller_Android Low memory killer

android的oomkiller_Android Low memory killer

Android Low memorykillerby 永远的伊苏Android中&#xff0c;进程的生命周期都是由系统控制的&#xff0c;即使用户关掉了程序&#xff0c;进程依然是存在于内存之中。这样设计的目的是为了下次能快速启动。当然&#xff0c;随着系统运行时间的增长&#xff0c;内存会越来越少…
阅读更多...
C++ 11 深度学习（十二）函数新特性、内联函数、const详解

C++ 11 深度学习（十二）函数新特性、内联函数、const详解

函数后置返回类型 //后置返回类型 auto fun(int, int)->int; 内联函数 在函数定义前增加关键字 inline ,使得该函数变成内联函数 (1) 适用于函数体很小&#xff0c;调用很频繁的函数类型&#xff0c;可以引入内联函数 (2) inline影响编译器&#xff0c;在编译阶段对inc…
阅读更多...
apache pdfbox_Apache PDFBox 2

apache pdfbox_Apache PDFBox 2

apache pdfboxApache PDFBox 2已于今年早些时候发布 &#xff0c; Apache PDFBox 2.0.1和Apache PDFBox 2.0.2已发布。 Apache PDFBox是开源的&#xff08; Apache许可证版本2 &#xff09;并且基于Java&#xff08;因此易于使用&#xff0c;包括Java &#xff0c; Groovy &…
阅读更多...
cad坐标归零lisp_CAD图怎么归零

cad坐标归零lisp_CAD图怎么归零

展开全部原理&#xff0c;就是把图元Z轴线移动的负无穷远&#xff0c;然e68a84e8a2ad62616964757a686964616f31333335336530后移动到正无穷&#xff0c;除了块就可以Z轴线归零了。用autoLISP来解决。;;;;;;Z坐标归零;;(defun c:z0 ( / &kw &k1 #os1)(setvar "cmde…
阅读更多...
C++ 11 深度学习（十三）左值、右值，左值引用、右值引用、move

C++ 11 深度学习（十三）左值、右值，左值引用、右值引用、move

左值右值
阅读更多...
dynamodb java_使用Java查询DynamoDB项

dynamodb java_使用Java查询DynamoDB项

dynamodb java在上一篇文章中&#xff0c;我们继续在DynamoDB数据库上插入数据。 在本教程中&#xff0c;我们将对DynamoDB表发出一些基本查询。 主要规则是每个查询都必须使用哈希键。 查询的最简单形式是仅使用哈希键。 我们将在此表上查询Users表。 结果只有一个&#xff…
阅读更多...
冰点还原离线激活_冰点还原密钥,小编告诉你如何激活冰点还原

冰点还原离线激活_冰点还原密钥,小编告诉你如何激活冰点还原

冰点还原软件&#xff0c;它具有轻松安装、动态保护、实时瞬间恢复&#xff0c;操作简单的特点。安装了冰点还原的系统&#xff0c;无论进行了安装文件&#xff0c;还是删除文件、更改系统设置等操作&#xff0c;计算机重新启动后&#xff0c;一切将恢复成初始状态。不过这些都…
阅读更多...
【WebRTC---源码篇】（四）WebRTC线程模型

【WebRTC---源码篇】（四）WebRTC线程模型

常见的线程模型 1.为了解决频繁线程创建与销毁，在此模型中使用的线程池。在线程池创建的时候就将一些线程创建起来，以提高效率。通过控制线程数量来解决线程频繁切换。 2.一般线程与线程存在前后关系的，线程执行完毕之后生成一个新的任务（task1 , task2,task3---）插入到任…
阅读更多...
java cuba_CUBA平台–用于快速应用程序开发的开源Java框架

java cuba_CUBA平台–用于快速应用程序开发的开源Java框架

java cuba传统上&#xff0c;自计算时代开始以来&#xff0c;企业软件开发自然面临着一个挑战&#xff0c;当时自然而然地&#xff0c;企业软件开发本应专注于解决实际的业务问题&#xff0c;但与此同时&#xff0c;开发人员必须在技术上花费大量时间和精力。解决方案的一面&am…
阅读更多...
web project、web service project和java project的区别

web project、web service project和java project的区别

java project就是普通的用java写的程序&#xff0c;直接就能运行的&#xff0c;web project,web service project不能直接运行&#xff0c;必须在容器里面运行&#xff0c;这个容器就是web server&#xff0c;例如tomcat,jboss。web project就是web工程&#xff0c;简单的讲做网…
阅读更多...
WebRTC Qos优化杂记

WebRTC Qos优化杂记

WebRTC视频JitterBuffer详解 详细内容链接 JitterBuffer延迟换流畅 在丢包+延迟+抖动的弱网环境下，推流端通过NACK+FEC等方式做了一定的容错，但是可能并不能百分之百解决所有问题，而且通过SFU分发到拉流端之后，拉流端网络也可能有问题，这个时候需要JitterBuffer来做媒体…
阅读更多...
keras添加正则化全连接_TensorFlow keras卷积神经网络 添加L2正则化

keras添加正则化全连接_TensorFlow keras卷积神经网络 添加L2正则化

model keras.models.Sequential([#卷积层1keras.layers.Conv2D(32,kernel_size5,strides1,padding"same",data_format"channels_last",activationtf.nn.relu,kernel_regularizerkeras.regularizers.l2(0.01)),#池化层1keras.layers.MaxPool2D(pool_size2,…
阅读更多...
java中什么时候应用异常_生产Java应用程序中的十大异常类型-基于1B事件

java中什么时候应用异常_生产Java应用程序中的十大异常类型-基于1B事件

java中什么时候应用异常Pareto记录原理&#xff1a;97&#xff05;的记录错误语句是由3&#xff05;的唯一错误引起的 在最新的数据整理帖子之后&#xff0c;我们收到了很多反馈和问题&#xff0c;我们发现97&#xff05;的记录错误是由10个唯一错误引起的 。 根据大众的需求&…
阅读更多...
C++ 11 深度学习（十四）C++类

C++ 11 深度学习（十四）C++类

(一)综述&#xff1a;类是我们自己定义的数据类型 设计时要考虑的角度&#xff1a; 站在设计和实现的角度来考虑&#xff1b;站在使用者的角度考虑&#xff1b;父类&#xff0c;子类之间的考虑&#xff1b; &#xff08;二&#xff09;explicit 首先, C中的explicit关键字只…
阅读更多...
手动编译 lombok_Lombok，一种编译时Java注释预处理器，可最大程度地减少代码大小...

手动编译 lombok_Lombok，一种编译时Java注释预处理器，可最大程度地减少代码大小...

手动编译 lombok在本文中&#xff0c;我们将看到如何在常规Java代码中使用lombok来最大程度地减少代码长度和冗余。 什么是Lombok&#xff1f; Lombok&#xff0c;一个编译时注释预处理器&#xff0c;有助于在编译时注入一些代码。 在详细介绍之前&#xff0c;我要求您应该从…
阅读更多...
MyEclipse for Windows快捷键

MyEclipse for Windows快捷键

文章目录编辑查询/替换导航调试重构其他自定义快捷键技巧编辑 快捷键功能说明Ctrl1快速修复&#xff08;最经典的快捷键,就不用多说了&#xff0c;可以解决很多问题&#xff0c;比如import类、try catch包围等&#xff09;CtrlShiftF格式化代码。团队有统一的代码格式&#xf…
阅读更多...
最新文章

Copyright @ 2022~2023