代码随想录-链表

General 5219

已于 2023-12-09 10:36:20 修改

阅读量140

点赞数

分类专栏：刷题记录文章标签：链表数据结构

于 2023-12-09 10:35:59 首次发布

本文链接：https://blog.youkuaiyun.com/m0_43422224/article/details/134782833

版权

刷题记录专栏收录该内容

3 篇文章

订阅专栏

4.1.1移除链表中给定val的节点_头节点单独处理

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        while(head!=NULL && head->val==val){//新的头节点也要检测是否为val
            ListNode* tmp = head;
            head = head->next;
            delete tmp;
        }
        ListNode* cur = head;//将头节点指针传给一个变量开始cur->next判断
        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;
    }
};

4.1.2移除链表中给定val的节点_头节点统一处理

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;
    }
};

4.2设计链表_头节点统一处理

必须使用虚拟头节点！！！
根据index get val时，需要从headnode（index = 0）开始，
插入新节点，根据题目要求是在该节点之前插入，所以从dummyNode开始，可以理解为-1开始。
delete节点时，index = _size为空，没有意义
链表尾部插入节点：判断条件：cur->next != nullptr，不要使用cur != nullptr这种条件

class MyLinkedList {
public:
    //定义链表结构体
    struct Linkednode{
        int val;
        Linkednode* next;
        Linkednode(int val):val(val),next(nullptr){}
    };
    MyLinkedList() {
        _dummynode = new Linkednode(0);
        _size = 0;
    }
    
    int get(int index) {
        if(index>(_size-1) || index<0){
            return -1;
        }
        Linkednode* cur = _dummynode->next;
        while(index--){// 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        Linkednode* newhead = new Linkednode(val);
        newhead->next = _dummynode->next;
        _dummynode->next = newhead;
        _size++;
    }
    
    void addAtTail(int val) {
        Linkednode* newnode = new Linkednode(val);
        Linkednode* cur = _dummynode;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newnode;
        _size++;
    }
     // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    // 如果index小于0，则在头部插入节点   
    void addAtIndex(int index, int val) {
        if(index > _size) return;
        if(index<0) index = 0;
        Linkednode* newnode = new Linkednode(val);
        Linkednode* cur = _dummynode;
        while(index--){
            cur = cur->next;
        }
        newnode->next = cur->next;
        cur->next = newnode;
        _size++;
    }
    
    void deleteAtIndex(int index) {
        if(index>=_size || index<0){
            return;
        }
        Linkednode* cur = _dummynode;
        while(index--){
            cur = cur->next;
        }
        Linkednode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        tmp = nullptr;
        _size--;

    }
    
    // 打印链表
    void printLinkedList() {
        Linkednode* cur = _dummynode;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }

    private:
        int _size;
        Linkednode* _dummynode;
};

4.3.1翻转链表_双指针法

定义一个pre指针指向空，定义cur指针指向头节点
1.定义tmp指针指向cur->next，保存下一个节点。
2.cur->next 翻转，指向pre，此时链表从cur节点处被拆为两部分。tmp保存了下一节点信息便于与未翻转节点建立联系。
3.pre前移，cur前移至tmp。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur){
            ListNode* tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;

    }
};

4.3.2翻转链表_递归法

逻辑与双指针是一样的，换了一种写法。tmp节点保存当前节点的next节点，cur节点的next翻转，递归调用的时候传参改成return reverse（cur,tmp）对应形参pre与cur。

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) {
        ListNode* cur = head;
        return reverse(NULL,head);

    }
};

4.3.3翻转链表_从后往前翻转

递归找到倒数第二个节点，将最后一个节点的next指向倒数第二个节点，倒数第二个节点的next指向NULL
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        //边缘条件判断
        if(head == NULL){
            return NULL;
        }
        if(head->next == NULL){
            return head;
        }
        //结合上边的边界条件，每调用一次递归，head往后移一个
        //最后一次递归 head->next = null,直接返回
        //则上一次递归 head 节点是倒数第二个
        ListNode* last = reverseList(head->next);
        //倒数第二个节点，next为最后一个节点，其next指向NULL
        //使其翻转，指向倒数第二个节点
        head->next->next = head;
        //倒数第二个节点本来是指向倒数第一个节点的，此时倒数第一和倒数第二节点互指
        //翻倒数第二个节点，翻转后倒数第二个节点暂时为最后一个节点，使其指向NULL
        head->next = NULL;
        return last;
    }
};

