一. 链表 1 删除等于给定值的节点

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

有几种情况需要考虑：

1. 最后一个node是None
2. 有多个连续的node与被删除值相同
3. 表头的node的值=被删除
4. 整个表为None

Python3

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    # @param head, a ListNode
    # @param val, an integer
    # @return a ListNode
    def removeElements(self, head, val):
        # 寻找返回值----head
        # 如果链表为空
        if head == None:
            return head
        #如果第一个node的值是我们要删除的值
        while head.val == val:
            head = head.next  # 删除这个node， 即跳向下一个node
            # 如果新的node为空，跳出循环
            if head == None:
                break
        # 定义返回值---head
        return_head = head
        # 如果这个返回值是None，返回None
        if return_head == None:
            return None
        # 当head的下一个节点不为空
        while head.next != None :
            # 当head的下一个节点的值为要删除的值
            while head.next.val == val:
                # 将head的指针指向下一个node的指针，即删除下一个节点
                head.next = head.next.next
                # 如果head的指针为空，即已经到达链表尾部
                if head.next == None:
                    return return_head
            #指向下一个节点     
            head = head.next
        return return_head

既然是删除，那么就要考虑到垃圾回收的机制：
就python而言 1. 引用计数机制 2. 标记-清除和分代收集
详情见Python垃圾回收机制--完美讲解!

Java

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    /**
     * @param head a ListNode
     * @param val an integer
     * @return a ListNode
     */
    public ListNode removeElements(ListNode head, int val) {
        // Write your code here
        ListNode return_head = head;
        //当head为空时
        if( head == null)  
        {
            return return_head;
        }
        
        //当头指针的值等于被删除的值
        while (head.val == val)
        {
            if (head.next != null )
            {
                // 删除这个node，即将这个node的指针指向下一个node的next。
                head = head.next;
                // 记录头指针，作为最后的返回参数。
                return_head = head;
            }
            else{
                // 如果下一个的node为none，那么返回none。
                return null;
            }
        }
        // 当该node的下一个node不为null
        while(head.next != null) 
        {
            // 当下一个node的值=被删除的值
            while (head.next.val == val)
            {
                // 删除这个node，即将这个node的指针指向下一个node的next
                head.next = head.next.next;
                // 如果这个node的下一个为null，返回头指针
                if (head.next == null)
                {
                    return return_head;
                }
            }
            head = head.next;
        }
        return return_head;
    }
}

就java而言，Java语言规范没有明确地说明JVM使用哪种垃圾回收算法，但是任何一种垃圾回收算法一般要做2件基本的事情：
（1）发现无用信息对象；
（2）回收被无用对象占用的内存空间，使该空间可被程序再次使用。
More info：Java垃圾回收机制