代码随想录算法训练营第三天 | LeetCode203.移除链表元素 、707.设计链表、206.反转链表

一、链表理论基础

文档讲解：

视频讲解：

LeetCode题目：

思路：

• 可以不构造函数，会默认生成一个构造函数，但是这个构造函数不会初始化任何成员变量。

• 删除链表中的节点，Java不需要手动释放该节点，有自己的内存回收机制

• 增加节点，删除节点时间复杂度都是O(1)，也不会影响其他节点，但是查找是O(n)。

• 数组定义的时候长度是固定的，如果要改动长度就要重新定义一个新数组。

• 链表长度不固定，适合数据量不固定，查少，增删多的场景

代码：

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;
    }
}

二、203.移除链表元素

文档讲解：https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html

视频讲解：https://www.bilibili.com/video/BV18B4y1s7R9?vd_source=9239d2aed03432357fb58e82f8d152ff

LeetCode题目：https://leetcode.cn/problems/remove-linked-list-elements/description/

思路：

2种写法：普通、加虚拟节点

因为需要考虑删的节点是不是头结点，所以有两种思路

• 普通：先判断是不是头结点，不是的话就直接将前一节点的指针指向下一节点，是的话head往后移一位。
• 虚拟节点：在链表前加一节点，以统一规则

代码：

方法一：不添加虚拟节点方式

public ListNode removeElements(ListNode head, int val){
    //head不为空且第一个节点就符合
    while (head != null && head.val == val){
        head = head.next;
    }
    
    //head为空
    if(head == null){
        return head;
    }
    
    //已经确定当前的head.val != val
    ListNode pre = head;
    ListNode cur = head.next;
    while(cur!=null){
        if(cur.val==val){
            pre.next = cur.next;
        }else{
            pre = cur;
        }
        cur = cur.next;
    }
    return head;    
}

方法二：不添加虚拟节点and pre Node方式

public ListNode removeElements(ListNode head, int val) {
        while(head != null && head.val == val){
            head = head.next;
        }

        ListNode cur = head;
        while(cur != null){
            while(cur.next!=null && cur.next.val == val){
                cur.next = cur.next.next;
            }
            cur = cur.next;
        }
        return head;
}

方法三：增加虚拟节点

public ListNode removeElements(ListNode head, int val){
    if(head == null) return head;
    
    ListNode dummy = new ListNode(-1, head); //由于它不是真正的数据节点，因此给它赋一个特殊值（如-1）来表示这不是一个常规的数据节点。表明这个节点是一个虚拟头节点，不包含实际数据。
    ListNode pre = dummy;
    ListNode cur = head;
    while(cur != null){
        if(cur.val == val){
            pre.next == cur.next;
        }else{
            pre = cur;
        }
        cur = cur.next;
    }
    return dummy.next;
}

需要注意点：

注意第一个循环是使用while还是if。如果使用if，那么第一个head判断之后，如果新head的值还是target，用if就判断不到了。所以要用while

• 时间复杂度：O(n)
• 空间复杂度：O(1)

---

三、707.设计链表

文档讲解：https://programmercarl.com/0707.%E8%AE%BE%E8%AE%A1%E9%93%BE%E8%A1%A8.html

视频讲解：https://www.bilibili.com/video/BV1FU4y1X7WD?p=7&vd_source=9239d2aed03432357fb58e82f8d152ff

LeetCode题目：https://leetcode.cn/problems/design-linked-list/

思路：

建立虚拟头结点

实现5个功能：

• 获取第n个节点的值
• 头部插入节点
• 尾部插入节点
• 第n个节点前插入节点
• 删第n个节点

代码：

单链表

class ListNode{
    int val;    // 这是一个成员变量，用来存储节点的值，类型为int
    ListNode(){}  // 这是一个无参构造函数，创建ListNode对象时可以不传入任何参数，函数体为空，可以进行一些默认初始化操作，但这里没有做任何事情
    ListNode(int val){     // 这是一个有参构造函数，创建ListNode对象时可以传入一个int类型的参数val
        this.val = val;   // 使用this关键字将传入的val值赋给成员变量val
    }    
}

class MyLinkedList{
    //size存储链表元素的个数
    int size;
    //虚拟头结点
    ListNode head;
    
    //初始化链表
    public MyLinkedList(){
        size = 0;
        head = new ListNode(0);
    }
    
    //获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
    public int get(int index){
        if(index<0 || index>size-1) return -1;
        ListNode currentNode = head;
        
        for(int i=0; i<=index; i++){
            currentNode = currentNode.next;
        }
        return currentNode.val;    
    }
    
    //在链表最前面插入一个节点，等价于在第0个元素前添加
    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 pred = head;
        for(int i=0; i<index; i++){
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pre.next;
        pre.next = toAdd;
        
    }
    
    //删除第index个节点
    public void removeAtIndex(int index){
        if(index < 0 || index >= size) return;
        size--;
        if(index = 0){
            head = head.next;
            return;
        }
        ListNode pred = head;
        for (int i; i< index; i++){
            pred = pred.next;
        }
        pred.next = pred.next.next;
    }

}

双链表：

需要注意点：

插入的时候，要保证先更新新节点的next指向，再更新节点前的next指向自己。

考虑方法中代入边界值是否符合条件。

首先判断n是否合理取值

---

四、206.反转链表

文档讲解：https://programmercarl.com/0206.%E7%BF%BB%E8%BD%AC%E9%93%BE%E8%A1%A8.html

视频讲解：https://www.bilibili.com/video/BV1nB4y1i7eL

LeetCode题目：https://leetcode.cn/problems/reverse-linked-list/description/

思路：

有2种写法：双指针法、递归法

核心就是将原有数组的箭头颠倒过来。

• 第一种：双指针法

首先定义一个cur，指向head。再定义一个pre，指向head前的节点，也就是NULL，还要设置个指针temp，保存cur->next；

然后开始反转：cur->next = pre。然后整体往后移动：pre = cur; cur=temp; temp=temp->next;

最后结束的标志：cur指向null，pre指向最后一个节点。循环结束，链表翻转结束，return pre;

• 第二种：递归法

和双指针逻辑一样，初始化时cur = head, pre = null

代码：

方法一：双指针法

class Solution{
    public ListNode reverseList(ListNode head){
        ListNode pre = null;
        ListNode cur = head;
        ListNode temp = null;
        while(cur!= null){
            temp = cur.next;  //用temp保存下一节点
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;  
    }    
}

方法二：递归法

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

需要注意点：

注意反转指针后，三个指针移动的先后顺序。

双指针法：

• 时间复杂度: O(n)
• 空间复杂度: O(1)

递归法：

• 时间复杂度: O(n), 要递归处理链表的每个节点
• 空间复杂度: O(n), 递归调用了 n 层栈空间