4.4 两两交换链表中的节点

这里的三个步骤一定要牢记：节点2要翻转，会失去与节点3的联系，所以tmp1要保存节点3，节点二翻转后要指向节点1，需要tmp保存一下节点1
1.cur指向节点2；
2.节点2翻转，指向节点1（已使用tmp保存）；
3.节点1指向节点3（已使用tmp1保存）；
后处理：新的链表已建立，cur下移两次，到节点1处。
另外while循环的条件：第一次，cur为_dummynode，对节点1、节点2进行交换
此时节点顺序为 cur 2 1 3 4；
第二次循环，需要交换节点3、节点4，cur需要指向节点1，这里判断一下节点3和节点4是否都存在，否则无法交换。
在这里插入图片描述

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* _dummynode = new ListNode(0);
        ListNode* cur = _dummynode;
        cur->next = head;
        while(cur->next != NULL && cur->next->next != NULL){
            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;
        }
        return _dummynode->next;

    }
};

4.5.1 删除链表的倒数第N个节点_递归计算链表长度，正向删除节点

采用递归的方法，先遍历链表到最后一个节点，传入cnt对链表长度进行计数。
主函数中先判断为空或者只有一个节点，这种情况都返回空即可。
创建_dummynode，正向遍历到要删除节点的前一个节点。
需要分类判断是删除头节点还是正常后续节点。遍历了两次。

class Solution {
public:
    int reverse(ListNode* head,int cnt){
        if(head->next == NULL){
            return cnt;
        }
        cnt++;
        cnt = reverse(head->next,cnt);
        return cnt;
    }
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head == NULL || head->next == NULL){
            return NULL;
        }
        int cnt = 1;
        cnt = reverse(head,cnt);
        ListNode* _dummmynode = new ListNode(0);
        _dummmynode->next = head;
        ListNode* cur = _dummmynode;
        int forward = cnt - n;
        while(forward--){
            cur = cur->next;
        }
        ListNode* tmp = cur->next;
        if(cnt == n){
            _dummmynode->next = cur->next->next;
        }
        else{
            cur->next = cur->next->next;
        }
        delete tmp;
        tmp = nullptr;
        cout << cnt <<" ";
        return _dummmynode->next;
    }
};

4.5.2 删除链表的倒数第N个节点_翻转链表，删除，再翻转

如标题，先翻转链表，然后正向删除节点，再翻转回去。
删除某个链表节点，一定是在要删除的节点前进行操作，故第一次翻转后，先把n自减1，再从dummynode开始往后循环。
循环遍历的过程中加入了对n的判断，如果n大于链表长度，直接break，删除的时候也加入了判断。

class Solution {
public:
    ListNode* reverse(ListNode* head){
        if(head == NULL){
            return NULL;
        }
        if(head->next == NULL){
            return head;
        }
        ListNode* last = reverse(head->next);
        head->next->next = head;
        head->next =NULL;
        return last;//这个头在所有递归中只是一直return

    }
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head == NULL || head->next == NULL){
            return NULL;
        }
        //这里已经通过判断，排除了链表为空和链表只有一个元素的情况
        //能运行到这里的链表，都是元素>=2的
        ListNode* _dummynode = new ListNode(0);
        
        _dummynode->next = reverse(head);
        ListNode* cur = _dummynode;
        n--;//循环遍历到要删除节点的前一个节点
        while(n--){
            if(cur->next!=NULL){//加入n大于链表长度的判断
                cur = cur->next;
            }
            else{
                break;
            }  
        }
        if(cur->next!=NULL){
            ListNode* tmp = cur->next;
            cur->next = cur->next->next;
            delete tmp;
            tmp = nullptr;
        }
        
        _dummynode->next = reverse(_dummynode->next);
        return _dummynode->next;
            
    }
};

4.5.2 删除链表的倒数第N个节点_快慢指针

fast先走n个节点，然后fast和slow一起走，直到fast到最后一个节点，这里与随想录稍微有一点区别。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* _dummyNode = new ListNode(0);
        _dummyNode->next = head;
        ListNode* fast = _dummyNode;
        ListNode* slow = _dummyNode;
        while(n-- && fast->next!= NULL ){
            fast = fast->next;
        }
        while(fast->next != NULL){
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;
        tmp = nullptr;
        return _dummyNode->next;
    }
};

