DS | 链表 Linked List（240214更新）

理论：

1、线性表的链式存储

1.1 链式存储

        用一组任意的存储单元存储线性表的元素，这组单元可以是连续的，也可以是不连续的。
        每一个数据元素包含数据域和指针域，数据域存储数据元素信息，指针域存储后续数据元素的存储地址。数据域和指针域共同组成结点（Node）
        

1.2 相关概念

头结点和头指针：
        头指针：链表中第一个结点的存储位置（有头结点时为头结点，无头结点是为第一个元素结点（开始结点））；头指针具有标识作用，所以常常会用头指针冠以链表的名字；无论链表是否为空，头指针均存在，头指针是链表的必要元素。
        头结点：在单链表第一个结点前可以附设一个结点，称为头结点；头结点的数据域可以不存储数据，也可以存储链表长度等信息，指针域存储链表的头指针（第一个结点的存储位置）。

链表为空：

2、单链表：

        每个结点中只包含一个指针域的链表。

3、其他链表：

3.1 静态链表

        用数组描述的链表叫做静态链表，描述方法称为游标实现法

3.2 循环链表

        将链表终点结点的指针域由空指针改为指向头结点

3.3 双向链表

练习：

203.移除链表元素  

1、题目

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

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

2、解题

Key：设置虚拟头结点以统一原有头结点和其他结点的删除操作

public class Solution {
    public ListNode RemoveElements(ListNode head, int val) 
    {
        if(head == null)
        {
            return null;
        }
        else
        {
            //set a dummy node
            ListNode dummy = new ListNode(0);
            dummy.next = head;

            //set point
            ListNode prev = dummy;
            ListNode cur = head;
            //loop
            while(cur != null)
            {
                if(cur.val == val)
                {
                    prev.next = cur.next;
                }
                else
                {
                    prev = cur;
                }

                cur = cur.next;
            }

            return dummy.next;
        }
    }
}

3、总结

错误：
prev.next = cur
忘记删除操作是基于已经存在的链表，prev.next 本来即为cur；
prev和cur是遍历链表的指针，随着循环进行更新；

​
//loop
            while(cur != null)
            {
                if(cur.val == val)
                {
                    prev.next = cur.next;
                }
                else
                {
                    prev.next = cur;
                }

                cur = cur.next;
            }

​

707.设计链表

1、题目

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：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 的节点。

示例：
输入：
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出：
[null, null, null, null, 2, null, 3]
解释：
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

2、解题

public class MyLinkedList {
    public class ListNode
    {
        public int val;
        public ListNode next;
        public ListNode(int val = 0, ListNode next = null)
        {
            this.val = val;
            this.next = next;
        }
    }
    
    private ListNode head;
    private int size;

    public MyLinkedList() {
        this.head = null;
        this.size = 0;
    }
    
    public int Get(int index) {
        if(index < 0 || index >= this.size)
        {
            return -1;
        }
        else
        {
            int i = 0;
            ListNode cur = this.head;
            while(i < index)
            {
                cur = cur.next;
                i ++;
            }
            return cur.val;
        }
    }
    
    public void AddAtHead(int val) {
        ListNode newHead = new ListNode(val);
        newHead.next = this.head;
        this.head = newHead;
        this.size ++;
    }
    
    public void AddAtTail(int val) {
        if(head == null)
        {
            AddAtHead(val);
            return;
        }

        ListNode cur = this.head;
        while(cur.next != null)
        {
            cur = cur.next;
        }

        cur.next = new ListNode(val);
        size ++;
    }
    
    public void AddAtIndex(int index, int val) {
        
        if(index < 0 || index > this.size)
        {
            return;
        }
        if(index == 0)
        {
            this.AddAtHead(val);
            return;
        }

        ListNode newNode = new ListNode(val);
        ListNode prev = null;
        ListNode cur = head;

        for(int i = 0; i < index; i ++)
        {
            prev = cur;
            cur = cur.next;
        }

        newNode.next = cur;
        prev.next = newNode;
        size ++;
    }
    
    public void DeleteAtIndex(int index) {
        if(index < 0 || index >= this.size)
        {
            return;
        }
        if(index == 0)
        {
            head = head.next;
            this.size --;
            return;
        }

        ListNode prev = this.head;
        int i = 0;
        while(i < index -1)
        {
            prev = prev.next;
            i ++;
        }
        prev.next = prev.next.next;
        size --;
    }
}

3、总结

1、简单错误：
        0 < index < size 写法不对，不等式需要分开；
        若智啊！！！while循环里记得i++啊！！！！！！！！！！！！！！！！！！！！！！！！！
