一、链表的常见技巧总结

二、两数相加

. - 力扣（LeetCode）

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
     //利用t来存进位信息
     int t=0;
     ListNode*newhead=new ListNode(0);//创建一个哨兵节点，方便尾插
     ListNode*ptail=newhead;//ptail方便尾插
     ListNode* cur1=l1,*cur2=l2;
     while(cur1||cur2||t==1)//t==1防止后面有进位没加上
     {
        if(cur1)  {t+=cur1->val; cur1=cur1->next;}
        if(cur2)  {t+=cur2->val;cur2=cur2->next;}
        ptail->next=new ListNode(t%10);
        ptail=ptail->next;
        t/=10;
     }
     ListNode*ret=newhead->next;
     delete newhead;
     return ret;
    }
};

 三、两两交换链表中的节点

 四、重排链表

. - 力扣（LeetCode）

class Solution {
public:
    void reorderList(ListNode* head) 
    {
      //方法1，利用一个数据结构将每个节点存起来，通过下标去访问
      //方法2, （1）利用快慢指针，找中点 （2） 拆开链表 从中点开始往后翻转 （3）进行合并成新链表
      if(head==nullptr||head->next==nullptr||head->next->next==nullptr) return;
      ListNode*mid=midnode(head);//找到中间节点
      //断开链表
      ListNode*l1=head;
      ListNode*l2=mid->next;
      mid->next=nullptr;
      //然后反转2
      l2=reverseList(l2);
      //合并链表
      mergeList(l1,l2);
    }

    ListNode*midnode(ListNode* head)
    {
       ListNode*fast=head;
       ListNode*slow=head;
       while(fast->next!=nullptr&&fast->next->next!=nullptr)//确保后面两步能走
       {
        fast=fast->next->next;
        slow=slow->next;
       }
       return slow;//此时慢指针指向的就是最小的节点
    }

     ListNode* reverseList(ListNode* head)
     {
        ListNode*p1=nullptr;
        ListNode*p2=head;
        ListNode*p3=head->next;//记录下一个要遍历的点
        while(p2)
        {
            p2->next=p1;
            p1=p2;
            p2=p3;
            if(p3) p3=p3->next ;
        }
        return p1;
     }

     void mergeList(ListNode* l1, ListNode* l2)
     {
        ListNode* temp1,*temp2;
        while(l1!=nullptr&&l2!=nullptr)
        {
            temp1=l1->next;
            temp2=l2->next;
            l1->next=l2;
            l1=temp1;//回到原链表0
            l2->next=l1;
            l2=temp2;//回到原链表
        }
     }
};

五、合并k个升序链表

. - 力扣（LeetCode）

 优先级队列：

class Solution {
public:
   //建小堆需要greater
   struct greater //构造一个仿函数
   {
      bool operator()(const ListNode*l1,const ListNode*l2)
      {
        return l1->val>l2->val;
      }
   };

    ListNode* mergeKLists(vector<ListNode*>& lists) 
    {
      //建立优先级队列（小堆）,每次将堆顶元素插入进去，然后再删除堆顶元素，插入下个位置
       priority_queue<ListNode*,vector<ListNode*>,greater> heap;//建立一个小堆
       //入堆
       for(auto l:lists) if(l) heap.push(l);//因为有可能里面存的是一个空链表
       //开始合并k个有序链表
       ListNode*newnode=new ListNode(0);
       ListNode*ptail=newnode;//用于帮助我们进行尾插
       while(!heap.empty())
       {
        //进行尾插
        ListNode*it=();
         ptail->next=it;
         ptail=it;//去到下一个位置准备尾插
         //删除堆顶元素并将该节点的下一个节点入堆 ，为空就不入
        heap.pop();
        if(it->next) heap.push(it->next);
       }
       //此时全部的元素都插入完成了，返回最终的链表
       ListNode*ret=newnode->next;
       delete newnode;
       return ret;
       //时间复杂度o（n*k*logk）
    }
};

分治思想：

