Leetcode 203. 移除链表元素

https://leetcode-cn.com/leetbook/read/linked-list/f9izv/

这个题目是一道简单题， 但是我觉得还是蛮好的，因为题解采用的方法是引入哨兵节点。哨兵节点和哑节点其实是一回事，哨兵节点（sentinel）是一个哑元节点（dummy node），可以简化边界条件。是一个附加的链表节点，该节点作为第一个节点，它的值域中并不存储任何东西，只是为了操作的方便而引入的。如果一个链表有哨兵节点的话，那么线性表的第一个元素应该是链表的第二个节点。 
很多情况下，需要处理当前节点的前驱节点，如果是没有哨兵节点的链表，对第一个节点，即头节点，没有前驱节点。如果不作特殊处理，就可能出错；如果对它特别对待，就会增加代码复杂性，还会降低程序效率。而如果有哨兵节点的话， 线性表的每个位置的节点都有前驱节点，因此可以统一处理。 
当链表为空时，没有哨兵节点的链表的头节点为NULL，处理起来也和其他情况不同。带哨兵节点的链表，当其为一个空链表时，仅含哨兵节点，哨兵节点的指针域为空，和其他情况的表尾是一样的。

所以不要误以为哨兵节点和哑节点不一样，这种采用哑节点解题的方法在链表中很常见。

带哨兵节点的链表，需要额外的一个节点，但插入和删除等操作不需要额外的判断；不带哨兵节点，在处理链表为空时，和其他情况不一样，需要单独判断一次。 
带哨兵节点的链表，插入或删除时，不论操作的位置，表头都不变，不需要额外的判断；不带哨兵节点的链表，插入或删除操作发生在第一个节点时，表头指针都要变化，需要额外的处理。

https://www.cnblogs.com/Ph-one/p/7069814.html大佬的这篇文章解释的很清楚。

对于这道题目，我们需要考虑下面几种情况。

• 首先空结点的情况，直接返回NULL
• 删除的是中间结点，将待删除节点的前一个节点prev的next指向待删除节点的next.
• 当要删除的一个或者多个节点位于头部时，引入哨兵节点，伪头，伪尾，伪标记，其主要目的是使链表标准化，如使链表永不为空、永不无头、简化插入和删除。

• /**
   * 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) {
          ListNode* sentinel=new ListNode(0);//哨兵节点
          sentinel->next=head;
          ListNode* prev=sentinel;//指向前驱节点
          ListNode* cur=head;//指向当前节点
          ListNode* temp=nullptr;
          while(cur!=nullptr)
          {
              if(cur->val==val)
              {
                  prev->next=cur->next;
                  temp=cur;
              }
              else
              {
                 prev=cur;
              }
              cur=cur->next;//遍历下一个元素
              if(temp!=nullptr)
              {
                  delete temp;//防止内存泄漏
                  temp=nullptr;//释放空间
              }
          }
          ListNode* ans=sentinel->next;
          delete sentinel;
          return ans;
      }
  };

  

• 上面这也是官方题解给的答案，我个人觉得节点太多了，有点头晕，下面我自己的做法

  /**
   * 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) {
          ListNode* sentinel=new ListNode(0);//哨兵节点
          sentinel->next=head;
          ListNode* prev=sentinel;//指向前驱节点
          ListNode* cur=head;//指向当前节点
          while(cur!=nullptr)
          {
              if(cur->val==val)
              {
                  prev->next=cur->next;
              }
              else
              {
                 prev=cur;
              }
              cur=cur->next;//遍历下一个元素
          }
          return sentinel->next;
      }
  };

  

这是没有用temp和ans的提交状况，有差别，执行用时比上一个要慢点，但是我觉得不论是代码可读性还是理解程度我个人更倾向于这个。 

• 另外没考虑到哑节点也是可以的，只是看起来有点复杂

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head==NULL) return NULL;
        while(head!=NULL&&head->val == val){
            ListNode* deletenode = head;
            head = head->next;
            delete deletenode;
        }
        ListNode* temp = head;
        while(temp!=NULL&&temp->next!=NULL){
            while(temp->next!=NULL&&temp->next->val == val){
                ListNode* deletenode = temp->next;
                temp->next = temp->next->next;
                delete deletenode;
            }
            if(temp->next!=NULL) temp = temp->next;
        }
        return head;
    }
};

• 递归解法也是可以的，不过我想不到，但是代码简单很多。

  class Solution {
  public:
      //题解1：递归法
      ListNode* removeElements_1(ListNode* head, int val) {
          //1、递归边界
          if(!head)return nullptr;
          //2、递去：直到到达链表尾部才开始删除重复元素
          head->next=removeElements(head->next,val);
          //3、递归式：相等就是删除head，不相等就不用删除
          return head->val==val?head->next:head;
      }
  };