数据结构（二）—— 链表

---

一、链表基础

链表是一种线性结构。
单链表：一个节点包括：一个指针和一个数据。指针只能指下一个节点。
双链表：一个节点包括：两个指针和一个数据，可以向前向后查询。
循环链表：指针收尾相接。

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

1.1 链表定义

struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};
通过自定义构造函数初始化节点
ListNode* head = new ListNode(5);

1.2 创建链表

只要给了头节点dummy，你就拥有了整个链表

1.3 删除链表某一节点

删除链表节点，也就是说让a->next = a->next->next

1.4 与数组的对比

数组插入慢，查询快，链表反之。
数组长度固定，而链表长度不固定，所以链表适用于频繁增删、较少查询的场景。

二、题

重要1、2

2.1 21 合并两个有序链表

1、创建新链表

2、遍历输入的l1和l2

3、加入剩下的东西

迭代版本：

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 == nullptr) return l2;
        if(l2 == nullptr) return l1;

        ListNode* headres = new ListNode(999);
        ListNode* cur = headres;
        while(l1 != nullptr && l2 != nullptr) {
            if(l1->val < l2->val) {
                cur->next = l1;
                l1 = l1->next;
            }
            else {
                cur->next = l2;
                l2 = l2->next;
            }
            cur = cur->next;
        }
        
        // 加剩下的东西
        if (l1 == nullptr) cur->next = l2;  
        if (l2 == nullptr) cur->next = l1;
        
        return headres->next;
}

递归版本：

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 == nullptr) return l2;
        if(l2 == nullptr) return l1;
        else if(l1->val >= l2->val)
        {
            l2->next = mergeTwoLists(l1,l2->next);
            return l2;
        }
        else
        {
            l1->next = mergeTwoLists(l1->next,l2);
            return l1;
        }
}

2.2 206 反转单链表

题目：输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

图中有误，应该是先移动pre

重点：步骤
1、temp = cur->next; // 存储即将断开的指针
2、cur->next = pre; // 断开指针指向前面的pre
3、pre = cur; cur = temp; // 先移动pre，后移动cur

ListNode* reverseList(ListNode* head) {
    ListNode* cur = head;
    ListNode* pre = NULL;
    ListNode* temp; // 保存cur的下一个节点
    while (cur != NULL) {
        temp = cur->next;
        cur->next = pre;  // 指向pre指向的前一个节点以此反向
        pre = cur;  
        cur = temp;
    }
    return pre;
}

2.3 203 移除链表元素

代码如下

ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* cur = dummy;
        while(cur->next != nullptr){
            if(cur->next->val == val) {
                // ListNode* temp = cur->next;
                cur->next = cur->next->next;
                // delete temp;
            }else{
                cur = cur->next;
            }
        }
        head = dummy->next;
        // delete dummy;
        return head;
}

删除节点总结

1、删除节点的方式1：直接移动头指针，等于删除了1节点

直接删除头节点格式
1、ListNode* temp = head；
head = head->next;  // 头节点移位就是删除，注意与下方的cur移位操作进行对比
delate temp;

2、删除节点的方式2：设置一个虚拟头结点

2、虚拟头节点删除格式
ListNode* dummyHead = new ListNode(0);  // 设置一个虚拟头结点，该节点的val为0
dummyHead->next = head; // 将head赋给虚拟头结点的指针，这样方面后面做删除操作
ListNode* cur = dummyHead;  // 这样就能肆无忌惮的删除了cur了，只是复制了一个等于dummyHead的属于链表外部的指针变量
cur->next = cur->next->next;  // 删除操作
cur = cur->next;  // 移位操作，不删除
// 删除完成后释放头节点内存
head = dummyHead->next;
delate dummyHead;
3、
ListNode* cur = head;
一个属于链表外部的指针变量

2.4 707 设计链表

看视频，加深对链表理解
https://www.bilibili.com/video/BV1FU4y1X7WD

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

交换和删除节点的题把交互的过程画出来，边画边写。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = dummyHead;
        while(cur->next != nullptr && cur->next->next != nullptr)
         {
            ListNode* tmp = cur->next; // 记录临时节点
            ListNode* tmp1 = cur->next->next->next; // 记录临时节点

            cur->next = cur->next->next;    // 步骤一
            cur->next->next = tmp;          // 步骤二
            cur->next->next->next = tmp1;   // 步骤三

            cur = cur->next->next; // 步骤四：cur移动两位，准备下一轮交换
        }
        return dummyHead->next;
    }
};

步骤一：

步骤二：

步骤三：

步骤四：cur已经移动了两位

2.6 9 删除链表的倒数第N个节点

题目：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
提示：注意是倒数第n个节点，而我们并不知道输入链表的长度，所以需要fast指针先走n+1步，然后slow和fast再一起走，这个fast指向NULL指针时，slow刚好指向导数第n个

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n-- && fast != NULL) {
            fast = fast->next;
        }
        fast = fast->next; // fast再提前走一步，因为需要让slow指向删除节点的上一个节点
        while (fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next; 
        
        // ListNode *tmp = slow->next;  C++释放内存的逻辑
        // slow->next = tmp->next;
        // delete nth;
        
        return dummyHead->next;
    }
};

2.7 面试题 02.07. leetcode160 链表相交

思路：使用哈希映射insert函数保存节点指针，再用count函数查找是否有相同指针地址。
想到用unordered_set<ListNode*> visited这道题非常简单。
PS：链表相交说明两个链表中有两个指针(Alistnode、Blistnode)指向了同一片内存
Alistnode->val == Blistnode->val

2.8 142 环形链表II

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

2.8.1 思路一：寻找链表中是否有多个指针指向同一内存空间

使用哈希映射查找相同指针地址，因为环入口节点一定有两个不同的指针指向这个入口节点

ListNode* detectCycle(ListNode* head) {
    unordered_set<ListNode*> visited;
    ListNode* dummyHead = new ListNode(0);
    dummyHead->next = head;
    ListNode* temp = dummyHead;
    temp = temp->next;
    while (temp != NULL) {
        visited.insert(temp);
        temp = temp->next;
        if (visited.count(temp)) {
            // ListNode* found = head;
            // int pos = 0;
            // while(found != temp){
            //     pos++;
            //     found = found->next;
            // }    pos：第pos个节点开始环
            return temp;
        }
    }
    return NULL;
}

2.8.2 思路二 不重要

---