leetcode刷题记录——链表

leetcode刷题记录——链表

——参考代码随想录和力扣顺序刷题(https://programmercarl.com/)

总结:善用虚拟头节点(dummyHead)


文章目录

  141. 环形链表

  142. 环形链表 II

  203. 移除链表元素

  206. 反转链表

  21. 合并两个有序链表

  707. 设计链表

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

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


链表的定义


C/C++的定义链表节点方式,如下所示:

// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
    //leetcode定义如下:
    ListNode() : val(0), next(nullptr) {}
    ListNode(int x) : val(x), next(nullptr) {}
    ListNode(int x, ListNode *next) : val(x), next(next) {}
};

C++默认生成一个构造函数。

但是这个构造函数不会初始化任何成员变量,下面我来举两个例子:

通过自己定义构造函数初始化节点:

ListNode* head = new ListNode(5);

使用默认构造函数初始化节点:

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

所以如果不定义构造函数使用默认构造函数的话,在初始化的时候就不能直接给变量赋值!


链表的删除


删除操作记得要进行内存释放

ListNode *tmp = cur->next;
cur->next = cur->next->next;
delete tmp;

性能分析


leetcode刷题记录——链表_第1张图片

141. 环形链表(简单)

142. 环形链表 II(中等)

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

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

不允许修改 链表。

leetcode刷题记录——链表_第2张图片

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

leetcode刷题记录——链表_第3张图片

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

思路1:

  • 哈希表

思路2:

  • 快慢指针;

  • 指针一快一慢同时出发,fastIndex走两格,slowIndex走一格;如果有环,一定会在环里面相遇(可以理解为快的在追慢的);并且相遇时一定是slowIndex首次进入环,fashIndex已经在环内绕了n圈;并有以下条件:

    • fastIndex走的路程是slowIndex的两倍。

    • fastIndex - slowIndex的路程为n倍的环大小。

      • 为什么相遇时一定是slowIndex首次进入环:(临界条件:slowIndex和fastIndex同时同一个节点出发,当fastIndex走完一圈后,slowIndex在半圈,剩下的半圈走完后在起点一定会相遇)

      • leetcode刷题记录——链表_第4张图片

      • 可以看出如果slow 和 fast同时在环入口开始走,一定会在环入口3相遇,slow走了一圈,fast走了两圈。重点来了,slow进环的时候,fast一定是在环的任意一个位置,如图:

      +leetcode刷题记录——链表_第5张图片

      • 那么fast指针走到环入口3的时候,已经走了k + n 个节点,slow相应的应该走了(k + n) / 2 个节点。

        因为k是小于n的(图中可以看出),所以(k + n) / 2 一定小于n。也就是说slow一定没有走到环入口3,而fast已经到环入口3了

    • 作出一下假设(参考:作者:LeetCode-Solution 链接:https://leetcode.cn/problems/linked-list-cycle-ii/solution/huan-xing-lian-biao-ii-by-leetcode-solution/

    • leetcode刷题记录——链表_第6张图片

    • (fast可能走了n圈,但slow一定在第一圈的途中)可以找到a = c+(n−1)(b+c) 的等量关系,我们会发现:从相遇点到入环点的距离加上 n-1圈的环长,恰好等于从链表头部到入环点的距离。

    • 因此找到相遇点后,从b开始往c方向一直走,和从a出发的指针相遇的地方,就是入环口。

  • 图片参考:代码随想录__142-环形链表ii

代码:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(head == nullptr || head -> next == nullptr) return nullptr;
        ListNode *fastIndex = head;
        ListNode *slowIndex = head;
        while(fastIndex != nullptr) {
            if(fastIndex->next == nullptr || slowIndex->next == nullptr) {//双重判断:fastIndex != nullptr和fastIndex->next == nullptr;
                return nullptr;
            }
            //判断条件:fastIndex->next == nullptr 因为fastIndex->next->next放的是null(如果)因此判断fastIndex->next是否存在就行;
            fastIndex = fastIndex->next->next;
            slowIndex = slowIndex->next;
            if(slowIndex == fastIndex) {//如果放外面,第一个while的条件要改,影响第一次的情况和特殊条件下的情况:fastIndex != slowIndex || fastIndex == head;又可能fastIndex一直等于head(两个元素的环);
                ListNode *temp = head;
                while(temp != fastIndex) {
                    fastIndex = fastIndex->next;
                    temp = temp->next;
                }
                return fastIndex;
            }
        }
        return nullptr;
    }
};

来源:力扣(LeetCode)
链接:https://leetcode.cn/problems/linked-list-cycle-ii
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。


203. 移除链表元素(简单)

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

leetcode刷题记录——链表_第7张图片

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

