基础知识

链表是一种通过指针串联在一起的线性结构。在内存中不是连续分布的，分配机制取决于操作系统内存管理。

类型

三种类型：单链表、双链表、循环链表

单链表：每个节点由两部分组成，数据域和指针域（存放指向下一个节点的指针），最后一个节点的指针域指向NULL。

双链表：每个节点有两个指针域（ prec 和 next ），分别指向上一个和下一个节点，可以向前查询，也可以向后查询。

循环链表：首尾相连，可以解决约瑟夫环问题。

链表的c++定义

//单链表
struct ListNode {
    int val;
    ListNode *next;
    //构造函数
    ListNode (int x): val(x), next(nullptr) {}
};

重写构造函数，可以直接给 val 赋值：

ListNode *head = new ListNode(5);

使用默认函数不能直接赋值：

ListNode *head = new ListNode();
head->val = 5;

指针的简单知识

如下：ListNode* p = new ListNode()

不管是ListNode* p 还是ListNode *p，它的类型都是ListNode *，p是变量名，用来存储ListNode类型数据的地址。

C语言重点——指针篇（一篇让你完全搞懂指针） - 知乎 (zhihu.com)

移除元素

移除元素有两种方法：用/不用虚拟头节点

不用虚拟头节点

删除头节点的情况要单独讨论

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
		//删除头节点
        while (head != NULL && head -> val == val) {
            ListNode* tmp = head;
            head = head -> next;
            delete tmp;
        }
        //删除非头节点
        ListNode* cur = head;
        while (cur != NULL && cur -> next != NULL) {
            if (cur -> next -> val == val) { //找到该元素
                ListNode* tmp = cur -> next;
                cur -> next = cur -> next -> next;
                delete tmp;
            } else { //没找到，继续找
                cur = cur -> next;
            }
        }
        return head;
    }
};

用虚拟头节点

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
		ListNode* dummyNode = new ListNode(0); //创建
        dummyNode -> next = head;
        ListNode* cur = dummyNode;
        while (cur -> next != NULL) {
            if (cur -> next -> val == val) {
                ListNode* tmp = cur -> next;
                cur -> next = cur -> next -> next;
                delete tmp;                
            } else {
                cur = cur -> next;
            }
        }
        head = dummyNode -> next;
        delete dummyNode;
        return head;
    }
};

设计链表

这题真难，但真的顶。

自己写出来一堆错，看着题解改了好久

class MyLinkedList {
public:
    // 定义结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val): val(val), next(nullptr) {}
    };
    // 初始化链表
    MyLinkedList() {
		_size = 0;
        _dummyHead = new LinkedNode(0);
    }
    // 根据索引获取元素
    int get(int index) {
		// 若值不合理，返回-1
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while (index--) {
            cur = cur->next;
        }
        return cur->val;
    }
    // 在头部添加新节点
    void addAtHead(int val) {
		LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }
    // 在尾部添加新节点
    void addAtTail(int val) {
		LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }
    // 在Index前插入新节点
    void addAtIndex(int index, int val) {
		if (index > _size) { // 若等于size，就插入size-1，就是尾部。若小于0，就插入头部
            return; // 不作处理
        }
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while (index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }
    // 删除Index的节点
    void deleteAtIndex(int index) {
		if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while (index--) {
            cur = cur->next;
        }
        // 要删的是下一个节点
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != NULL) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;
};

反转链表

两种方法：双指针法、递归法

双指针法

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
		ListNode* pre = NULL; // 指向前一个结点
        ListNode* tmp; // 指向下一个结点
        ListNode* cur = head;
        while (cur) {
            tmp = cur->next; // 保存下一个结点
            cur->next = pre; // 反转
            // 循环
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};

递归法

与双指针完全相同的逻辑，只是写法不同

class Solution {
public:
    ListNode* reverse(ListNode* pre, ListNode* cur) {
        if (cur == NULL) return pre;
        ListNode* tmp = cur->next;
        cur->next = pre;
        return reverse(cur, tmp); // 这里就是循环
    }
    ListNode* reverseList(ListNode* head) {
		return reverse(NULL, head); // 初始化赋值
    }
};

删除倒数第n个节点

用一种非常美妙的双指针法，根本想不到

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
		ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead;
        // fast先走
        while (n-- && fast != NULL) {
            fast = fast->next;
        }
        // fast再走一步，因为要指向前一个结点，好删
        fast = fast->next;
        // fast和slow一起走
        while (fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;
        return dummyHead->next;
    }
};

环形链表

双指针法

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast != NULL && fast->next != NULL) {
            // fast走两步，slow走一步
            fast = fast->next->next;
            slow = slow->next;
            // 二者相遇
            if (fast == slow) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1; // 有环的情况
            }
        }
        return NULL; // 无环的情况
    }
};