20230421 | 203. 移除链表元素、707. 设计链表、206. 反转链表

1、203. 移除链表元素

方法1：不添加虚拟节点方式，但是要注意处理删除头部的数据
时间复杂度 O(n)
空间复杂度 O(1)

/**
 * 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;
        }
        //已经为null，提前退出
        if(head == null) return head; 
        //前驱节点
        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;
    }
}

方法二：增加一个虚拟头节点，可以方便删除头部的数据，但主要返回时的位置是什么，构建头节点的时候要注意是：ListNode dump = new ListNode(-1,head); 或者是

public ListNode removeElements(ListNode head, int val) {
        //已经为null，提前退出
        if(head == null) return head; 
        ListNode dump = new ListNode(-1,head);
        //前驱节点
        ListNode pre = dump;
        //当前节点
        ListNode cur = head;
        while(cur!=null){
            if(cur.val == val){
                pre.next = cur.next; //前驱节点的指针指向当前节点的尾部
            }else{
                pre = cur; //前驱节点指向当前节点
            }
            cur = cur.next; //当前节点往后移动
        }
        return dump.next;
    }

2、707. 设计链表

删除链表节点： 链表-删除节点

添加链表节点： 链表-添加节点

这道题目设计链表的五个接口：

获取链表第index个节点的数值
在链表的最前面插入一个节点
在链表的最后面插入一个节点
在链表第index个节点前面插入一个节点
删除链表的第index个节点

可以说这五个接口，已经覆盖了链表的常见操作，是练习链表操作非常好的一道题目

链表操作的两种方式：

直接使用原来的链表来进行操作。
设置一个虚拟头结点在进行操作。

class ListNode{
    int val; //值
    ListNode next;
    ListNode(){}
    ListNode(int val){
        this.val = val;
    }
}
class MyLinkedList {
    //size 存储链表元素的个数
    int size;
    //虚拟节点
    ListNode head;

    //初始化 MyLinkedList 对象。
    public MyLinkedList() {
        size =0;
        head = new ListNode(0);
    }
    
    //获取第index个节点的数值，注意index是从0开始的，第0个节点就是头节点
    public int get(int index) {
        //如果下标无效，则返回 -1 。
        if(index<0|| index>=size){
            return -1;
        }
        ListNode currNode = head; //当前
        //包含一个虚拟头节点，所以查找第index+1个节点
        for(int i=0;i<=index;i++){
            currNode = currNode.next;
        }
        //返回值
        return currNode.val;
    }
    
    // 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
    // 等价于在第0个元素前添加
    public void addAtHead(int val) {
        addAtIndex(0,val); //借助按索引位置添加
    }
    
    //将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
    //等价于在size+1的位置添加
    public void addAtTail(int val) {
        addAtIndex(size,val);
    }
    
    //将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
    public void addAtIndex(int index, int val) {
        if(index>size) return;
        if(index<0) index = 0;
        size++;//链表长度+1
        
        //找到要插入节点的前驱
        ListNode pre = head;
        for(int i=0;i<index;i++){
            pre = pre.next;
        }
        ListNode toAdd = new ListNode(val); //创建节点
        toAdd.next = pre.next; //创建的节点指向插入的位置
        pre.next = toAdd; //指向当前节点
    }
    //如果下标有效，则删除链表中下标为 index 的节点。
    public void deleteAtIndex(int index) {
        if(index<0 || index>=size){
            return;
        }
        size--;
        if(index == 0) { //删除头节点的情况
            head = head.next;
            return;
        }
        //先找打前驱
        ListNode pre = head;
        for(int i=0;i<index;i++){
            pre = pre.next;
        }
        pre.next = pre.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);
 */

需要反复练习

3、206. 反转链表

/**
 * 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) {
        if(head ==null || head.next ==null) return head;
        ListNode cur = head;//当前节点
        ListNode pre = null;//前驱节点
        while(cur!=null){
            ListNode temp = cur.next; //记录下一个节点的位置，防止找不到
            cur.next = pre; //第一次pre为空，实现链表的端口操作
            pre = cur; //前驱节点指向下一个
            cur = temp; //当前节点指向临时存储的节点(下一个节点)
        }
        return pre; //返回pre节点，是因为pre节点已经指向最后一个位置了,各自的指针已经转变，并且此时cur为null。我错误的以为是head，其实head只指向1一个值了
    }
}

注意： 返回pre节点，是因为pre节点已经指向最后一个位置了,各自的指针已经转变，并且此时cur为null。我错误的以为是head，其实head只指向1一个值了