思路1:

  • 从头遍历,遇到val相同就删除;

    • 删除代码:
    ListNode *tmp = cur->next;
    cur->next = cur->next->next;
    delete tmp;
    
  • 遇到的问题:

    • 1、头节点怎么删除?
    • 2、出现报错:member access within null pointer of type ‘ListNode’(注意head != NULL)
  • 解决1:

    • 方法两种;

      • 1、创建虚拟指针,指向头节点,然后可以整个进行遍历,最后再将虚拟指针->next赋值给head;
      /**
       * 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) {
              ListNode *vir = new ListNode(0,head);
              ListNode *cur = vir;
              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 = vir->next;
              delete vir;
              return head;
          }
      };
      
      • 2、单独处理头节点;
      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) {
                      //这里是cur->next为什么不能cur->val == val:因为这样cur不会更新;
                      ListNode *tmp = cur->next;
                      cur->next = cur->next->next;
                      //这里更新的是cur->next;cur->next->val会更新;cur->val不会更新;
                      delete tmp;
                  }
                  else {
                      cur = cur->next;
                  }
              }
              return head;
          }
      };
      

来源:力扣(LeetCode)
链接:https://leetcode.cn/problems/remove-linked-list-elements
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。


206. 反转链表(简单)

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

leetcode刷题记录——链表_第8张图片

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

思路:

  • 用两个指针,分别指向front和behind再用一个temp指针,存behind->next;
  • 双指针同步向前,双指针同步更新;

代码:

/**
 * 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) {
        ListNode *tmp;
        ListNode *front = NULL;
        ListNode *behind = head;
        while(behind != NULL) {
            //相当于判断head是否为NULL;
            tmp = behind->next;
            behind->next = front;
            front = behind;
            behind = tmp;
        }
        return front;
    }
};

代码2:

  • 思路和代码1相同,但是要对head进行处理
  • head->next = NULL;
  • 不然会报错;AddressSanitizer: heap-use-after-free on address 0x602000000078 at pc 0x00000037a94d bp 0x7ffc5a743860 sp 0x7ffc5a743858
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == NULL) return NULL;
        if(head->next == NULL) return head;
        ListNode *pre = head;
        ListNode *next = head->next;
        while(next != NULL) {
            ListNode *tmp = next->next;
            next->next = pre;
            pre = next;
            next = tmp;
        }
        head->next = NULL;
        return pre;
    }
};

21. 合并两个有序链表(简单)

来源:力扣(LeetCode)
链接:https://leetcode.cn/problems/merge-two-sorted-lists
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

leetcode刷题记录——链表_第9张图片

示例 1:
输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]

思路1:

  • 创建一个虚拟表头;然后从list1和list2中挑min(list1->val,list2->val);假设list1->val较小,则虚拟表头指向list1(vir->next = list1);然后虚拟表头(vir)更新为list1;更新list1(list1=list1->next);

    • vir->next = list1;
      vir = list1;
      list1 = list1->next;
      
  • 注意对最后一个节点进行处理;

    • if(list1==NULL) {
          vir->next = list2;
          break;
      }
      if(list2==NULL) {
          vir->next = list1;
          break;
      }
      
  • 因为vir在不断更新,因此可以作为循环条件;

代码:

/**
 * 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* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if(list1 == NULL || list2 == NULL) return list1 == NULL ? list2 : list1;
        ListNode *vir = new ListNode(0);
        ListNode *tmp = vir;
        while(vir!=NULL) {
            if(list1==NULL) {
                vir->next = list2;
                break;
            }
            if(list2==NULL) {
                vir->next = list1;
                break;
            }
            if(list1->val >= list2->val) {
                vir->next = list2;
                vir = list2;
                list2 = list2->next;
            }
            else {
                vir->next = list1;
                vir = list1;
                list1 = list1->next;
            }
        }
        ListNode *head = tmp->next;
        return head;
    }
};
  • 复杂度分析

时间复杂度:O(n + m),其中 n 和 m 分别为两个链表的长度。因为每次循环迭代中,l1 和 l2 只有一个元素会被放进合并链表中, 因此 while 循环的次数不会超过两个链表的长度之和。所有其他操作的时间复杂度都是常数级别的,因此总的时间复杂度为 O(n+m)。

  • 空间复杂度:O(1)。我们只需要常数的空间存放若干变量

作者:LeetCode-Solution
链接:https://leetcode.cn/problems/merge-two-sorted-lists/solution/he-bing-liang-ge-you-xu-lian-biao-by-leetcode-solu/

思路2:

  • 递归
  • 每次判断选择list1还是list2;如果选择list1;则将list1->next传给下一次递归;
  • 相当于每次判断都选择了一个节点;

代码:

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1 == NULL) {
            return l2;
        }
        if (l2 == NULL) {
            return l1;
        }
        if (l1->val <= l2->val) {
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        }
        l2->next = mergeTwoLists(l1, l2->next);
        return l2;
    }
};

作者:z1m
链接:https://leetcode.cn/problems/merge-two-sorted-lists/solution/yi-kan-jiu-hui-yi-xie-jiu-fei-xiang-jie-di-gui-by-/
来源:力扣(LeetCode)
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

707. 设计链表(中等)

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

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

思路:

  • 注意位置;index从0开始;
  • 注意从虚拟节点出发还是从头节点出发:LinkedNode *cur = _dummyHead->next;还是LinkedNode *cur = _dummyHead;
  • 要记录size
  • 区分while(–i)和while(i–)
    • while(–i):先–i然后再判断while
    • while(i–):先i–然后再判断while

代码:

class MyLinkedList {
public:
    struct LinkedNode {
        int val;
        LinkedNode *next;
        LinkedNode(int val):val(val),next(NULL){};
    };

    MyLinkedList() {
        _dummyHead = new LinkedNode(0);
        _size = 0;
    }
    
    int get(int index) {
        if(index < 0 || index > (_size - 1)) 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;
        //有可能只有dummyhead;因此不能LinkedNode *cur = _dummyHead->next;
        while(cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = newNode;
        newNode->next = NULL;
        _size++; 
    }
    
    void addAtIndex(int index, int val) {
        if(index > _size) return;
        if(index < 0) index = 0;
        LinkedNode *newNode = new LinkedNode(val);
        LinkedNode *cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        } 
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }
    
    void deleteAtIndex(int index) {
        if(index < 0 || index >= _size) return;
        LinkedNode *cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        } 
        LinkedNode *tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }
private:
    int _size;
    LinkedNode* _dummyHead;
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

来源:力扣(LeetCode)
链接:https://leetcode.cn/problems/design-linked-list
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。


24. 两两交换链表中的节点(中等)

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

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

思路:

  • 创建虚拟头节点;然后三个三个为一组;
    • 对于[1,2,3,4]这一个示例:

      • 例如第一次;cur->dummyHead;然后使用多一个指针指向3;然后2指向1;1指向3;cur指向2;
      • 第二次时cur指向1;
      • leetcode刷题记录——链表_第10张图片
    • 善于使用虚拟节点,可以减少对头节点特殊情况的处理;

代码:

/**
 * 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* swapPairs(ListNode* head) {
        ListNode *dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode *cur = dummyHead;
        while(cur->next != NULL && cur->next->next != NULL) {
            ListNode *pre = cur->next;
            ListNode *next = cur->next->next;
            ListNode *tmp = next->next;

            next->next = pre;
            pre->next = tmp;
            cur->next = next;

            cur = cur->next->next;
        }
        return dummyHead->next;
    }
};

来源:力扣(LeetCode)
链接:https://leetcode.cn/problems/swap-nodes-in-pairs
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。


19. 删除链表的倒数第 N 个结点(中等)

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

leetcode刷题记录——链表_第11张图片

思路:

  • 使用栈先进后出的特点;倒数第n个就是stack.pop( )n次后stack.top( )元素;
  • 善于使用虚拟节点;

代码:

/**
 * 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* removeNthFromEnd(ListNode* head, int n) {
        stack<ListNode*> s;
        ListNode *dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode *cur = dummyHead;
        while(cur != NULL) {
            s.push(cur);
            cur = cur->next;
        }
        while(n--) {
            s.pop();
        }
        ListNode *prev = s.top();
        ListNode *tmp = prev->next;
        prev->next = tmp->next;
        delete tmp;
        return dummyHead->next;
    }
};

思路2

  • 倒数第n个;可以理解成和最后一个元素相差n个;那么只要定义双指针;先让fastIndex先走n步;然后slowIndex和fastIndex同时开始;当fastIndex到达最后一个指针时;slowIndex指向的下一个节点就是倒数第n个;
  • 还是要创建虚拟节点;

代码:

/**
 * 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* removeNthFromEnd(ListNode* head, int n) {
        if(head == NULL) return NULL;
        ListNode *dummyHead = new ListNode();
        dummyHead->next = head;
        ListNode *slowIndex = dummyHead;
        ListNode *fastIndex = dummyHead;
        while(n--) {
            fastIndex = fastIndex->next;
        }
        while(fastIndex->next != NULL) {
            fastIndex = fastIndex->next;
            slowIndex = slowIndex->next;
        }
        ListNode *tmp = slowIndex->next;
        slowIndex->next = slowIndex->next->next;
        delete tmp;
        return dummyHead->next;
    }
};

你可能感兴趣的:(leetcode,链表,leetcode,数据结构)