【LeetCode】【牛客】链表刷题（一）

桜キャンドル淵

已于 2022-04-30 20:21:50 修改

阅读量1.2k

点赞数 12

分类专栏：刷题（散装的题目）数据结构(C/C++) 文章标签：链表 leetcode 算法数据结构

于 2022-04-30 20:18:07 首次发布

本文链接：https://blog.csdn.net/weixin_62684026/article/details/124516751

版权

数据结构(C/C++) 同时被 2 个专栏收录

55 篇文章 18 订阅

订阅专栏

刷题（散装的题目）

36 篇文章 3 订阅

订阅专栏

二、遍历原链表，把不是val的结点拿出来尾插到新的链表

一、反转链表

力扣

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

对于链表的转置，在此，我们给出下面的解法

一、头插法

struct ListNode* reverseList(struct ListNode* head){
    //创建我们的新头结点并置空
    struct ListNode* newhead=NULL;
    //创建我们的临时结点来存储我们传入的头结点
    struct ListNode* cur=head;
    //当我们的临时结点不为空时，进入循环
    while(cur)
    {
        //创建前置节点为临时结点的下一个结点，
        //因为我们当前的cur元素的位置将被头插到倒置的新链表中，
        //我们需要一个前置结点来记录我们原来链表的下一个结点的位置，
        //否则我们之后将找不到原来的链表。
        struct ListNode*next=cur->next;
        //将我们临时结点的下一个结点指向我们的新的头结点，通过头插的方法来实现链表的倒置
        cur->next=newhead;
        //将新的头结点的指针指向我们新的倒置链表的头结点位置
        newhead=cur;
        //将我们的临时指针指向前置结点的位置
        cur=next;
    }
    return newhead;
}

二、逆转指针

struct ListNode* reverseList(struct ListNode* head){
    if(head==NULL)
        return NULL;
    //创建三个新的指针
    struct ListNode *n1,*n2,*n3;
    //n1为我们倒置链表的头结点
    n1=NULL;
    //n2为我们当前链表的头结点
    n2=head;
    //n3为我们n2的前置结点
    n3=n2->next;
    //当我们的n2不为空时，进入循环
    while(n2)
    {
        //倒指向
        n2->next=n1;
        //迭代
        n1=n2;
        n2=n3;
        if(n3)
            n3=n3->next;
    }
    return n1;
}

二、删除链表中的指定元素

力扣

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

一、顺序逐个删除

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
            {
                //前置结点的next指向临时结点的next，保存我们当前要删除结点的下一个结点，
                //能够使我们在删除当前结点之后还能找到原来的链表
                prev->next=cur->next;
                //释放我们的要删除的结点
                free(cur);
                //将我们的临时结点指向我们删除的元素后的下一个结点
                cur=prev->next;
            }
        }
        //如果不是我们要删除的结点
        else
        {
            //将我们的prev指向cur的位置
            prev=cur;
            //将我们的cur指向链表的下一个位置
            cur=cur->next;
        }
    }
    return head;
}

二、遍历原链表，把不是val的结点拿出来尾插到新的链表

struct ListNode* removeElements(struct ListNode* head, int val){
    //创建我们临时结点，并将我们的临时结点指向我们头结点的位置
    struct ListNode *cur=head;
    //创建我们的尾结点，并将尾结点置空
    struct ListNode *tail=NULL;
    //将我们的头结点置空，因为我们需要将我们原链表中不是要删除的数据尾插到新的链表
    head=NULL;
    //当我们的临时结点非空是进入循环
    while(cur)
    {
        //当我们的临时结点所存储的数据就是我们要删除的时候
        if(cur->val==val)
        {
            //创建一个删除结点，等于我们当前要删除的结点。
            struct ListNode*del=cur;
            //将我们的临时结点指向下一个结点
            cur=cur->next;
            //释放我们所要删除的结点
            free(del);
        }
        //如果不是我们要删除的结点
        else
        {
            //尾插
            //如果我们当前的新链表中没有一个结点
            if(tail==NULL)
            {
                //将我们新链表的头，尾都指向临时结点的位置
                head=tail=cur;
            }
            //如果我们当前的新链表中已经存在结点了
            else
            {
                //将我们的临时结点接在尾结点之后，再将我们的尾结点指向最后一个结点
                tail->next=cur;
                tail=tail->next;
            }
            cur=cur->next;
        }
    }
    //当我们的新链表已经生成完毕了之后，我们需要将我们新链表的尾结点的next置空
    if(tail)
        tail->next=NULL;
    return head;
}

