1. 删除链表中等于val 的所有节点
203. 移除链表元素
难度简单
给你一个链表的头节点 head 和一个整数 val ,
请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。
示例 1:
![](https://i-blog.csdnimg.cn/blog_migrate/33dbb4ba94d93be5b504ef7a6c7e5a91.jpeg)
输入:head = [1,2,6,3,4,5,6], val = 6
输出:[1,2,3,4,5]
示例 2:
输入:head = [], val = 1
输出:[]
示例 3:
输入:head = [7,7,7,7], val = 7
输出:[]
提示:
列表中的节点数目在范围 [0, 10^4] 内
1 <= Node.val <= 50
0 <= val <= 50
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* removeElements(struct ListNode* head, int val) {
}
代码:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* removeElements(struct ListNode* head, int val) {
struct ListNode* cur = head;
struct ListNode* prev = NULL;
while (cur)
{
if (cur->val == val)
{
if (cur == head)
{
head = cur->next;
free(cur);
cur = head;
}
else
{
prev->next = cur->next;
free(cur);
cur = prev->next;
}
}
else
{
prev = cur;
cur = cur->next;
}
}
return head;
}
2. 反转一个单链表
206. 反转链表
难度简单
给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。
示例 1:
![](https://i-blog.csdnimg.cn/blog_migrate/dbba3c92e75794bfd8164197c5d130db.jpeg)
输入:head = [1,2,3,4,5]
输出:[5,4,3,2,1]
示例 2:
![](https://i-blog.csdnimg.cn/blog_migrate/83df8b4067ac6b2e3f503063143f448f.jpeg)
输入:head = [1,2]
输出:[2,1]
示例 3:
输入:head = []
输出:[]
提示:
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000
进阶:链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题?
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* reverseList(struct ListNode* head) {
}
时间O(N^2)的代码:
(自己第一遍写的笨方法)过了挺高兴,看完别人的思路就...
![](https://i-blog.csdnimg.cn/blog_migrate/55a046f7cd2557fa88a956d95170b4e5.jpeg)
struct ListNode* reverseList(struct ListNode* head) {
if (head == NULL)
{
return NULL;
}
struct ListNode* cur = head;
while (cur->next)//直接找到最后一个在指回来
{
cur = cur->next;
}
struct ListNode* newHead = cur;
while(cur!=head)
{
struct ListNode* prev = head;
while (prev->next != cur)
{
prev = prev->next;
}
cur->next = prev;
cur = prev;
}
cur->next = NULL;
return newHead;
}
时间O(N)的代码(三指针):
struct ListNode* reverseList(struct ListNode* head) {
if(head==NULL)
{
return NULL;
}
struct ListNode *n1=NULL,*n2=head,*n3=head->next;
while(n2)
{
n2->next=n1;//翻转
n1=n2;//迭代往后走
n2=n3;
if(n3!=NULL)
{
n3=n3->next;
}
}
return n1;
}
简化:
struct ListNode* reverseList(struct ListNode* head) {
struct ListNode *n1=NULL,*n2=head;
while(n2)
{
struct ListNode *n3=n2->next;
n2->next=n1;//翻转
n1=n2;//迭代往后走
n2=n3;
}
return n1;
}
时间O(N)的代码(头插):
其实和上面本源是一样的(上面简化后应该就是这个了),只是名字变了可能更好理解
struct ListNode* reverseList(struct ListNode* head) {
struct ListNode* newHead=NULL,*cur=head;
while(cur)
{
struct ListNode* curNext=cur->next;
cur->next=newHead;//头插
newHead=cur;//迭代往后走
cur=curNext;
}
return newHead;
}
3.返回链表的中间结点
876. 链表的中间结点
难度简单
给定一个头结点为 head 的非空单链表,返回链表的中间结点。
如果有两个中间结点,则返回第二个中间结点。
示例 1:
输入:[1,2,3,4,5]
输出:此列表中的结点 3 (序列化形式:[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意,我们返回了一个 ListNode 类型的对象 ans,这样:
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.
示例 2:
输入:[1,2,3,4,5,6]
输出:此列表中的结点 4 (序列化形式:[4,5,6])
由于该列表有两个中间结点,值分别为 3 和 4,我们返回第二个结点。
提示:
给定链表的结点数介于 1 和 100 之间。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* middleNode(struct ListNode* head){
}
普通思路的代码:
struct ListNode* middleNode(struct ListNode* head){
struct ListNode*cur=head;
int count=0;
while(cur!=NULL)
{
cur=cur->next;
count++;//计算链表长度
}
struct ListNode*middle=head;
for(int i=0;i<count/2;i++)//如5的话3次,6的话4次
{
middle=middle->next;
}
return middle;
}
这样的时间复杂度是N+N/2 虽然还是O(N)
但是以后面试可能会要求只能遍历一遍数组呢,这时就要用到快慢指针的思想了
虽然以前有用过,但是变一下就想不到了,看到这个思路又是震惊的一天...
![](https://i-blog.csdnimg.cn/blog_migrate/0818a8eb3f5fd258acbd3e7977f2b4a9.jpeg)
运用快慢指针的代码:
struct ListNode* middleNode(struct ListNode* head) {
struct ListNode* fast = head , * slow = head;
while (fast!=NULL&&fast->next!=NULL)
{
fast=fast->next->next;//快指针一次走两步
slow=slow->next;//慢指针一次走一步
}
return slow;
}
4. 输出该链表中倒数第k个结点
剑指 Offer 22. 链表中倒数第k个节点
输入一个链表,输出该链表中倒数第k个节点。为了符合大多数人的习惯,
本题从1开始计数,即链表的尾节点是倒数第1个节点。
例如,一个链表有 6 个节点,从头节点开始,它们的值依次是 1、2、3、4、5、6。
这个链表的倒数第 3 个节点是值为 4 的节点。
示例:
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* getKthFromEnd(struct ListNode* head, int k){
}
(这题没给范围,有点不严谨,但是懂思路就好了)
力扣这题是后更新的,所以测试用例更不严谨
这里说一下,力扣应该是OJ题做的最好的,但是面试那些应该用牛客多一点。
普通思路的代码:
这题和上一题的普通思路一样,相当于遍历两次链表
struct ListNode* getKthFromEnd(struct ListNode* head, int k){
struct ListNode*cur=head;
int count=0;
while(cur!=NULL)
{
cur=cur->next;
count++;//计算链表长度
}
struct ListNode*newHead=head;
for(int i=0;i<count-k;i++)
{
newHead=newHead->next;
}
return newHead;
}
写完普通思路我想着用快慢指针怎么用,想了几秒就觉得不行就不想了,以为不能用
(不想动太多脑的坏处)看到别人的思路我已经开始咬嘴唇了...
![](https://i-blog.csdnimg.cn/blog_migrate/55e0d33f66d8aaca7ed8cf8ea4e0306c.jpeg)
虽然觉得k不一样时,时间一样,但是帅就对了:
运用快慢指针的代码:
struct ListNode* getKthFromEnd(struct ListNode* head, int k){
struct ListNode* fast = head , * slow = head;
while(k--)
{
if(fast==NULL)
{
return NULL;
}
fast=fast->next;//快指针先走k步
}
while(fast)
{
fast=fast->next;
slow=slow->next;//快慢指针一起走
}
return slow;
}
5. 合并两个有序链表为一个新的有序链表
21. 合并两个有序链表
难度简单
将两个升序链表合并为一个新的 升序 链表并返回。
新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1:
![](https://i-blog.csdnimg.cn/blog_migrate/ea5e09b8cb12a7eca0af16ed74951597.jpeg)
输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]
示例 2:
输入:l1 = [], l2 = []
输出:[]
示例 3:
输入:l1 = [], l2 = [0]
输出:[0]
提示:
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
}
尾插法代码:
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
if (list1 == NULL)
{
return list2;
}
if (list2 == NULL)
{
return list1;
}
struct ListNode* cur=NULL;
if(list1->val <= list2->val)
{
cur = list1;
list1 = list1->next;
}
else
{
cur = list2;
list2 = list2->next;
}
struct ListNode* new = cur;
while (list1 && list2)
{
if (list1->val <= list2->val)
{
cur->next = list1;
cur = list1;
list1 = list1->next;
}
else
{
cur->next = list2;
cur = list2;
list2 = list2->next;
}
}
if (list1 == NULL)
{
cur->next = list2;
}
else
{
cur->next = list1;
}
return new;
}
尾插法+哨兵位的头节点代码:
哨兵位的头节点就是不存数据的节点
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
if (list1 == NULL)
{
return list2;
}
if (list2 == NULL)
{
return list1;
}
struct ListNode* cur = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* new = cur;
while (list1 && list2)
{
if (list1->val <= list2->val)
{
cur->next = list1;
cur = list1;
list1 = list1->next;
}
else
{
cur->next = list2;
cur = list2;
list2 = list2->next;
}
}
if (list1 == NULL)
{
cur->next = list2;
}
else
{
cur->next = list1;
}
struct ListNode* newHead = new->next;
free(new);
return newHead;
}
本篇完。
后面还有接着这部分的较难的OJ题