代码随想录(day03)-LeetCode：203、707、206

1. 链表理论基础

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是【数据域】一个是【指针域】（存放指向下一个节点的指针）。最后一个节点的指针域指向为null（空指针）。

链表的入口节点称为链表的头结点，即：head。

链表的分类：

• 单链表

  单链表中的指针域只能指向节点的下一个节点。

• 双链表

  双链表：每一个节点有两个指针域，一个指向上一个节点，一个指向下一个节点。

  双链表既可以向前查询也可以向后查询。

• 循环链表

  首位相连的链表，最后一个节点的指针域指向头结点。

链表的存储方式：

数组在内存中是连续分布的，但链表在内存中并不是连续分布的。

链表是通过指针域的指针链接在内存中各个节点。

链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

链表的操作：

• 删除节点

  1. 若要删除ABC节点中的B节点，则将待删除节点（B）的上一个节点（A）的指针域指向待删除节点的下一个节点（C）。

  2. 若要删除head节点，则将head指向当前头结点的下一个节点，作为新的head节点。

  待删除节点此时仍留在内存中，在C++中最好再手动释放内存，而在Java、Python中因为有内存回收机制的存在，可不用手动删除。

• 添加节点

  若要在AB节点中添加C节点，则将A节点的指针域指向待添加节点（C），再将C节点的指针域指向B节点即可。

  链表的删除、添加操作的时间复杂度为O(1)，并不会影响到其他节点。

  注意：当要删除链表中的最后一个节点时，需要从head节点查找到倒数第二个节点，并通过其next指针进行删除。此时查找的时间复杂度为：O(n)

数组&链表性能分析：

在此分析的性能为操作的时间复杂度。

	插入 / 删除	查询	使用场景
数组	O(n)	O(1)	数据量固定、频繁查询、较少增删
链表	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;
	}
}

---

2. 【203】移除链表元素

力扣题目链接：203

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

【示例1】：

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

【示例2】：

输入：head = [], val = 1
输出：[]

【示例3】：

输入：head = [7,7,7,7], val = 7
输出：[]

【提示】：

• 列表中的节点数目在范围 [0, 104] 内
• 1 <= Node.val <= 50
• 0 <= val <= 50

---

方法一：原链表删除元素

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

  移除头结点和移除其他节点的操作是不一样的，因为链表的其他节点都是通过前一个节点来移除当前节点，而头结点没有前一个节点。

  删除头结点：将头结点向后移动一位即可，就从链表中移除了当前的头结点。

  在单链表中【移除头结点】和【移除其他节点】的【操作方式不同】，需要单独写一段逻辑来处理移除头结点的情况。

