【LeetCode】初级专题-链表

最新推荐文章于 2024-06-15 22:05:49 发布

zxfhahaha

最新推荐文章于 2024-06-15 22:05:49 发布

阅读量116

点赞数

分类专栏： LeetCode

本文链接：https://blog.csdn.net/zxfhahaha/article/details/101756149

版权

LeetCode 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

链表

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

删除链表中的结点

题目

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。

现有一个链表 – head = [4,5,1,9]，它可以表示为:
在这里插入图片描述
示例 1:

输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:

输入: head = [4,5,1,9], node = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
说明:
链表至少包含两个节点。
链表中所有节点的值都是唯一的。
给定的节点为非末尾节点并且一定是链表中的一个有效节点。
不要从你的函数中返回任何结果。

思路

已知要删除结点的值，则把要删除结点的下一个值赋到当前要删除的结点，然后把下一个结点删掉即可

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */


class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val = node->next->val; //把当前要删除的结点的下一个结点的值赋值为当前要删除结点的值
        node->next = node->next->next; //把下一个结点删除
    }
};

删除链表的倒数第N个节点

题目

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
示例：
给定一个链表: 1->2->3->4->5, 和 n = 2.
当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：
给定的 n 保证是有效的。
进阶：
你能尝试使用一趟扫描实现吗？

方法一

思路

首先找到链表的长度m
找到要删除结点的位置把此结点删除p->next=p->next->next

用到一个技巧就是添加一个哑结点dummy，该结点位于链表头部，即dummy->next = head，这样就可以简化某些极端情况，如列表中只含有一个结点，或者要删除列表头部。

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        int m=0; //链表的长度
        ListNode* p = head;
        ListNode* dummy = (struct ListNode*)malloc(sizeof(ListNode)); 
        dummy->next = head;//设置一个哑结点
        //得到链表的长度m
        for(;p;p=p->next){
            m = m+1;
        }

        p = dummy;
        //找到要删除结点的位置
        for (int i=0;i<m-n;i++){
            p = p->next;
        }
        //删除结点
        p->next = p->next->next;
        return dummy->next;   
    }
};

方法二：用双指针实现一次遍历

思路

设置两个指针first和second，他们的next都是头结点

先让first向前走n+1步
然后让first和second同时向前走，知道first走到最后。这样就找到了要删除的节点的位置

同样设置一个哑结点dummy
初始化结点的时候遇到了一个问题，写
dummy->next=head;
first = dummy;
second = dummy;
是对的

如果写
dummy->next=head;
first->next = head;
second->next = head;
就会出错，输入时[1]，1的时候输出还是[1]
在这里插入图片描述

代码

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        int m=0; //链表的长度
        ListNode* first = (struct ListNode*)malloc(sizeof(ListNode));
        ListNode* second = (struct ListNode*)malloc(sizeof(ListNode));
        ListNode* dummy = (struct ListNode*)malloc(sizeof(ListNode)); //设置一个哑结点

        dummy->next = head;
        first = dummy; //first->next = head; 不能写成这样
        second = dummy; //second->next = head; 不能写成这样
        
        // 先让first走n+1步
        while(n>=0){
            first = first->next;
            n = n-1;
        }
        //找到要删除节点的前一个节点
        while(first!=nullptr){
            first = first->next;
            second = second->next;
        }
        
        second->next = second->next->next;//删除当前结点
        
        return dummy->next;
        
    }
};

反转链表

反转链表一

反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？

方法一：迭代

思路

设置三个相邻的结点p1,p2,p3，让p2->next=p1，然后让三个结点都后移，直到p2为NULL。
要注意链表为空链和只有一个结点的情况
在这里插入图片描述

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==NULL||head->next==NULL){ //空链或只有一个结点直接返回它本身
            return head;
        }
        else{
        //定义三个结点分别指向相邻的结点
        ListNode* p1 = head;
        ListNode* p2 = p1->next;
        ListNode* p3 = p2->next;
        
 
        while(p2){
            p3=p2->next;
            p2->next = p1;  //第二个结点指向第一个结点进行反转
            p1 = p2;       //第一个结点向后移
            p2 = p3;       //第二个结点向后移
        }
        head->next = NULL;
        head = p1;
        return head;
        }

        
        
    }
};

方法二：递归

思路

调用反转函数反转子链表
写递归程序重要的是把调用函数当成已经执行完了返回了的值，然后做后续的工作，不用管递归是怎么做的。
所以一直递归调用反转子链后的结果应该如下图所示
即1->2<-3<-4<-5<-new_head
接下来我们要做的就是让head->next->next = head;也就是让1<-2
然后再让head->next=NULL 就完成了反转
在这里插入图片描述

代码

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        
        
        if(head==NULL||head->next==NULL){ //空链或只有一个结点直接返回它本身
            return head;
        }
        else{
        //定义三个结点分别指向相邻的结点
            ListNode *new_head = reverseList(head->next);//反转以第二个结点为头的子链表
            
            // 将之前的头结点放入子链尾
            head->next->next = head;
            head->next = NULL;
            return new_head;
        }

        
        
    }
};

92. 反转链表 II

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。

说明:
1 ≤ m ≤ n ≤ 链表长度。

示例:

输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL

方法一迭代

