代码随想录第三天：链表1：● 链表理论基础 ● 203.移除链表元素 ● 707.设计链表 ● 206.反转链表

203.移除链表元素

https://leetcode.cn/problems/remove-linked-list-elements/
https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html

题意：删除链表中等于给定值 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 输出：[]

思路

虚拟头结点来进行删除。
如果不使用虚拟头结点，那么头结点的删除方式就是把头结点向后面移一位。

代码

class Solution {
    public ListNode removeElements(ListNode head, int val) {
    	//判断别忘
    	if(head == null){
    		return head;
    	}
        ListNode dumyhead  = new ListNode(-1);
        dumyhead.next = head;

        ListNode pre = dumyhead;
        ListNode cur = head;

        while(cur != null){
            if(cur.val == val){
                pre.next = cur.next;
            }else{
                pre = cur;
            }
            cur = cur.next;
        }
        return dumyhead.next;
    }
}

707.设计链表

比较难，不太会

题意：
在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

思路

通过虚拟节点来解决：因为包含一些删除、添加操作。
同时需要考虑实现的一些细节。

代码

单链表解法

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

    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
    }
    
    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        ListNode cur = head;
        for(int i = 0; i < index + 1; i++){
            cur = cur.next;
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        if(index > size){
            return;
        }
        if(index < 0){
            index = 0;
        }
        size ++;
        ListNode cur = head;
        for(int i = 0; i < index; i++){
            cur = cur.next;
        }
        ListNode newNode = new ListNode(val);
        newNode.next = cur.next;
        cur.next = newNode; 
    }
    
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        size--;
        ListNode cur = head;
        for(int i =0; i < index; i++){
            cur = cur.next;
        }
        cur.next = cur.next.next;
    }
}

双链表解法

注意双链表的初始化，非常重要！

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

class MyLinkedList {
    int size;
    ListNode head,tail;

    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
        tail = new ListNode(0);
        // 初始化双链表的必要过程
        head.next = tail;
        tail.pre = head;
    }
    
    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        ListNode cur = head;
        if(index > size / 2){
            cur = tail;
            for(int i = 0; i < size - index; i++){
                cur = cur.pre;
            }
        }else{
            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) {
        addAtIndex(size, val);
    }
    
    public void addAtIndex(int index, int val) {
        if(index > size){
            return;
        }
        if(index < 0){
            index = 0;
        }
        size++;
        ListNode cur = head;
        for(int i = 0; i < index; i++){
            cur = cur.next;
        }
        ListNode newAdd = new ListNode(val);
        newAdd.next = cur.next;
        newAdd.next.pre = newAdd;
        newAdd.pre = cur;
        cur.next = newAdd;
    }
    
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        size--;
        ListNode cur = head;
        for(int i = 0; i < index; i++){
            cur = cur.next;
        }
        cur.next.next.pre = cur;
        cur.next = cur.next.next;

    }
}

/**
 * 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);
 */

206.反转链表

题意：反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

思路

双指针法和递归法

代码

双指针法

class Solution {
    public ListNode reverseList(ListNode head) {
        // 双指针法
        // pre == null 就已经可以解决第一个节点的问题了。
        // 不需要单独考虑
        ListNode pre = null;
        ListNode cur = head;
        ListNode temp = null;
        while(cur != null){
            temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
            
        }
        return pre;
    }
}

递归法

class Solution {
    public ListNode reverseList(ListNode head) {
        return reverse(null,head);
    }
    public ListNode reverse(ListNode pre, ListNode cur){
        if(cur == null){
            return pre;
        }
        ListNode temp = null;
        temp = cur.next;
        cur.next = pre;
        return  reverse(cur,temp); //要注意这里已经进行 了更新，不需要单独更新cur和temp
    }
}