DAY3打卡移除链表元素设计链表反转链表

最新推荐文章于 2024-09-23 22:27:40 发布

MOMO_114514

最新推荐文章于 2024-09-23 22:27:40 发布

阅读量426

点赞数 8

文章标签：链表数据结构

本文链接：https://blog.csdn.net/MOMO_114514/article/details/135873318

版权

文章讨论了如何在链表中删除等于给定值的节点，提供了多种实现方法，包括直接处理首节点和中间节点、使用虚拟头节点简化代码以及反转链表的基本算法。作者强调了使用虚拟头节点在链表操作中的优势和递归实现的反转方法。

摘要由CSDN通过智能技术生成

移除链表元素：

题意：删除链表中等于给定值 val 的所有节点。

示例 1：输入：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 输出：[]

对应力扣203题

这个直接写的话需要分为两种情况，一个是首节点，一个是中间节点的情况

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
          auto flag=head;
          while(flag!=NULL)
          {   if(flag->val==val)
              {
                 head=head->next;
                 flag=head;
                 continue;
              }
              if(flag->next!=NULL&&flag->next->val==val)
              {
                  flag->next=flag->next->next;
                 // flag=flag->next;
                  continue;
              }  
             if(flag->val!=val&&flag->next==NULL)
             return head;
             flag=flag->next;
          }
          return head;
    }
};

自己写的，我的评价是史↑。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
          while(head!=NULL&&head->val==val)
         {  ListNode* tmp = head;
             head=head->next;
             delete tmp;
         }
            auto flag=head;
           while(flag!=NULL&&flag->next!=NULL)
           {    if(flag->next->val==val)
                {
                    ListNode* tmp1 = flag->next;
                    flag->next=flag->next->next;
                    delete tmp1;
                }
                else
                {
                    flag=flag->next;
                }
           }  
          return head;
    }
};

这个↑的话加上释放内存了，稍微好看了一点，更有条理一点。

加上虚拟头结点的话，就不需要区分两种情况了，代码更加简洁。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
         ListNode* vhead=new ListNode();//虚拟头节点
         vhead->next=head;
         auto flag=vhead;
         while(flag!=NULL&&flag->next!=NULL)
        {     if(flag->next->val==val)
              {     ListNode* tmp=flag->next;
                    flag->next=flag->next->next;
                    delete tmp;
              }
              else
              flag=flag->next;
        }
          head=vhead->next;
          return head;
    }
};

设计链表

题意：

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

对应力扣707题

究极折磨人，每一个模块都不是很难，但是组合起来非常麻烦，非常不好debug,建议认真写一次写对，使用虚拟头结点会省事很多，还好有万能的chatgpt。

class MyLinkedList {
public:
   
     struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };
   
    // 初始化链表
    MyLinkedList() {
        vhead = new LinkedNode(0); 
        _size = 0;
    }
    
    int get(int index) {
       if(index<0||index>_size-1)
       return -1;
       LinkedNode* flag=vhead->next;
       for(int i=0;i<index;i++)
       {
           flag=flag->next;
       }
       return flag->val;
    }
    
    void addAtHead(int val) {
        if(vhead->next==NULL)
         {LinkedNode* flag=new LinkedNode(val);
           vhead->next=flag;
           _size++;
         }
        else
        {
          LinkedNode* flag=vhead->next;  
          LinkedNode* newhead=new LinkedNode(val); 
          newhead->next=flag;
          vhead->next=newhead;
          _size++;
        }
          
    }
    
    void addAtTail(int val) {
       if(vhead->next==NULL)
         {LinkedNode* flag=new LinkedNode(val);
           vhead->next=flag;
           _size++;
         }
        else
        {
           LinkedNode* flag=vhead->next; 
           while(flag->next!=NULL)
           {flag=flag->next;}  
            LinkedNode* newtail=new LinkedNode(val); 
            flag->next=newtail;
            _size++;
        }
    }
    
    void addAtIndex(int index, int val) {
      if(index<0||index>_size)
      return;
      if(index==_size)
      {LinkedNode* flag1=vhead->next;
       LinkedNode* flag2=new LinkedNode(val);
       if(flag1==NULL)
       {vhead->next=flag2;
       _size++;}
       else
      { while(flag1->next!=NULL)
        flag1=flag1->next;
        flag1->next=flag2;
        _size++;
      }
      }
      else
      { LinkedNode* flag=vhead; 
          for(int i=0;i<index;i++)
      {    flag=flag->next;      }
        LinkedNode* flag3=new LinkedNode(val);
        LinkedNode* flag4=flag->next;
        flag->next=flag3;
        flag3->next=flag4;
        _size++;
      }
    }
    