2、所有链表元素增减操作及时更新链表size；
3、所有操作建议第一步先单独讨论参数无效的情况（如index < 0 || index > size）
4、AddAtTail
        没有判断链表为空的情况；
        寻找链表最后一个结点可以以cur . next 不为空为loop条件

public void AddAtTail(int val)
{
    ListNode newEnd = new ListNode(val);
    ListNode lastNode = this.head;
    for(int i = 0; i < this.size; i ++)
    {
        lastNode = lastNode.next;
    }
    lastNode.next = newEnd;
}

5、AddAtIndex
        单独判断Index无效的情况；
        单独判断插入头结点的情况但不需要单独判断插入终端结点？
                类似删除节点中，设置虚拟头结点可以统一操作，否则单独写头结点的操作
        插入思路：（注意是将index位的结点替换为newnode，而不是再index位后插入newnode）
                1）同时找到index位的前驱结点prev和后继结点cur，用newnode替换cur。
                2）只找到index位的前驱结点prev，先设置newnode的后继结点，再将newnode设为prev的后继结点，注意顺序。

public void AddAtIndex(int index, int val) 
{
    ListNode newNode = new ListNode(val);
    ListNode cur = this.head;
    int i = 0;
    if(0 < index && index < this.size)
    {
        while(i < index - 1)
        {
            cur = cur.next;
            i ++;
        }
        newNode.next = cur.next;
        cur.next = newNode;
    }
    else if(index == 0)
    {
        this.AddAtHead(val);
    }
    else if(index == this.size)
    {
        this.AddAtTail(val);
    }
    else
    {
        return;
    }
}

6、DeleteAtIndex

        单独判断index无效的情况；
        单独写删除头结点的情况；

public void DeleteAtIndex(int index) {
        if(index == 0)
        {
            this.head = this.head.next;
        }
        else if(0 < index && index < this.size)
        {
            int i = 0;
            ListNode cur = this.head;
            while(i < index - 1)
            {
                cur = cur.next;
                i ++;
            }
            cur.next = cur.next.next;
        }
        else
        {
            return;
        }
    }

7、思路

用for循环或while循环查找某个位置或某个值的结点，前驱和后继结点，开始和终端结点
对节点进行删除或替换（插入）操作
单独讨论情况：index无效；头结点（也可以使用虚拟头结点）操作；链表为空时（）

206.反转链表

1、题目

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

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

2、解题

递归法：

3、总结

1、递归法纠错

2、双指针法
注意用temp存储cur.next

public class Solution {
    public ListNode ReverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null)
        {
            ListNode temp = cur.next;

            cur.next = pre;
            pre = cur;
            cur = temp;
        }

        head = pre;
        return head;
    }
}

3、实质就是指针指向反转，不要若智的以为是结点位置的互换！！！

24. 两两交换链表中的节点

1、题目

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

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

2、解题

public class Solution {
    public ListNode SwapPairs(ListNode head) {
        //set dummy  head
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;

        //
        ListNode cur = dummyHead;
        while(cur.next != null && cur.next.next != null)
        {
            //set temp
            ListNode temp1 = cur.next;
            ListNode temp2 = cur.next.next.next;

            //change
            cur.next = cur.next.next;
            cur.next.next = temp1;
            cur.next.next.next = temp2;

            //
            cur = cur.next.next;
        }

        return dummyHead.next;
    }
}

3、总结

画图解决问题：

19.删除链表的倒数第N个节点

1、题目

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

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

2、解题

二次扫描

public class Solution {
    public ListNode RemoveNthFromEnd(ListNode head, int n) {
        int size = 0;
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode cur = dummyHead;
        while(cur != null)
        {
            size ++;
            cur = cur.next;
        }

        cur = dummyHead;
        for(int i = 0; i < size - n - 1; i ++)
        {
            cur = cur.next;
        }
        cur.next = cur.next.next;
        return dummyHead.next;
    }
}

3、总结

1、注意：
                for循环条件：i < size - n - 1(要定位删除结点的前驱结点)
2、双指针写法：

public class Solution {
    public ListNode RemoveNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode first = dummy;
        ListNode second = dummy;

        // 将 first 指针向前移动 n+1 步
        for (int i = 0; i <= n; i++) {
            first = first.next;
        }

        // 继续同时移动 first 和 second 指针，直到 first 指针到达链表末尾
        while (first != null) {
            first = first.next;
            second = second.next;
        }

        // 删除倒数第 n 个节点
        second.next = second.next.next;

        return dummy.next;
    }
}

面试题 02.07. 链表相交

1、题目

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。

从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

2、解题

3、总结

142.环形链表II

1、题目

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点解释：链表中有一个环，其尾部连接到第二个节点。

2、解题

3、总结

1、思路推导：
Key：快慢指针为什么第一圈一定相遇；快指针为什么不会跳过慢指针；x和z的关系

2、