代码随想录算法训练营-day03-链表理论基础、203.移除链表元素、707. 设计链表、206.反转链表 (1)

链表理论基础

1. 文章学习来源：
2. 链表（单链表）：链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。
3. 头节点（head）：链表的入口结点。如下图所示（图片来源与代码随想录）


4. 双链表：在单链表的基础上，增加反向指针，即每个节点有两个指针，分别指向上一个节点和下一个节点。链表结构如下图所示（图片来源与代码随想录）


5. 循环链表：在单链表的基础上，首尾相连，即最后一个指针指向头节点。可以解决约瑟夫环问题。


6. 链表的一些特点：储存方式不连续，适用于数量不固定、增删多、查询少的场景。
7. 定义链表的代码：

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.移除链表元素

1. 学习文章链接：
2. 题目分析：
   1. 如果某个节点是目标节点，那么就将该节点的上一个节点的next指针指向该节点的下一个节点。示意图如下图所示。
   2. 如果直接进行删除处理，因为头节点是没有上一节点，因此，需要单独处理下头节点。
   3. 对直接删除处理进行改进，即使用虚拟头节点进行删除，该方法将不再单独处理头节点，所有节点将统一处理。


3. 代码
   1. 提问：为什么不能返回head节点？
      1. head节点有可能被删除，如果不被删除，则可以返回head节点。
   2. cur起到了什么作用？
      1. dummy是用来标记头节点，因此需要孪生兄弟来帮他处理自己内身的删除问题。个人理解，cur是医生。

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

4. 心得
   1. 链表知识忘得很多
   2. 对虚拟头节点更深刻的理解，也探究为什么不能直接返回头节点。

707.设计链表

1. 学习文章链接：
2. 题目分析：
   1. 设计链表分为三个部分：链表结构体 + 链表初始化（长度size，头节点head） + 链表方法。
   2. get方法是其他几种方法的基础，是add方法与delete方法的基础框架。
   3. add方法需要注意size的增加。
   4. delete方法要注意size的减少，删除节点为头节点时需要特殊处理。
   5. addAtHead、addtTail方法基于add方法。
3. 代码：

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 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) {
        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 pre = head;
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }

        ListNode toAdd = new ListNode(val);
        toAdd.next = pre.next;
        pre.next = toAdd;
    }
    
    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;
    }
}

4. 心得
   1. 细节：size、删除方法中的头节点处理。
   2. 这题的确有点折磨人。。。

707. 设计链表

1. 学习文章链接：
2. 题目分析：
   1. 反转涉及到双指针，pre指向上一个节点，cur指向当前节点
   2. 每次指针反向之前都要保留当前节点的下一个节点，也就是cur.next
   3. 结果返回pre指针即可
3. 代码：

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode pre = null;
        ListNode cur = head;
        while (cur != null) {
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;

4. 心得：
   1. 切记保存的是当前节点的下一个节点，而不是当前节点，否则会使当前节点与下一节点断开
   2. 对链表有了更深的理解