链表定义：

public class ListNode {
    // 结点的值
    int val;

    // 下一个结点
    ListNode next;

    // 节点的构造函数(无参)
    public ListNode() {
    }

    // 节点的构造函数(有一个参数)
    public ListNode(int val) {
        this.val = val;
    }

    // 节点的构造函数(有两个参数)
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

1:移除链表元素

leetcode.cn/problems/re…
当要移除链表元素的时候，有两种方法： 1：单独处理 2：定义虚节点统一处理
还需要注意的是，处理链表题目，需要注意结点为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) {
        //单独处理头结点的情况
            while (head != null && head.val == val){
                head = head.next;
            }
            ListNode cur = head;
            while (cur != null){
                if(cur.next != null && cur.next.val == val){
                    cur.next = cur.next.next;
                }
                else {
                    cur = cur.next;
                }
            }
            return head;

    }
}

static class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //不单独处理头结点，定虚结点

        ListNode dummy = new ListNode(-1,head);
        ListNode cur = dummy;
        while(cur.next != null){
            if(cur.next.val == val){
                cur.next = cur.next.next;
            }
            else {
                cur = cur.next;
            }
        }
        return dummy.next;
    }
}

方法二：递归

TODO

2:设计链表元素

leetcode.cn/problems/de…
你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

• MyLinkedList() 初始化 MyLinkedList 对象。
• int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
• void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
• void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
• void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
• void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

 

示例：

输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

代码

class MyLinkedList {

    ListNode dummy;
        int size;

        public MyLinkedList() {
            dummy = new ListNode(-1);
            size = 0;
        }

        //获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
        public int get(int index) {
            if(index < 0 || index >= size){
                return -1;
            }
            ListNode cur = dummy.next;
            for(int i = 0; i < index; i++){
                cur = cur.next;
            }
            return cur.val;
        }

        //将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
        public void addAtHead(int val) {
            addAtIndex(0,val);
        }

        //将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
        public void addAtTail(int val) {
            addAtIndex(size,val);
        }

        //将一个值为 val 的节点插入到链表中下标为 index 的节点之前。
        // 如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。
        // 如果 index 比长度更大，该节点将 不会插入 到链表中。
        public void addAtIndex(int index, int val) {
            if(index > size){
                return;
            }
            ListNode cur = dummy;
            for(int i = 0; i < index; i++){
                cur = cur.next;
            }
            ListNode listNode = new ListNode(val);
            listNode.next = cur.next;
            cur.next = listNode;
            size++;
        }

        //如果下标有效，则删除链表中下标为 index 的节点。
        public void deleteAtIndex(int index) {
            if(index >= size || index < 0){
                return;
            }
            ListNode cur = dummy;
            for(int i = 0; i < index; i++){
                cur = cur.next;
            }
            cur.next = cur.next.next;
            size--;
        }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

3：反转链表

leetcode.cn/problems/re… \

方法一：双指针法

定义两个指针，第一个指向null，第二个指向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 reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null){
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}

方法二：递归

这里根据上面的代码修改成递归即可
1:递归出口：即cur == null
2:子问题：pre = cur; cur = temp; 不难写出：

public ListNode reverse(ListNode pre, ListNode cur){
    if(cur == null){
        return pre;
    }

    ListNode temp = cur.next;
    cur.next = pre;
    return reverse(cur, temp);
}
public ListNode reverseList(ListNode head) {
    ListNode pre = null;
    ListNode cur = head;
    return reverse(pre, cur);
}