//策略，利用递归解决问题，结合归并排序，合并两个有序链表  (利用分治思想)
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists)
    {
        int n=lists.size();
        return merge(lists,0,n-1);//让merge帮助我们完成整个区间的归并
    }
    
    ListNode* merge(vector<ListNode*>& lists,int left,int right)
    {
        //首先，处理边界情况，如果不存在链表或者是只有一个链表，此时没有必要进行下去
        if(left>right) return nullptr;
        if(left==right) return lists[left];
        //让merge帮助我们归并左右区间
        int mid=(left+right)>>1;
        ListNode*l1=merge(lists,left,mid);
        ListNode*l2=merge(lists,mid+1,right);
        //然后开始进行合并两个有序链表
        return mergetwolist(l1,l2);
    }

    ListNode*mergetwolist(ListNode*l1,ListNode*l2)
    {
       //考虑两个链表为空的情况
       if(l1==nullptr) return l2;
       if(l2==nullptr) return l1;
       //此时两个链表必然不为空，开始进行合并
       ListNode*newhead=new ListNode(0);//哨兵节点
       ListNode*ptail=newhead;//帮助我们进行尾插
       ListNode*cur1=l1,*cur2=l2;//两个指针分别指向两个链表
       while(cur1&&cur2)//当两个都不为空的时候
       {
         if(cur1->val<cur2->val) 
         {
            //此时要尾插cur1
             ptail->next=cur1;
             ptail=cur1;//更新到下一个位置
             cur1=cur1->next;//继续去下一个节点遍历
         }
         else
         {
             ptail->next=cur2;
             ptail=cur2;//更新到下一个位置
             cur2=cur2->next;//继续去下一个节点遍历
         }
       }
       //可能有的链表没有遍历完
       if(cur1) ptail->next=cur1;
       if(cur2) ptail->next=cur2;
       //此时返回到目标的位置
        ListNode*ret=newhead->next;
        delete newhead;
        return ret;
    }
};

六、k个一组翻转链表

. - 力扣（LeetCode）

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) 
    {
       int n=0;//记录总数
       ListNode*cur=head;
       while(cur)//统计节点个数，并推测有多少组
       {
        cur=cur->next;
        ++n;
       }
       n/=k;//看看一共需要几组
       ListNode*newhead=new ListNode(0);//创建一个哨兵节点
       ListNode*prev=newhead;//记住被头插的点
       cur=head;//从head开始进行头插
       //翻转n组，每组翻转k个
       for(int i=0;i<n;++i)
         {
            ListNode*temp=cur;
            for(int j=0;j<k;++j)
            {
                //用头插的逻辑
                ListNode*next=cur->next;;
                cur->next=prev->next;
                prev->next=cur;
                cur=next;//继续去链表的下一个点
            }
            prev=temp;//更新prev
         }
         //循环结束后，将后面的不需要逆序的部分接上
         prev->next=cur;
         ListNode*ret=newhead->next;
         delete newhead;
         return ret;
    }
};

七、旋转链表

. - 力扣（LeetCode）

思路1：截断再连接

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) 
    {
       //让链表成环(闭合成环)，然后在指定位置断开
       if(head==nullptr||head->next==nullptr||k==0) return head;
       int count=1;//数节点数量
       ListNode*ptail=head;
       while(ptail->next!=nullptr) //找到尾节点,并统计节点数
       {
        ptail=ptail->next;
        ++count;
       }
        int add=count-k%count;//看看具体是翻转几次
        if(add==count) return head;//避免不需要翻转的情况
       //截断重连
       ListNode*cur=head;
       while(--add) cur=cur->next; //找到被截断的位置
       ListNode*ret=cur->next;
       cur->next=nullptr;//断开
       cur=ret;
       while(cur->next!=nullptr) cur=cur->next;//找到尾节点
       cur->next=head;//连接
       return ret; 
    }
};

思路2：链表成环，指定位置截断

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) 
    {
       //让链表成环，然后在指定位置断开
       if(head==nullptr||head->next==nullptr||k==0) return head;
       int count=1;//数节点数量
       ListNode*ptail=head;
       while(ptail->next!=nullptr) //找到尾节点,并统计节点数
       {
        ptail=ptail->next;
        ++count;
       }
        int add=count-k%count;//看看具体是翻转几次
        ptail->next=head;//头尾相连
        while(add--) ptail=ptail->next;
        ListNode*ret=ptail->next;
        ptail->next=nullptr;
        return ret; 

    }
};

思路3：逆置前n-k个，再逆置后k个，最后整体逆置

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) 
    {
        if(head==nullptr||head->next==nullptr||k==0) return head;
       //先逆置前n-k个，再逆置后k个，再整体逆置
         int count=1;//数节点数量
         ListNode*ptail=head;
       while(ptail->next!=nullptr) //找到尾节点,并统计节点数
       {
        ptail=ptail->next;
        ++count;
       }
        int add=count-k%count;//看看具体是翻转几次
        if(add==count) return head;
        //开始找前n-k个节点
        ListNode*cur=head;
        while(--add) cur=cur->next;
         ListNode*l2=cur->next;//第二个链表
         cur->next=nullptr;//断开
          ListNode* l1=reverse(head);
          l2=reverse(l2);
          head->next=ptail;//连接起来
          return reverse(l1);//然后整体翻转
    }

    ListNode*reverse(ListNode* head)
    { //只有一个节点，没什么好逆置的
        if(head==nullptr||head->next==nullptr) return head;
        ListNode*p1=nullptr,*p2=head,*p3=head->next;
        while(p2)
        {
           p2->next=p1;
           p1=p2;
           p2=p3;
           if(p3) p3=p3->next;
        }
        return p1;
    }
};