/**
 * 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，若新的头结点值仍为val，继续删除
        while (head != null && head.val == val) { 
            head = head.next;
        }
        //若head为null，则退出
        if (head == null) {
            return head;
        }
        //删除其他节点的方式
        //cur为当前节点、cur.next为待删除节点
        ListNode cur = head; 
        while (cur != null && cur.next != null) { 
            if (cur.next.val == val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        return head;
    }
}

---

方法二：使用虚拟头结点

虚拟头结点（dummy head）：也可称作“哨兵节点”。

给链表添加一个虚拟头结点为新的头结点，这样进行删除节点的操作方式就可以统一了。

/**
 * 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) {
        if(head == null) {
            return head;
        }
        //创建虚拟头结点，其next指向head
        ListNode dummyHead = new ListNode(-1,head);
        //cur为当前节点，cur.next为待删除节点
        ListNode cur = dummyHead;
        while (cur.next != null) {
            if (cur.next.val == val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        //更新删除后的新head
        head = dummyHead.next;
        return head;
    }
}

---

3. 【707】设计链表

力扣题目链接：707

【题目描述】：
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

【示例】：

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

【提示】：

0 <= index, val <= 1000
请不要使用内置的 LinkedList 库。
get, addAtHead, addAtTail, addAtIndex 和 deleteAtIndex 的操作次数不超过 2000。

---

• 本题统一使用的是虚拟头结点方式进行求解，便于头结点和其他节点进行统一操作。

单链表实现

//定义单链表节点
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 dummyHead; //虚拟头结点，而非真正的头结点head

    public MyLinkedList() { //初始化链表
        size = 0;
        dummyHead = new ListNode(0);
    }
    
    /*获取到第index个节点数值，如果index是非法数值直接返回-1;
    注意index是从0开始的，第0个节点就是头结点*/
    public int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode cur = dummyHead.next; //cur记录当前节点，从真正的头结点开始
        while (index > 0) { //cur一直后移，直到移到index位置
            cur = cur.next;
            index--;
        }
        return cur.val;
    }
    
    //在链表最前面插入一个节点，新插入的节点为新的头节点
    public void addAtHead(int val) {
        ListNode newNode = new ListNode(val); //待插入的节点
        //注意next改变的顺序，不能反了
        newNode.next = dummyHead.next;
        dummyHead.next = newNode;
        size++;
    }
    
    //在链表尾部添加新节点
    public void addAtTail(int val) {
        ListNode newNode = new ListNode(val); //待插入的节点
        ListNode cur = dummyHead; //cur记录当前节点，从虚拟头结点开始
        while (cur.next != null) { //cur一直后移，直到移到尾结点
            cur = cur.next;
        }
        cur.next = newNode;
        size++;
    }
    
    /*在index个节点前插入一个新节点。
      若index = 0，则插入的节点为新的头结点；
      若index = size，则插入的节点为尾结点；
      若index > size，则返回空；
      若index < size，则在头部插入节点；
    */
    public void addAtIndex(int index, int val) {
        if (index > size) return;
        if (index < 0) index = 0;
        ListNode newNode = new ListNode(val); //待插入的节点
        //cur.next为第index节点，cur为其前驱节点
         ListNode cur = dummyHead; //cur记录当前节点，从虚拟头结点开始
         while (index > 0) {
             cur = cur.next;
             index--;
         }
         newNode.next = cur.next;
         cur.next = newNode;
         size++;
    }
    
    //删除index个节点，若index > size，直接return
    //注意index是从0开始的
    public void deleteAtIndex(int index) {
        if (index >= size || index < 0) {
            return;
        }
        ListNode cur = dummyHead;
        while (index > 0) {
            cur = cur.next;
            index--;
        }
        cur.next = cur.next.next;
        size--;
    }
}

---

4. 【206】反转链表

力扣题目链接：206

【题目描述】：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

【示例1】：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

【示例2】：

输入：head = [1,2]
输出：[2,1]

【实例3】：

输入：head = []
输出：[]

【提示】：

提示：

• 链表中节点的数目范围是 [0, 5000]
• -5000 <= Node.val <= 5000

---

方法一：双指针算法

若通过再定义一个新的链表来实现元素的反转，则会造成很大的内存开销。

其实只需要改变链表的next指针的指向（将next改为指向前一个节点），直接将链表反转 ，而不用重新定义一个新的链表。

在整个过程性并没有添加或者删除节点，仅仅是改变next指针的方向。

【实现思路】：

• 首先定义一个【cur指针】，指向头结点；再定义一个【pre指针】，初始化为null。

• 开始反转，首先把 cur.next 节点用【tmp指针】保存。

• 为什么要保存一下这个节点呢？因为接下来要改变 cur.next 的指向，即：将cur.next 指向pre ，此时反转了第一个节点。

• 随后，循环走如下代码逻辑了，继续移动pre和cur指针。

• 当cur 指针已经指向了null，循环结束，链表反转完毕。 最后return pre指针，其指向了新的头结点。

/**
 * 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) {
        //pre初始化为null，反转后其上一个节点为尾结点
        ListNode pre = null; 
        ListNode cur = head;
        ListNode temp = null;
        //cur==null时，说明已到最后节点
        while (cur != null) {
            //注意改变的顺序逻辑
            temp = cur.next; //在改变前暂存下一个节点
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}

---

方法二：递归算法

逻辑与双指针算法相同，代码更简洁，但更晦涩难懂。

按照双指针算法的思路进行改写，赋值、初始化等均相互对应。

/**
 * 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) {
        return reverse(null, head);
    }

    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); //原方法参数：reverse(pre,cur)

    }
}

---

方法三：从后往前递归

双指针算法、递归算法均是从前往后反转。

此方法为从后往前反转指针指向进行递归。

/**
 * 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) return null;
        if (head.next == null) return head;

        //递归调用：反转第二个节点开始往后的链表
        ListNode last = reverseList(head.next);
        //反转头结点与第二个节点的指向
        head.next.next = head;
        //此时的head节点为尾结点，其next指向null
        head.next = null;
        return last;
    }
}

---

5. 总结

今天学习了链表的基础知识，通过这三道算法题更加了解了对链表的操作，同时也加深了对双指针算法的使用。

递归算法代码看起来很简洁，但是理解起来更晦涩，需要慢慢琢磨。

万丈高楼平地起，加油！day day up！

---