链表oj (7.29)

203. 移除链表元素 - 力扣(LeetCode)

思路1:使用结构体指针 cur 遍历链表,遇到值为 val 时删除,删除之前需要判断是头删还是正常的删除,头删需要改变头指针;

正常的删除需要 cur(待删除节点)和 cur 前面一个节点 prev ,让prev 指向 cur 的下一个节点,然后释放掉 cur节点,再让 cur 指针指向现在 prev 指向的下一个节点(原来 cur 指向的下一个节点)。

那么如何找到 prev ?每一次遍历结束先将 cur 赋给 prev,cur 再往后移动一个节点,这样下一次遍历时,prev 就是 cur 的上一个节点。

问题:修改头指针不应该传头指针的地址(二级指针)吗?为什么这里没有?

因为函数结束返回新的头节点,因此本题中可以不传二级指针(通常不推荐)。

实现:

cpp 复制代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeElements(struct ListNode* head, int val)
{
      struct ListNode* prev=NULL;
      struct ListNode* cur=head;
      while(cur)  
   {
      //遇到val,需要删除
      if(cur->val==val)
      {
        //判断是否为头删
        if(cur==head)
        {
        //头指针指向第二个节点
         head=cur->next;
        //释放第一个节点
         free(cur);
        //第二个节点成为头节点
         cur=head;
        }
        //正常删除
        else
        {
        //cur的上一个节点指向指向cur的下一个节点
        prev->next=cur->next;
        //释放掉cur节点
        free(cur);
        //cur指针指向原来cur的下一个节点
        cur=prev->next;
        }
      }
      else
      {
          //记录当前cur为上一个节点prev
          prev=cur;
          //cur向下一个节点移动
          cur=cur->next;
      }
   }
   return head;
}

思路2:

定义一个 cur 指针遍历原链表,把不是 val 的节点,尾插到头节点为 newhead 的新链表,是 val 的节点,就释放掉。

释放的过程为先定义一个 del 节点来记录待删除的节点,然后 cur 往后移,释放 del 节点。

这样的做法势必导致时间复杂度的增加,因为每次尾插都要查找尾节点,如何解决呢?

定义一个尾指针 tail 来记录尾节点,cur 完成遍历后不能忘了将 tail 指向空,还需要考虑到如果原链表为空,那么 newhead 就为空,tail 也为空,因此需要限制 tail 不为空的时候才能将其指向空。

实现:

cpp 复制代码
/**
 * 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* newhead=NULL,*tail=NULL;
       while(cur)
       {
             //删除
             if(cur->val==val)
             {
                    struct ListNode* del=cur;
                    cur=cur->next;
                    free(del);
             }
             else
             {
                    //尾插(头插)
                    if(tail==NULL)
                    {
                        //头节点等于尾节点
                       newhead=tail=cur;
                    }
                    else
                    //正常尾插
                    {
                        //尾节点指向插入的节点
                        tail->next=cur;
                        //尾节点向后移动
                        tail=tail->next;
                    }
                    //遍历节点后移
                    cur=cur->next;
             }
       }
       //遍历完成后,将尾节点指向空
       if(tail)
       {
           tail->next=NULL;
       }
       return newhead;
}

876. 链表的中间结点 - 力扣(LeetCode)

法1:先遍历一遍找出链表的长度,再遍历一遍找出中间节点。

但如果要求只能遍历一遍呢?

法2:这时就可以定义两个指针,一个走得慢,另一个走得快,速度是慢指针的两倍,

在链表有偶数个节点的情况下,快指针走到尾节点(下一个节点为空)的时候,慢指针刚好走到链表中间节点。

在链表为奇数个节点的情况下,当快指针走到尾节点后面一个位置(空)的时候,慢指针恰好处于链表的第二个中间节点。

无论是奇数个还是偶数个节点,直接返回慢节点,就能得到我们需要的结果。

实现:

cpp 复制代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


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

链表中倒数第k个结点_牛客题霸_牛客网 (nowcoder.com)

本题同样采用和上题类似的快慢指针的做法,使用了 相对距离 的原理。

先让快指针向前移动 k 个节点,这样快慢指针之间的距离就为 k 个节点;

我们的目的是找出倒数第 k 个节点,当快指针走到 NULL 的时候,慢指针就刚好走到倒数第 k 个节点的位置上了。

我们还需要考虑到如果链表为空或者 k <=0的情况,直接返回NULL;如果 k 大于链表的长度,也要返回空。

实现:

cpp 复制代码
/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

/**
 * 
 * @param pListHead ListNode类 
 * @param k int整型 
 * @return ListNode类
 */
struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    if(!pListHead||k<=0)
    {
        return NULL;
    }
    struct ListNode* slow=pListHead,*fast=pListHead;
    while(k--)
    {
        if(fast)
        {
        fast=fast->next;
        }
        else {
        return NULL;
        }
    }
    while(fast)
    {
        slow=slow->next;
        fast=fast->next;
    }
    return slow;
}

21. 合并两个有序链表 - 力扣(LeetCode)

创建一个新的空链表,并记录它的头节点和尾节点;

比较两个链表相同位置节点的大小,较小的一方就头插到新链表中,直到有两个链表中的其中一个先走到了空,结束插入,将有剩余的链表链接到新链表。

需要注意如果开始就有一条链表为空,那么直接返回另外一条链表。

实现:

cpp 复制代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    if(list1==NULL)
    {
        return list2;
    }
    if(list2==NULL)
    {
        return list1;
    }
       struct ListNode* phead=NULL,*tail=NULL;
       while(list1&&list2)
       {
       if(list1->val<list2->val)
       {
           if(tail==NULL)
           {
               phead=tail=list1;
           }
           else
           {
               tail->next=list1;
               tail=tail->next;
           }
           list1=list1->next;
       }
       else
       {
           if(tail==NULL)
           {
               phead=tail=list2;
           }
           else
           {
               tail->next=list2;
               tail=tail->next;
           }
           list2=list2->next;
       }
       }
       if(list1==NULL)
       {
           tail->next=list2;
       }
       if(list2==NULL)
       {
           tail->next=list1;
       }
       return phead;
}
相关推荐
散1125 小时前
01数据结构-01背包问题
数据结构
消失的旧时光-19435 小时前
Kotlinx.serialization 使用讲解
android·数据结构·android jetpack
Gu_shiwww6 小时前
数据结构8——双向链表
c语言·数据结构·python·链表·小白初步
苏小瀚7 小时前
[数据结构] 排序
数据结构
_不会dp不改名_9 小时前
leetcode_21 合并两个有序链表
算法·leetcode·链表
睡不醒的kun9 小时前
leetcode算法刷题的第三十四天
数据结构·c++·算法·leetcode·职场和发展·贪心算法·动态规划
吃着火锅x唱着歌9 小时前
LeetCode 978.最长湍流子数组
数据结构·算法·leetcode
Whisper_long10 小时前
【数据结构】深入理解堆:概念、应用与实现
数据结构
IAtlantiscsdn10 小时前
Redis7底层数据结构解析
前端·数据结构·bootstrap
我星期八休息10 小时前
深入理解跳表(Skip List):原理、实现与应用
开发语言·数据结构·人工智能·python·算法·list