代码随想录算法训练营第三天| 链表理论基础，203.移除链表元素，707.设计链表，206.反转链表

链表理论基础

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个数据域和几个指针域，最后一个节点的next指针域指向null。链表的入口节点称为链表的头结点也就是head。

单链表

双链表

每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。这样双链表既可以向前查询也可以向后查询。

循环链表

循环链表，顾名思义，就是链表首尾相连。可以用来解决约瑟夫环问题。

链表的存储方式

链表在内存中不是连续分布的。链表是通过指针域的指针链接在内存中各个节点。所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

链表的定义

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

链表的操作

删除节点

删除D节点，如图所示：

 只要将C节点的next指针 指向E节点就可以了。

添加节点

可以看出链表的增添和删除都是O(1)操作，也不会影响到其他节点。

但是要注意，要是删除第五个节点，需要从头节点查找到第四个节点通过next指针进行删除操作，查找的时间复杂度是O(n)。

与数组对比的性能分析

203.移除链表元素

建议： 本题最关键是要理解 虚拟头结点的使用技巧，这个对链表题目很重要。

题目链接/文章讲解/视频讲解：：代码随想录

重点：使用虚拟头节点，可以保证操作头节点和非头节点时的操作一致

链表操作的两种方式：

• 直接使用原来的链表来进行删除操作。

• 

• 设置一个虚拟头结点在进行删除操作。

• 

/**
 * 不添加虚拟节点方式
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 */
public static ListNode removeElements(ListNode head, int val) {
        // 移动头节点到非目标值的节点上
        while (head != null && head.val == val) {
            head = head.next;
        }
        // 说明全部节点都是要删掉的
        if (head == null) {
            return null;
        }
        ListNode pre = head;
        // 经过最上面的while循环，当前头节点的值肯定不是要删的值
        ListNode cur = head.next;
        while (cur != null) {
            if (cur.val == val) {
                pre.next = cur.next;
            } else {
                pre = cur;
            }
            cur = cur.next;
        }
return head;

/**
 * 添加虚节点方式
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 */
public static ListNode removeElements(ListNode head, int val) {
        if (head == null) {
            return null;
        }
        // 加入虚拟头节点，可以把操作头节点和非头节点的操作统一起来
        ListNode dummyHead = new ListNode(-1, head);
        ListNode pre = dummyHead;
        ListNode cur = dummyHead.next;
        while (cur != null) {
            if (cur.val == val) {
                pre.next = cur.next;
            } else {
                pre = cur;
            }
            cur = cur.next;
        }
        return dummyHead.next;
}

707.设计链表

建议： 这是一道考察 链表综合操作的题目，不算容易，可以练一练 使用虚拟头结点

题目链接/文章讲解/视频讲解：代码随想录

重点：熟悉链表的获取，添加，删除操作。可以通过添加虚拟头节点的方式来辅助操作。

class Node {
    int val;
    Node next;
    public Node(int val) {
        this.val = val;
    }
    public Node(int val, Node next) {
        this.val = val;
        this.next = next;
    }
}

class MyLinkedList {
    int size;
    Node dummyHead; // 虚拟头节点

    public MyLinkedList() { // 初始化链表及虚拟头节点
        size = 0;
        dummyHead = new Node(-1, null);
    }

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

    public void addAtHead(int val) {
        // 先把新头节点和旧头节点连接上，再连接虚拟头节点和新头节点
        Node newHead = new Node(val, dummyHead.next);
        dummyHead.next = newHead;
        size++;
    }

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

    public void addAtIndex(int index, int val) {
        if (index < 0 || index > size) {
            return;
        }
        Node pre = dummyHead;
        // 要找的是要插入index的前一个节点
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }
        Node insertNode = new Node(val, pre.next);
        pre.next = insertNode;
        size++;
    }

    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        Node pre = dummyHead;
        // 要找的是要删除index的前一个节点
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }
        pre.next = pre.next.next;
        size--;
    }
}

206.反转链表

建议先看我的视频讲解，视频讲解中对 反转链表需要注意的点讲的很清晰了，看完之后大家的疑惑基本都解决了。

题目链接/文章讲解/视频讲解：​​​​​​代码随想录​​​​​​

重点:

1.双指针（快慢指针）

双指针需要一个temp变量来保存cur.next，不然cur.next = pre之后，我们的cur就不知道怎么移动到下一个了。

2. 递归 

递归的操作逻辑其实和双指针是一样的，递归最主要的是要想好最底层的终止递归的条件以及下一次递归的参数是这一次递归的哪个值。

// 双指针
public static ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        // 需要一个temp变量来保存cur.next，
        // 不然cur.next = pre之后，我们的cur就不知道怎么移动到下一个了
        ListNode temp;
        while (cur != null) {
            temp = cur.next;
            // 掉转链表方向
            cur.next = pre;
            // 移动两个指针
            pre = cur;
            cur = temp;
        }
        return pre;
}

public static ListNode reverseList(ListNode head) {
        return reverse(null, head);
    }

public static ListNode reverse(ListNode pre, ListNode cur) {
        // 递归底层回调条件，也就是终止递归条件
        if (cur == null) {
            return pre;
        }
        // 每个节点掉转方向的操作
        ListNode temp = cur.next;
        cur.next = pre;
        // 下一次递归的pre就是这次递归的cur，下一次递归的cur就是这次递归的temp
        return reverse(cur, temp);
}