void deleteAtIndex(int index) {
     if(index<0||index>_size-1)
       return;
     LinkedNode* flag=vhead;
    for(int i=0;i<index;i++)
    {
        flag=flag->next;
    }
     LinkedNode* temp = flag->next;
    flag->next = temp->next;
    delete temp;
    _size--;
    }

   private:
    int _size;
    LinkedNode*  vhead;
};

我发现我写的这一段，虽然是通过了，但是根本没有用上虚拟头结点的概念，搞得就很复杂。

最后合理运用了虚拟头结点，果然简化很多。

class MyLinkedList {
public:
   
     struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };
   
    // 初始化链表
    MyLinkedList() {
        vhead = new LinkedNode(0); 
        _size = 0;
    }
    
    int get(int index) {
       if(index<0||index>_size-1)
       return -1;
       LinkedNode* flag=vhead->next;
       for(int i=0;i<index;i++)
       {
           flag=flag->next;
       }
       return flag->val;
    }
    
    void addAtHead(int val) {
       LinkedNode* newnode=new LinkedNode(val);
       newnode->next=vhead->next;
       vhead->next=newnode;
       _size++;    
    }
    
    void addAtTail(int val) {
        LinkedNode* newnode=new LinkedNode(val);
        auto flag=vhead;
        while(flag->next!=NULL)
        flag=flag->next;
        flag->next=newnode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
      if(index<0||index>_size)
      return;
      if(index<0)index=0;
      LinkedNode* newnode=new LinkedNode(val);
      LinkedNode* flag=vhead;
      for(int i=0;i<index;i++)
      {   flag=flag->next;
      }
       LinkedNode* temp=flag->next;
       flag->next=newnode;
       newnode->next=temp;
       _size++;
    }
    
void deleteAtIndex(int index) {
     if(index<0||index>_size-1)
       return;
     LinkedNode* flag=vhead;
    for(int i=0;i<index;i++)
    {
        flag=flag->next;
    }
     LinkedNode* temp = flag->next;
    flag->next = temp->next;
    delete temp;
    _size--;
    }

   private:
    int _size;
    LinkedNode*  vhead;
};

反转链表：

题意：反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

对应力扣206题

最简单的一集，总算是有个我能直接写的了，标准做法是双指针＋一个临时指针

不过我一开始的做法是flag1和flag2分别指向1和2，还是稍微复杂了一点，需要多考虑几种情况

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
         if(head==NULL||head->next==NULL)return head;
         ListNode* flag1=head;
         ListNode* flag2=head->next;
         flag1->next=NULL;
         while(flag2->next!=NULL)
         {        
           ListNode* temp=flag2->next;
           flag2->next=flag1;
           flag1=flag2;
           flag2=temp;
         }
       flag2->next=flag1;
       head=flag2;
       return head;
        
    }
};

后面采用图片里使用的方法，代码瞬间简单很多

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
         ListNode* flag1=NULL;
         ListNode* flag2=head;
         while(flag2)
         {        
           ListNode* temp=flag2->next;
           flag2->next=flag1;
           flag1=flag2;
           flag2=temp;
         }
       head=flag1;
       return head;
        
    }
};

最后有个递归，是根据这个双指针改编的，建议先弄懂双指针

class Solution {
public:
   ListNode* reverse(ListNode* cur,ListNode* pre)
         {    if(cur==NULL) return pre;
              ListNode* temp=cur->next;
              cur->next=pre;
              //reverse(temp,cur);
              return reverse(temp,cur);
         }

    ListNode* reverseList(ListNode* head) {
         
         return reverse(head,NULL);
        
    }
};

结束！