代码随想录链表篇

代码随想录链表篇

1.链表的形式

1.1单链表

​ 一个结点分为数据域存放data和指针域存放next。单链表的头结点地址一般会有一个头指针head保存。在刷题时要注意指针head只是一个指针，并不是一个结点，没有数据域和指针域，尾部结点指向NULL。

//单链表结点定义形式
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) {}
}

1.2双链表

双链表的结点比单链表结点多了一个pre指针域，指向上一个结点。依然有一个head指针指向头结点。头结点的pre指针和尾部结点的next指针指向NULL。

//双链表结点定义形式
struct ListNode{
    int val;
    ListNode* pre;
    ListNode* next;
    ListNode():val(0),next(nullptr),pre(nullptr){}
    ListNode(int x):val(x),next(nullptr),pre(nullptr){}
    ListNode(int x, ListNode *next) : val(x), next(next),pre(nullptr) {}
    ListNode(int x, ListNode *next,ListNode *pre) : val(x), next(next),pre(pre) {}
}

1.3循环链表

循环链表头尾相接，结点类型与单链表一致，可以用来解决约瑟夫环问题。循环链表结点定义形式同单链表。

1.4常见链表操作

1.4.1删除结点

​ 将C结点的next指针指向结点E，并释放结点D的内存。但是在JAVA、python等其他具有自己的内存管理机制的语言中，不用手动释放。

//需要删除的为结点D
ListNode* temp=D;//记录下结点D的位置
C->next=C->next->next;
delete temp;//释放结点D内存

1.4.2添加结点

//	需要先查找到结点C所在位置
ListNode* F=NEW ListNode(0);
F->next=C->next;
C->next=F;

1.5性能分析

​ 因为链表的插入和删除操作是已经知道了前一个结点，因此事件复杂度为O(1),但是在不知道的情况下需要先查找，那样时间复度为O(N)。

2. 203移除链表元素

（题意：删除链表中等于给定值 val 的所有节点。）

https://leetcode-cn.com/problems/remove-linked-list-elements/

/*
	法1，原链表上删除。分为两种情况，一种为不改变头结点，一种为删除头结点的位置
	原题给定了头结点head和val。注意是头结点不是头指针。
*/
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
    if(!head)
      return NULL;//上面两行可以去掉，但是会减慢速度
	 while( head !=NULL && head->val==val ){//两个判断不能调换位置
     	ListNode* temp=head;
        head=head->next;
        delete temp;
    }//此步结束后，链表头结点不可能等于val
    ListNode* cur=head;
     while(cur!=NULL  && cur->next!=NULL)
     {
         if(cur->next->val==val)
         {
          	ListNode* temp=cur->next;
        	cur->next=cur->next->next;
        	delete temp;
         }
         else
             cur=cur->next;
     }
     return head;  
}
};

/*法2 虚拟头结点*/
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
    ListNode dummy(0);
    dummy.next=head;
    ListNode* cur=&dummy;
    //另外一种写法
    /*
  		ListNode dummy=new ListNode(0);
        dummy->next=head;
        ListNode* cur=dummy;
    */
    while(cur!=NULL && cur->next!=NULL)
    {
        if(cur->next->val==val)
        {
            ListNode* temp=cur->next;
            cur->next=cur->next->next;
            delete temp;
        }
        else
         cur=cur->next;
    }
    head=dummy.next;//关键
    return head;
}
};

3. 707设计链表

题目链接：https://leetcode-cn.com/problems/design-linked-list/

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

  class MyLinkedList {
  public:
   
  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(nullptr){}
  };
      MyLinkedList() {//创建一个空的链表
      size=0;
       head=new ListNode(0);//创建一个新的结点，存放头指针，不是头结点
      }
      
     
    
    int get(int index)//第0个结点是头结点
    {
        if(size == 0 || index >(size-1) ||index <0)//无用的index直接return 
           return -1;
      ListNode * cur=head->next;//指向头结点
       while(index--){ // 如果--index 就会陷入死循环
              cur = cur->next;
          }
          return cur->val;
    }
    
      
      void addAtHead(int val) {
      ListNode* headTemp=new ListNode(val);
      headTemp->next=head->next;//headTemp指向原先的头结点
      head->next=headTemp;//头指针指向现在的头结点
      size++;
      }
      
  
      void addAtTail(int val) {
          ListNode* TailNode=new ListNode(val);
  
          ListNode* cur=head;//头指针
          while( cur->next!=NULL)
              cur=cur->next;//指向最后一个结点
          cur->next=TailNode;
          TailNode->next=NULL;
          size++;
      }
      
      void addAtIndex(int index, int val) {
      if(index<0 || index>size)
          return ;
      //找到前一个结点
      if(index==0)//这段可以不用
      {
          ListNode* temp=new ListNode(val);
          temp->next=head->next;
          head->next=temp;
          size++;
          return;
      }
      ListNode* cur=head;
      while(index-- && cur!=NULL)
          cur=cur->next;
      ListNode* temp=new ListNode(val);
      temp->next=cur->next;
      cur->next=temp;
      size++;
      }
  
      void deleteAtIndex(int index) {
          if(index<0 || index>=size)
              return ;
          ListNode* cur=head;
          while(index-- && cur!=NULL)
              cur=cur->next;
          ListNode* temp=cur->next;//从这段看出cur->next不为Null
          cur->next=cur->next->next;
          delete temp;
          size--;
      
  
      private:
      int size;
      ListNode* head;//head作为头指针
  };
  
  /**
   * 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);
   */
  

