題意：刪除連結串列中等於給定值 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
輸出：[]

思路：

方法一：遞迴

方法二：迭代
刪除連結串列中給定值的節點，一般的步驟是：

遍歷連結串列找到所有值為 val 的節點；

將值為 val 的節點的上一個節點直接指向該節點的下一個節點（pre->next = pre->next->next）。

方法三：雙指標
解題步驟：

設定兩個均指向頭節點的指標，pre（記錄待刪除節點的前一節點）和 cur (記錄當前節點)；

遍歷整個連結串列，查詢節點值為 val 的節點，找到即刪除該節點，否則繼續查詢。

2.1 找到，將當前節點的前一節點（之前最近一個值不等於 val 的節點(pre)）連線到當前節點（cur）的下一個節點（即將 pre 的下一節點指向 cur 的下一節點：pre->next = cur->next）。

2.2 沒找到，更新最近一個值不等於 val 的節點（即 pre = cur），並繼續遍歷（cur = cur->next）。

方法四：虛擬頭節點（哨兵）
前三種方法均需要判斷頭節點是否為待刪除的節點，且處理頭節點的程式碼邏輯與其它節點特別相似，有沒有方法使得程式碼更優美並且能避免對頭節點的判斷呢？

答案是有的。可以通過在頭節點前增加虛擬頭節點，這樣頭節點就成了普通節點，不需要單獨拎出來考慮，但是在返回的時候，返回的是虛擬頭節點的下一節點而不是虛擬頭節點。

方法五：棧

本題還可以採用棧去做。

1. 將值不等於 val 的節點依次壓入棧中；

2. 將壓入棧的節點重新連線，棧底的節點作為新的頭節點返回

  1 #include<vector>
  2 #include<iostream>
  3 #include<algorithm>
  4 #include<numeric>
  5 #include<iterator>
  6
 
 #include<stack>
  7 using namespace std;
  8 
  9  struct ListNode {
 10      int val;
 11      ListNode *next; 
 12      ListNode() : val(0), next(nullptr) {}
 13      ListNode(int x) : val(x), next(nullptr) {}
 14      ListNode(int x, ListNode *next) : val(x), next(next) {}
 15  };
 16 
 17 class Solution {
 18 public:
 19     ListNode* removeElements_doublezhizhen(ListNode* head, int val) 
 20     {
 21         while(head!=nullptr && head->val==val)
 22         {
 23             head = head->next;
 24         }
 25         if (head == nullptr) return head;
 26         ListNode* pre = head;
 27         ListNode* cur = head;
 28         while(cur != nullptr)
 29         {
 30             cur = cur->next;
 31             if(cur->val == val)
 32             {
 33                 pre->next = cur->next;
 34                 cur = pre->next;
 35             }
 36             else
 37             {
 38                 pre = pre->next;
 39             }
 40         }
 41         return head;
 42     }
 43     ListNode* removeElements_digui(ListNode* head, int val)
 44     {
 45         if(head == nullptr)
 46         {
 47             return head;
 48         }
 49         head->next = removeElements_digui(head->next,val);
 50         return head->val == val? head->next:head;
 51     }
 52     ListNode* removeElements_diedai(ListNode* head, int val)
 53     {
 54         while(head!=nullptr&&head->val==val)
 55         {
 56             head = head->next;
 57         }
 58         if(head==nullptr)
 59         {
 60             return head;
 61         }
 62         ListNode*pre = head;
 63         while(pre->next!=nullptr)
 64         {
 65             if(pre->next->val==val)
 66             {
 67                 pre->next = pre->next->next;
 68             }
 69             else
 70             {
 71                 pre = pre->next;
 72             }
 73         }
 74         return head;
 75     }
 76     ListNode* removeElements_dummyhead(ListNode* head, int val)
 77     {
 78         ListNode* dummy_head = new ListNode(0,head);
 79         ListNode* cur = dummy_head;
 80         while(cur->next)
 81         {
 82             if(cur->next->val==val)
 83             {
 84                 ListNode* delete_node = cur->next;
 85                 cur->next = delete_node->next;
 86                 delete delete_node;
 87             }
 88             else
 89             {
 90                 cur = cur->next;
 91             }
 92         }  
 93         ListNode* res = dummy_head->next;
 94         delete dummy_head;
 95         return res;
 96     }
 97     ListNode* removeElements_stack(ListNode* head, int val)
 98     {
 99         stack<ListNode*>* sta = new stack<ListNode*>();
100         while(head!=nullptr)
101         {
102             if(head->val!=val)
103             {
104                 (*sta).push(head);
105             }
106             head = head->next;
107         }
108         while(!(*sta).empty())
109         {
110             ((*sta).top())->next = head;
111             head = (*sta).top();
112             (*sta).pop();
113         }
114         return head;
115     }
116 };
117 
118 int main() {
119     ListNode* head = new ListNode();
120     ListNode* r = nullptr;
121     vector<int> num = { 1,2,7,7,7,7 };
122     for (int i =num.size()-1;i>=0;i--)
123     {
124         ListNode* a = new ListNode(num[i],r);
125         head->next = a;
126         r = a;
127     }
128     for (auto p = head->next; p != nullptr; p = p->next) 
129     {
130         cout << p->val;
131     }
132     cout << endl;
133     ListNode* res = new ListNode();
134     Solution a;
135     res = a.removeElements_stack(head,7);
136     for (auto p = head->next; p != nullptr; p = p->next) 
137     {
138         cout << head->next->val;
139         head = head->next;
140     }
141     cout << endl;
142     system("pause");
143 }