三、带哨兵位的头结点

带哨兵位的头结点的题解与之前的解法类似，区别在于带哨兵位的头结点将我们非删除元素尾插在我们的哨兵位的头结点之后，在最后返回的是哨兵位头结点的下一个结点，并将我们的哨兵位结点释放。这就避免了原链表首结点就是要删除的数据的判断。

struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode *cur=head;
    struct ListNode *tail=NULL;
    //哨兵位的头结点
    head = tail=(struct ListNode*)malloc(sizeof(struct ListNode));
    tail->next=NULL;
    while(cur)
    {
        if(cur->val==val)
        {
            struct ListNode*del=cur;
            cur=cur->next;
            free(del);
        }
        else
        {
            //尾插
            if(tail==NULL)
            {
                head=tail=cur;
            }
            else
            {
                tail->next=cur;
                tail=tail->next;
                cur=cur->next;
            }
            
        }
    }
    tail->next=NULL;
    struct ListNode* del=head;
    head=head->next;
    free(del);
    return head;
}

三、链表的中间结点

力扣

给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

一、快慢指针法

创建快慢两个指针，快的那个指针是慢的指针的速度的两倍，当快指针指向链表尾部的时候，我们的慢指针所指向的恰好是我们的中间结点。最后将我们的中间结点返回即可。

struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* slow,*fast;
    slow =fast=head;
    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
    }
    return slow;
}

四、找到链表的导数第k个结点

链表中倒数第k个结点_牛客题霸_牛客网

描述

输入一个链表，输出该链表中倒数第k个结点。

输入：1,{1,2,3,4,5}

复制返回值：{5}

这道题我们同样可以采用上一题中的快慢指针法。

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    // 创建我们的快慢指针
    struct ListNode* slow,*fast;
    slow =fast=pListHead;
    //让我们的快指针提前慢指针k个位置，这样当我们的快指针指向尾结点的时候，我们的慢结点所指向的就是我们的倒数第k给位置。
    for(int i=0;i<k;i++)
    {
        if(fast==NULL)
        {
            return NULL;
        }
        fast=fast->next;
    }
    while(fast)
    {
        slow=slow->next;
        fast=fast->next;
    }
    return slow;
}

五、合并两个有序链表

力扣

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

在下面的代码中，我们创建了一个新的链表，然后将我们链表中相对较小的元素接在我们新的结点之后，并在我们全部连接完成之后在链表表尾置空。

p1指针指示我们list1中的元素，p2指针指示我们list2中的元素，p3指针指示我们新链表中的头结点，p4指针指示我们新链表中的尾结点。

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    if(list1==NULL)
        return list2;
    if(list2==NULL)
        return list1;
    struct ListNode*p1 ,*p2,*p3,*p4;
    p1=list1;
    p2=list2;
    p3=NULL;
    while(p1&&p2)
    {
        if(p1->val>=p2->val)
        {
            if(p3==NULL)
            {
                p3=p2;
                p2=p2->next;
                p4=p3;
            }
            else
            {
                p4->next=p2;
                p2=p2->next;
                p4=p4->next;
            }
        }
        else
        {
            if(p3==NULL)
            {
                p3=p1;
                p1=p1->next;
                p4=p3;
            }
            else
            {
                p4->next=p1;
                p1=p1->next;
                p4=p4->next;
            }
        }
    }
    p4->next=NULL;
    if(p1)
    {
        p4->next=p1;
    }
    if(p2)
    {
        p4->next=p2;
    }
    return p3;
}