第一步：找到要反转链表的起始结点，并把起始结点的前一个结点记录下来为dummy
第二步：进行m-n次迭代进行反转，并把反转的最后一个结点记录下来为end
第三步：把原来的dummy的next和反转后的第一个结点连起来，end的next和之前剩下的结点连起来

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        
        if(head==NULL or head->next==NULL or m==n){ //只有一个结点或没有结点不需要反转，m和n相等也不用反转
            return head;
        }
        
        else if(head->next->next==NULL){ //只有两个结点 进行反转
            ListNode *p=head->next;
            p->next=head;
            head->next = NULL;
            return p; 
        }
        
        ListNode* p1 = head;
        ListNode* p2 = p1->next;
        ListNode* p3 = p2->next;
        ListNode* dummy = new ListNode(0);   //记录要反转的前一个结点，最后让dummy->next是反转后的结点的头结点
        ListNode* end=p1;
        dummy->next = head;  
        int flag=0;
        int b;
        b = n-m;
        while(b){
            if(m>1){  //到达要反转的起始结点之前要进行的操作：p1、p2、p3都向后移
            flag=1;
            p1 = p1->next;
            p2 = p2->next;
            p3 = p3->next;
            dummy = dummy->next;
            
            m=m-1;
                
            if(m==1){
                end = p1; //把反转后的尾结点记录下来
                
            }
            }
            else 
            {//开始反转
                p3 = p2->next;
                p2->next = p1;
                p1 = p2;
                p2 = p3;
                
                b = b-1;
                
                if(b==0){ //反转结束
                    dummy->next = p1; //把反转后的链表接到之前的后面(m之前的结点)
                    end->next = p2;   //把反转后的最后一个结点和之前剩下的结点接起来
                    if(flag==0)return dummy->next; //输入m=1的情况
                    return head;
                }
            }
        }
     return head;
    }
};

合并两个有序链表

题目

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

思路

new一个新的结点head用来存放合并后的链表，当l1和l2都不为空的时候就判断哪个大就将哪个插入head

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *head = new ListNode(0); //创建一个合并后的链表
        ListNode *l3 = head; //最后用来返回
        while(l1!=NULL and l2!=NULL){
                if(l1->val<=l2->val){
                    head->next = l1;
                    l1 = l1->next;
                    head = head->next;
                }
                else{
                    head->next = l2;
                    l2 = l2->next;
                    head = head->next;
                }
        }  
        //最后还会剩下一个结点
        if(l1!=NULL){
            head->next = l1;
        }
        else{
            head->next = l2;
        }
        return l3->next;

    }
};

回文链表

题目

请判断一个链表是否为回文链表。

示例 1:
输入: 1->2
输出: false
示例 2:

输入: 1->2->2->1
输出: true
进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

思路

因为要用O(1)空间复杂度，我们可以把链表分为两部分，将后半部分链表反转后再和前半部分比较，如果有不一样的则不是回文链表。
重点是找到中间结点把链表分成两部分，这里用到了两个结点一个pre一个lst，lst是pre->next，然后让lst向后走两步pre向后走一步，当lst走到最后的时候，pre在的位置就是前半部分链表的最后一个结点。

代码

/**
 * 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) {
        
        if(head==NULL or head->next==NULL){
            return true;
        }
        
        ListNode *pre = head;
        ListNode *lst = head->next;
        ListNode *cur = new ListNode(0);
        ListNode *q = new ListNode(0);
        ListNode *p = new ListNode(0);
        
        //找到链表的中间结点
        while(lst!=NULL and lst->next!=NULL){
            lst = lst->next->next; //lst向后走两步
            pre = pre->next;       //pre向后走一步
        }
        //把链表分成两部分
        cur = pre->next;
        pre->next=NULL; //前半部分的尾结点赋值为NULL
        p = NULL; //后半部分的尾结点赋值为NULL
        
        //把后半部分的链表反转
        while(cur!=NULL){
            q = cur->next;
            cur->next = p;
            p = cur;
            cur = q;
        }
        //比较前半部分的链表和反转后的后半部分的链表是否一样
        while(p!=NULL and head!=NULL){
            if(head->val!=p->val){
                return false;
            }
            head = head->next;
            p = p->next;
        }
        return true;
        
    }
};

环形链表

题目

方法一利用hash set

思路

利用hash set存储每个结点，如果当前结点在hash表存在则证明是环形

代码

/**
 * 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) {
        //建一个哈希set
        set<ListNode*> nodeseen;
        while(head!=NULL){
            if(nodeseen.count(head)){  //当前访问的结点在hash表中存在
                return true;
            }
            else{
                nodeseen.insert(head); //将当前结点存储在hash表中
            }
            head = head->next;
        }
        
        return false;
        
    }
};

方法二

思路

创建快慢两个指针，快指针每次走两步，慢指针每次走一步，如果有环的话快指针一定能追上慢指针
要注意fast和fast->都不为空才进入循环

代码

class Solution {
public:
    bool hasCycle(ListNode *head) {
        //创建快慢两个指针
        ListNode *slow = head;
        ListNode *fast = head;
        while(fast!=NULL and fast->next!=NULL){ //要注意访问后两个结点的时候要判断fast的next是否为空
            //快指针每次走两步，慢指针每次走一步
            slow = slow->next;
            fast = fast->next->next;
            while(slow==fast){   //如果慢指针追上了快指针证明有环
                return true;
            }
            
        }
        return false;
    }
};

zxfhahaha

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【LeetCode】初级专题-链表

链表链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。删除链表中的结点题目请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。现有一个链表 – head = [4,5,1,9]，它可以表示为:示例 1:输入: head = [4,5,1,9], node = 5输出: [4,1,9]解释:...
复制链接

扫一扫