【算法Day3】链表：203.移除链表元素 707.设计链表 206.反转链表

链表理论基础:

单链表、双链表、循环链表、添加结点、删除结点

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
输出： [ ]

第一想法：链表和数组是不同的，在查找元素方面：数组可以直接用索引找到目标元素，而链表需要通过遍历才能找到目标元素；插入元素和删除元素方面：数组需要移动很多元素，而链表可以通过修改指针插入和删除元素。本题要求移除链表元素，故需要遍历链表找到目标元素并修改其前一个元素的指针以删除该元素，也需要保存新的头节点以便返回。
本题关键：理解并熟练使用虚拟头节点！
Java代码：

/** 结点定义
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 dummyhead = new ListNode(-1);
        dummyhead.next = head;//指向头节点
        ListNode prev = dummyhead;
        while(prev.next != null) {
            if(prev.next.val == val) {//找到待删除元素prev.next
                prev.next = prev.next.next;//让待删除元素的前一个元素指向待删除元素的下一个元素
            }
            else {//找不到 继续遍历
                prev = prev.next;
            }
        }
        return dummyhead.next;//返回头节点
    }
}

707.设计链表

题目链接：707.设计链表

题目：
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
在链表类中实现这些功能：
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

思路：根据题目要求设计链表，把链表的基本都覆盖到了，下面使用的是单链表实现：

Java代码：

class ListNode {
    int val;
    ListNode next;
    public ListNode() {}
    public ListNode(int val) {
        this.val = val;
        this.next = null;
    }
}
public class MyLinkedList {

    private int size;
    private ListNode dummyHead;//虚拟头节点，指向链表的第一个元素，以使得对链表第一个元素的操作与对其他元素操作时一样的

    public MyLinkedList() {
        dummyHead = new ListNode(0);
        size = 0;
    }

    public int get(int index) {
        if(index < 0 || index >= size) {
            return -1;
        }
        ListNode cur = dummyHead.next;
        for(int i = 0; i < index; i++) {
            cur = cur.next;
        }
        return cur.val;
    }

    public void addAtHead(int val) {
        addAtIndex(0,val);
       
    }

    public void addAtTail(int val) {
        ListNode cur = dummyHead;
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = new ListNode(val);
        size++;
        return;
    }

    public void addAtIndex(int index, int val) {
        if(index > size) {
           return;
        }
        else if(index == size) {
            addAtTail(val);
            return;
        }
        else if(index < 0) {
            addAtIndex(0,val);
            return;
        }

        ListNode cur = dummyHead;
        for(int i = 0; i < index; i++) {
            cur = cur.next;
        }
        ListNode newNode = new ListNode(val);
        newNode.next = cur.next;
        cur.next = newNode;
        size++;
        return;
    }

    public void deleteAtIndex(int index) {
        if(index >= size || index < 0) {
            return;
        }
        ListNode prev = dummyHead;
        for(int i = 0; i < index; i++) {
            prev = prev.next;
        }
        ListNode delNode = prev.next;
        prev.next = delNode.next;
        delNode.next = null;
        size--;
        return;
    }
}

206.反转链表

leetcode链接：206.反转链表

题目：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例1：

输入： head = [1,2,3,4,5]
输出： [5,4,3,2,1]

示例 2：

输入： head = [ ]
输出： [ ]

第一思路：反转链表，让每一个元素都指向它的前一个元素，原来的头节点指向null。可以用递归实现，定义一个递归函数reverseList(ListNode head),返回以head为头节点的链表反转之后的新链表的头节点，head是原链表的头结点，head.next是第二个节点，那么可以认为reverse(head.next)就是反转以head.next为头节点的链表，并且返回新的头节点。

原链表：

reverse(head.next)之后：

让2指向1，让1指向null：

Java代码：

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode rev = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return rev;
    }
}