leetcode刷题——单链表

简介: 笔记

练习题1移除链表元素


1.png

要考虑的情况

2.png3.png


如果只有一个节点,且这个节点要删除,则返回NULL


struct ListNode* removeElements(struct ListNode* head, int val){
     while(head != NULL && head->val == val){
        head = head->next;
    }
  struct ListNode* fast = head;
    struct ListNode* slow =head;
     struct ListNode* slow1 =head;
     if (head ==NULL)
            return NULL;//如果头节点为空,则直接返回
    while (fast!= NULL)
    {
            while (fast->val!=val)
            {
                slow = fast;
                if (slow->next == NULL)
                    return head;//如果遍历完整个链表,fast为NULL,都没找到val,则直接返回
                fast = fast->next;
            }
            if (fast->val == val)
            {
                slow->next = fast->next;
                fast = fast->next;//跨过要删除的节点
            }
    }
     if (slow1->val==val)//如果只有一个节点,且这个节点要删除,则返回空
            return NULL;
return head;
}
struct ListNode* removeElements(struct ListNode* head, int val){
 struct ListNode* cur=head;
  struct ListNode* prve=NULL;
  while(cur)
  {
      if(cur->val==val)
      {
          if(cur==head)
          {
             head=head->next;
             free(cur);
             cur=head;
          }
          else
          {
             prve->next=cur->next;
             free(cur);
             cur=prve->next;
          }
      }
      else 
      { prve=cur;
              cur=cur->next;
      }
  }
return head;
}

4.png

还可以把 非valu的节点,插到新链表


struct ListNode* removeElements(struct ListNode* head, int val){
 struct ListNode* cur=head;
  struct ListNode* tail=NULL;
  struct ListNode* newhead=NULL;
  while(cur)
  {
      if(cur->val!=val)
      {
          if(tail==NULL)
          {
          tail=newhead=cur;
          }
          else 
          {
          tail->next=cur;
          tail=tail->next;
          }
          cur=cur->next;
      }
      else
      {
          struct ListNode* del=cur;
          cur=cur->next;
          free(del);
      }
  }
  if(tail)
  tail->next=NULL;
return newhead;
}


带哨兵头

5.png

head不存储有效数据


struct ListNode* removeElements(struct ListNode* head, int val){
 struct ListNode* guard=(struct ListNode* )malloc(sizeof(struct ListNode));
 struct ListNode*tail=guard;
 struct ListNode*cur=head;
  while(cur)
  {
      if(cur->val!=val)
      {
          tail->next=cur;
          tail=tail->next;
          cur=cur->next;
      }
      else
      {
          struct ListNode* del=cur;
          cur=cur->next;
          free(del);
      }
  }
  if(tail)
  tail->next=NULL;
return guard->next;
}


带哨兵位的头节点,传参的时候不需要传二级指针


替代之前的二级指针:


1.返回新链表头


2.设计为带哨兵位


单链表:


1.实际运用中很少带头


2.OJ题基本不带头


练习题2合并两个有序链表  


6.png

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    struct ListNode*newhead=(struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode*tail=newhead;
    while(list1!=NULL&&list2!=NULL)
    {
        if(list1->val>list2->val)
        {
            newhead->next=list2;//newhead与第小的数链接
            list2=list2->next;//遍历下一个数
        }
        else
        {
             newhead->next=list1;
            list1=list1->next;
        }
        newhead=newhead->next;//newhead往下走,要存下一个数
    }
    while(list1!=NULL)
    {
         newhead->next=list1;
            list1=list1->next;
                newhead=newhead->next;
    }
    while(list2!=NULL)
    {
         newhead->next=list2;
            list2=list2->next;
                newhead=newhead->next;
    }
    newhead->next=NULL;
    return tail->next;
}


练习题3反转链表



struct ListNode* reverseList(struct ListNode* head){
    struct ListNode*cur=head;
    struct ListNode*next=NULL;
       struct ListNode*newhead=NULL;
    while(cur)
    {  
        next=cur->next;
        cur->next=newhead;
        newhead=cur;
        cur=next;
    }
    return newhead;
}

7.png

方法二:反转链表


struct ListNode* reverseList(struct ListNode* head){
    struct ListNode*cur=head;
    struct ListNode*prve=NULL;
   while(cur)
   {
        struct ListNode*t=cur->next;
        cur->next=prve;
        prve=cur;
        cur=t;
   }
    return prve;
}

8.png

习题4 链表的中间节点


9.png

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

采用快慢指针:快指针一次走俩步,慢指针走一步

10.png

习题5 倒数第K个节点


采用快慢指针法


方法一:fast先走k步,然后slow和fast一块一步一步走,等fast位空,则停止前进,slow所在位置就是倒数第k个


这里k=4,则slow要等于倒数第四个

11.png12.png

fast为空,找到了


方法二:fast先走k-1补,然后slow和fast一起一步一步走,等fast->next=NULL,则找到了

13.png14.png

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
  struct ListNode* fast=pListHead;
    struct ListNode *slow=pListHead;
    if(pListHead==NULL)
        return NULL;
    while(k--)
    {
        if(fast)
        fast=fast->next;
        else
            return NULL;
    }
    while(fast)
    {
        slow=slow->next;
        fast=fast->next;
    }
    return slow;
}
相关文章
|
6天前
|
算法 C++
【刷题】Leetcode 1609.奇偶树
这道题是我目前做过最难的题,虽然没有一遍做出来,但是参考大佬的代码,慢慢啃的感觉的真的很好。刷题继续!!!!!!
9 0
|
6天前
|
算法 索引
【刷题】滑动窗口精通 — Leetcode 30. 串联所有单词的子串 | Leetcode 76. 最小覆盖子串
经过这两道题目的书写,相信大家一定深刻认识到了滑动窗口的使用方法!!! 下面请大家继续刷题吧!!!
13 0
|
6天前
|
算法
【刷题】 leetcode 面试题 08.05.递归乘法
递归算法是一种在计算机科学和数学中广泛应用的解决问题的方法,其基本思想是利用问题的自我相似性,即将一个大问题分解为一个或多个相同或相似的小问题来解决。递归算法的核心在于函数(或过程)能够直接或间接地调用自身来求解问题的不同部分,直到达到基本情况(也称为基础案例或终止条件),这时可以直接得出答案而不必再进行递归调用。
25 4
【刷题】 leetcode 面试题 08.05.递归乘法
|
6天前
|
存储 算法 安全
【刷题】 leetcode 面试题 01.06 字符串压缩
来看效果: 非常好!!!过啦!!!
27 5
【刷题】 leetcode 面试题 01.06 字符串压缩
|
6天前
|
存储 算法 测试技术
|
6天前
|
算法 C语言 C++
|
6天前
|
存储 算法 C语言
C语言刷题~Leetcode与牛客网简单题
C语言刷题~Leetcode与牛客网简单题
|
6天前
刷题之Leetcode160题(超级详细)
刷题之Leetcode160题(超级详细)
15 0
|
6天前
|
Java
刷题之Leetcode19题(超级详细)
刷题之Leetcode19题(超级详细)
15 0