4. 206反转链表

https://leetcode-cn.com/problems/reverse-linked-list/

题意：反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

 /*法1 双指针法，给了头结点*/
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
    //头结点会指向null
    ListNode* pre=NULL;//后一指针
    ListNode* cur=head;
    while(cur!=NULL)
    {
        ListNode* temp=cur->next;
        cur->next=pre;
        pre=cur;
        cur=temp;
    }
    head=pre;
    return head;
}
};

//法2 递归法，本质相同
class Solution {
public:
ListNode* back(ListNode* pre,ListNode* cur)
{
    if(cur==NULL)
        return pre;
    ListNode* temp=cur->next;
    cur->next=pre;
    return back(cur,temp);
}
ListNode* reverseList(ListNode* head) 
{
  ListNode* pre=NULL;
  ListNode* cur=head;
  head=back(pre,cur);
  return head;
}
};

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

题目链接：https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/

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

我的思路：先遍历一边链表，得到链表的长度size，在这之后可以计算倒数第N个节点即是顺数size-n+1个节点,所以需要找到第size-n个结点。但是这样需要先遍历一边链表，事件复杂度较高。

代码随想录双指针法思路：

fast首先走n + 1步 ，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作），实质便是原先fast指针已走出了n+1步，剩余当fast走到NULL时，slow指针还能走size-n步，刚好走到待删除结点的上一个结点，如图：

删除slow指向的下一个节点，如图：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
    //定义两个指针fast slow,最好使用虚拟头结点
    ListNode* dummy=new ListNode(0);
    dummy->next=head;
    ListNode* fast=dummy;
    ListNode* slow=dummy;
    n++;
    while(n-- && fast!=NULL)
        fast=fast->next;
    while(fast!=NULL)
    {
        slow=slow->next;
        fast=fast->next;
    }
    ListNode* temp=slow->next;
    slow->next=slow->next->next;
    delete temp;
    head=dummy->next;
    delete dummy;
    return head;
    }
};

6. 面试题 02.07 链表相交

题目链接：https://leetcode-cn.com/problems/intersection-of-two-linked-lists-lcci/

以下为题目描述：

实际上此题就是简单的判断两条链表有无指针相等。

我的思路：两重循环，两个指针分别指向两个链表，一个指针不动，遍历另外一个数组。但是此方法在最差的情况下若仅链表尾部相交，若链表长度分别为m,n，那么时间两重循环时间复杂度达到O(m*n)，时间复杂度高

代码随想录思路：得到两条链表长度，定义两个指针，短链表从头结点开始，长链表从第m-n个结点开始，分别移动指针，直至相等或到达NULL

//两重循环
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
ListNode* temp=headA;
      while(headB!=NULL)
      {
          while(headA!=NULL)
          {
              if(headA==headB)
                return headA;
              else
                 headA=headA->next;
          }
          headA=temp;
        headB=headB->next;
      }
      return NULL;
        
    }
};

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != NULL) { // 求链表A的长度
            lenA++;
            curA = curA->next;
        }
        while (curB != NULL) { // 求链表B的长度
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            swap (lenA, lenB);
            swap (curA, curB);
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap--) {
            curA = curA->next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

7. 142环形链表II

https://leetcode-cn.com/problems/linked-list-cycle-ii/

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

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

主要考察两知识点：

• 判断链表是否环
• 如果有环，如何找到这个环的入口

---

判断链表是否环

可以使用快慢指针法， 分别定义 fast 和 slow指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。

为什么fast 走两个节点，slow走一个节点，有环的话，一定会在环内相遇呢，而不是永远的错开呢

并且fast指针走两步,slow走一步，相当于若是有环的话，fast指针在一步步的追赶slow(套圈),并且肯定不会跳过。

首先第一点：fast指针一定先进入环中，如果fast 指针和slow指针相遇的话，一定是在环中相遇，这是毋庸置疑的。

可以画一个环，然后让 fast指针在任意一个节点开始追赶slow指针。

会发现最终都是这种情况， 如下图：

当然若是fast先等于NULL，即fast和slow不会相等，那样就没有环

那么来看一下，为什么fast指针和slow指针一定会相遇呢？

以下是3个环展平的状态，当slow指针进入环中时,slow指针肯定在环1和环2之间，那样，fast指针肯定先于slow指针进入第三个环中，最差情况也是同时进入，那样slow指针肯定没有走完一整个环。

如何找到环入口

因为上文所述，slow会在第一圈与fast指针相遇，那样x,y,z的关系为：2(x+y)=x+y+n(y+z)(这里的n其实为1)（在其他情况中n可能不为1）

化简可得：x+y=n(y+z),得到x=(n-1)y+n*z。n=1时，x=z。即若在头节点处和两个指针相遇处定义两个指针index1和index2，那样若同时往前走，当指针相等时便是环形入口节点。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
         //先判断是否为环，利用快慢指针，快指针一次走两步，慢指针一次走一步，当快慢指针相等的时候，那样，说明肯定有环
   ListNode* fast=head;
   ListNode* slow=head;
   ListNode* index;
   
   while(fast!=NULL  &&fast->next!=NULL   )//如果是环那么迟早会相遇，不是环也会退出
   {
       fast=fast->next->next;
       slow=slow->next;
       if(fast==slow)
       {
          index=fast; //相遇位置定义一个指针，此位置与头结点同时向前单步走，最后会在环的入口处相遇
          while(head!=index)
         {
             head=head->next;
             index=index->next;
         }
        return head;
      }
   }
   return NULL;
    }
};