LeetCode.203.移除链表元素

LeetCode.203.移除链表元素

题目描述：

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == 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，这样通过prev->next=(prev->next)->next从而去除这个不要的值，并且存储后一个结点的地址，最后一个结点的地址就是null，同样可以

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
    if(head == null){//判断头指针为空的情况
        return head;
    }
    while(head != null && head.val == val){//首个数就是需要消去的数的情况，
    							//并考虑消去之后，后来的数也是需要消去的情况
        head=head.next;
    }
    ListNode prev = head;
    while(prev!=null&& prev.next != null){
        if(prev.next.val==val){//从第二个开始考虑
            prev.next=prev.next.next;
            //是，则将它后面的结点的地址（即它存储的地址）赋给prev，
        }else{
            prev=prev.next;//不是，prev往后移
        }
        
    }
        return head;
    }
}

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeElements(struct ListNode* head, int val){
    if(head == NULL){//头为空
        return head;
    }
    while(head != NULL && head->val == val   ){
        //首个结点就是要消去 的数,因为他没有前一个结点，所以单独讨论，并考虑后一个结点称为第一个结点之后依旧要消去 的情况
        head=head->next;
    }
    
    struct ListNode* prev=head;
    
    //是从第二个结点开始判断，
    while(prev != NULL && prev->next != NULL){
        if((prev->next)->val == val){
            prev->next=(prev->next)->next;
        }else{
            prev=prev->next;
        }

    }
    return head;

}

方法二：虚拟结点

方法一因为头结点之前没有prev所以需要分开讨论
为了解决这个，可以在头结点之前再弄一个虚拟结点dummyNode 。
虚拟结点的next指向head（即头结点的地址）；

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummyNode = new ListNode();//申请一个结点
        if(head == null){
            return head;
        }
        dummyNode.next=head;//连接
        ListNode prev = dummyNode;
        while(prev != null && prev.next != null){
            if(prev.next.val == val){
                prev.next = prev.next.next;
            }else{
                prev = prev.next;
            }
        }
        return dummyNode.next;//因为头结点是虚拟结点，所以从第二个结点输出
    }
}

方法三：递归

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null){
            return head;
        }
        
        if(head.val ==val){
            head.next  = removeElements(head.next,val);
            return head.next;
        }else{
            head.next  = removeElements(head.next,val);
            return head;
        }


    }
}