今日内容

链表理论基础、203.移除链表元素、707.设计链表、206.反转链表

代码随想录链接：代码随想录 (programmercarl.com)

链表理论基础

什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。因此链表在计算机内的存储不是连续的。

链表的入口节点称为链表的头结点也就是head。

如图所示：链表1

链表的类型

单链表 一个数据域一个指针域，指针域指向下一个next

双链表 一个数据域，前后两个指针域，一个指向前一个节点prev,一个指向下一个系欸但next,既可以向前查询也可以向后查询。如图所示：链表2

循环链表 循环链表，顾名思义，就是链表首尾相连。

循环链表可以用来解决约瑟夫环问题。

链表4

链表的定义

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

性能分析

再把链表的特性和数组的特性进行一个对比，如图所示：

链表-链表与数据性能对比

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

链表的长度可以是不固定的，并且可以动态增删，适合数据量不固定，频繁增删，较少查询的场景。

203.移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

删除操作就是将next指向下一节点，因为单链表只能指向下一个节点，因此如果要删除头节点，就会涉及如下两种链表操作：

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

设置虚拟头节点

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null){
            return head;
        }
        ListNode dummy = new ListNode(-1,head);
        ListNode cur = head;
        ListNode pre = dummy;
        while(cur != null){
            if(cur.val == val){
                pre.next = cur.next;
            }
            else{
                pre = cur;
            }
            cur = cur.next;
        }
        return dummy.next;
    }
}

不添加虚拟头节点

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        while (head != null && head.val == val) {
            head = head.next;
        }
        if(head == null){
            return head;
        }
        
        ListNode cur = head.next;
        ListNode pre = head ;
        while (cur != null) {
            if(cur.val == val){
                pre.next = cur.next;
            }
            else{
                pre = cur;
            }
            cur = cur.next;
        }
        return head;
    }
}

不添加虚拟节点和 pre 节点的方法（用cur.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) {
            while(cur.next != null && cur.next.val == val){
                cur.next = cur.next.next;
            }
            cur = cur.next;
        }
        return head;
    }
}

其实就是要记得这个头节点的删除，处理好之后，之后的删除的关键就是指向下一个节点。

上述方法的时间复杂度都为O（n）空间复杂度都为O（1）

707.设计链表

你可以选择使用单链表或者双链表，设计并实现自己的链表。单链表中的节点应该具备两个属性：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 的节点。

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; i++) { 
            cur = cur.next;
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
        ListNode add = new ListNode(val);
            add.next = head.next;
            head.next = add;
            size++;
        // addAtIndex(0, val);
    }
    
    public void addAtTail(int val) {
        ListNode add = new ListNode(val);
        ListNode cur = head;
        for(int i = 0; i < size; i++ ) {
            cur = cur.next;
        }
        cur.next = add;
        size++;
        // addAtIndex(size, val);
    }
    
    public void addAtIndex(int index, int val) {
        ListNode cur = head ;
        ListNode add = new ListNode(val);
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        add.next = cur.next;
        cur.next = add;
        
        size++;
    }
    
    public void deleteAtIndex(int index) {
        if(index >= size || index < 0){
            return;
        } 
        size--;
        if(index == 0){
            head = head.next;
        return;
        }
        ListNode cur = head;
        for(int i = 0;i < index; i++) {
            cur = cur.next;
        }
        cur.next = cur.next.next;

    }
}

class ListNode{
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val){ //插入时用
        this.val=val;
    }
}

真的非常生疏。。。
tips：因为三个add函数都可以用addAtIndex实现，所以addAtHead、addAtTail可以直接调用addAtIndex，我也写了相应的代码。

206.反转链表

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

双指针法

根据之前数据结构课程的内容，可以写出一个：

代码如下：

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode right = head;
        ListNode left = null;
        while(right != null){
            ListNode temp = new ListNode();
            temp = right.next;
            right.next = left;
            left = right;
            right = temp;
        }
        return left;

    }
}

找一个temp寄存一下right，避免找不到即可。

递归反转

时间不多了，直接看了文章，代码没看，还有个嵌套的，嵌套在之前学数据结构的时候就不太会，有点难写，试一下：

哈哈写半天还是去看答案了，看了半天才看懂，代码如下：

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

这是从后向前递归，递归的作用在我看来就是在不改变原有的链接的情况下，找到了最后一个节点，也就是结果的头结点，然后每一次嵌套改变当前节点前后的指针。太妙了，看了半天才看懂。

另一种递归，有点像是双指针法，代码如下：

class Solution {
    public ListNode reverseList(ListNode head) {
       return reverse(null, head);
    }
    public ListNode reverse(ListNode left, ListNode right){
        if(right == null){
            return left;
        }
        ListNode temp = new ListNode();
        temp = right.next;
        right.next = left;
        return reverse(right,temp);
    }
}

这个就是说把代码中两次给left``right赋值的代码，用一条函数实现了，原理是类似。

结束。无需多言。

[Day3]代码随想录