在这里插入图片描述
这里走n+1是因为后面 fast 要直接走到NULL

随想录原版代码

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;
    }
};

4.6 链表相交

这个题理解起来有困难，代码倒是没有很高深的逻辑
大概就是两个长度不同的链表，首先将二者尾对齐，curA，curB为指向A和B的指针。
对齐后，curA和curB同时开始向后移动，移动过程中比较curA、curB是否相等（即是在比较两个链表剩余的部分是否相等）
判断如图 c1 c2 c3是否相等，直接用 if(curA ==curB)，curA、curB本身包含了链表data以及next，推测会根据next一直比较下去。
在这里插入图片描述

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0,lenB = 0;
        while(curA!=NULL){
            lenA++;
            curA = curA->next;
        }
        while(curB!=NULL){
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        if(lenB>lenA){
            swap(lenA,lenB);
            swap(curA,curB);
        }
        int gap = lenA-lenB;
        while(gap--){
            curA = curA->next;
        }
        while(curA!=NULL){
            if(curA == curB){
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

4.7 环形链表

1.可以使用快慢指针，fast一次走两个节点，slow一次走一个节点，只要二者相遇了，说明一定存在环。
2.如果有环的话，fast相对于slow一次多走一个节点，相当于一次靠近一个节点，因此一定会相遇。
3.计算环的入口：
如图，假如相遇的时候，slow走过x+y，fast走过x+(z+y)+y，又因为fast的速度是slow的两倍，因此：x+n(z+y)+y = (x+y)*2
化简：n(z+y) = x+y
目标是x，化简往x的方向靠：x = (n-1)(z+y)+z；
先拿n为1的情况举例，公式化简为 x = z；
从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个指针相遇的时候就是环形入口的节点。
这句话理解起来不是很直观，但是与公式化简结果一致。
在这里插入图片描述
这里理解为什么slow为 x+y

如果slow 和 fast同时在环入口开始走，一定会在环入口3相遇，slow走了一圈，fast走了两圈。
（上面这句话需要好好理解，是重点）
可以理解为，同起点，fast需要追击slow一环的距离，由于速度是两倍关系，所以一定是slow走一圈，fast走两圈
在这里插入图片描述
更一般的情况下，slow进环的时候，fast在环内任意一个位置。
fast走到入口3的时候，走过了 k+n，slow相应走过了(k+n)/2，由图可知，k<n，则 (k+n)/2一定小于n。
可以看出，slow还没有走到环入口3，fast就已经到环入口3了，又因为fast相对slow一次只靠近一个节点，所以slow入环后走第一圈时就会和fast相遇。
如上整体说的意思是：假设极限情况fast和slow同起点，fast需要追slow一圈才能相遇，slow走一圈，fast走两圈，在环入口3二者相遇。
但更一般的情况是：slow入环的时候，fast在环中任意位置，离环入口2距离为k，slow走一圈又到了环入口，fast能走两圈，还是在环入口距离k的位置，此时fast又已经跑到slow的前面去了，因此slow走一圈的过程中，一定和fast相遇过，因为fast一次只接近slow一个节点，不会跨越。
（这里可以反推一下去理解这个逻辑）
代码随想录采用了外循环加内循环的方法，fast指针本身可以指向NULL，但是NULL不能再next。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，此时从head 和 相遇点，同时查找直至相遇
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }
};

可以使用两个循环分别完成，需要注意的就是，fast一次跳两个节点，需要判断fast->next->next是否存在。
也可以判断fast是否为NULL 且 fast->next是否为NULL,fast本身可以指向链表最后的NULL，但是不能再next往下找节点。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(!head) return NULL;
        ListNode* fast = head;
        ListNode* slow = head;
        do{
            if(fast->next == NULL) return NULL;
            if(fast->next->next == NULL) return NULL;
            //也可以采用如下格式，只要fast,fast->next不为NULL,fast->next->next可以为NULL
            //if(fast == NULL) return NULL;
            //if(fast->next == NULL) return NULL;
            fast = fast->next->next;
            slow = slow->next;
        }while(fast!=slow);
        slow = head;
        while(fast != slow){
            fast = fast->next;
            slow = slow->next;
        }
        return slow;   
    }
};