LeetCode203：移除链表元素（链表）

移除链表元素

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

不增加虚拟头结点时：

/**
     * 移除链表元素
     * @param head
     * @param val
     * @return
     */
    public ListNode removeElements(ListNode head, int val) {
        //判断链表第一个元素的val是否等于val，等于进行移除，
        // 可能移除后的链表的第一个元素的val还等于val，需要通过while进行判断移除
        //在访问head时需要确保head不为空
        while(head != null && head.val == val){
            ListNode delNode = head;
            head = delNode.next;
            //内存释放
            delNode.next = null;
        }
        //删除完第一个元素的val值等于val的情况后，需要确保此时head不为空
        if(head  == null){
            return null;
        }
        //删除不是第一个元素的val值等于val的情况
        ListNode curNode = head;
        while (curNode.next !=null) {
            if(curNode.next.val == val){
                //删除curNode.next
                ListNode delNode = curNode.next;
                curNode.next = delNode.next;
                //释放
                delNode.next =null;
            }else {
                curNode = curNode.next;
            }
        }
        return head;
    }

增加虚拟头结点：dummyHead

• 增加虚拟头结点,使头节点的删除和其他节点统一

       /**
     * 移除链表元素：增加一个虚拟头节点
     * 找到要删除节点的前一个节点，然后将要删除的节点跨过去
     * @param head
     * @param val
     * @return
     */
    public ListNode removeElements2(ListNode head, int val) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode curNode = dummyHead;
        while (curNode.next !=null) {
            if(curNode.next.val == val){
                //删除curNode.next
                ListNode delNode = curNode.next;
                curNode.next = delNode.next;
                //释放
                delNode.next =null;
            }else {
                curNode = curNode.next;
            }
        }
        ListNode retNode = dummyHead.next;
        dummyHead.next = null;
        return retNode;
    }

递归：

• 链表具有天然的递归结构

/**
     * 链表天然的递归性
     *  * 递归：本质上，将原来的问题，转化为更小的同一问题，例如：数组求和
 * 注意递归函数的“宏观”语意，递归函数就是一个函数，完成一个功能
 *
 * 递归函数的调用，本质就是函数的调用，只不过调用的函数是自己而已
 *
 * 递归调用是有代价的：函数调用+系统栈空间
 *
 * 近乎和链表相关的所有操作，都可以使用递归的形式完成
 * 对链表的增删改查都可通过递归实现
 *
 * 此外：双链表 class Node{E e; Node next,prev;}
 *      循环链表 class Node{E e; Node next,prev;}
 *      数组链表 class Node{E e, int next;}
 *
 * 链表具有天然的递归性
     * @param head
     * @param val
     * @return
     */
    public ListNode removeElements3(ListNode head, int val){

        if(head == null){
            //判断是否为空链表，递归中要求解的最基本的问题
            return null;
        }

        head.next = removeElements3(head.next,val);
        return head.val == val? head.next : head;
    }

数组求和：

   public static int sum(int[] arr){
        return sum(arr,0);
    }

    /**
     * 计算arr[l,....,n)这个区间内所有数字的和
     * @param arr
     * @param l
     * @return
     */
    private static int sum(int[] arr , int l){

        if(l == arr.length){
            //求解最基本的问题
            return 0;
        }

        //把原问题转化成更小的问题
        return arr[l]+sum(arr,l+1);
    }