专题八_链表_算法专题详细总结

链表

1.常用技巧

1）画图！！！ -> 直观 + 形象 + 便于我们理解

2）引入虚拟“头”节点

1.便于处理边界条件

2.方便我们对链表进行操作

3.不要吝啬空间，大胆定义变量

4.快慢双指针

1.判断链表是否存在环

2.链表中的常用操作

1.创建一个新节点new

2.尾插

3.头插、

1. 两数相加（medium）

解析：

1）暴力：

2）优化：

总结：

2. 两两交换链表中的节点（medium）

解析：

1）暴力：

2）优化：

总结：

3. 重排链表（medium）

解析：

模拟：

第一步：eg：链表1->2->3->4->5

第二步：

第三步：

总结：

4. 合并 K 个升序链表（hard）

解析：

1）暴力：

2）优化：

1）大小堆：

2）分治_归并

步骤：

总结：

5. K个⼀组翻转链表（hard）

解析：

模拟：

那么这里就要补充一个狠狠狠重要的只是点了，三指针翻转链表：

总结：

链表

1.常用技巧

1）画图！！！ -> 直观 + 形象 + 便于我们理解

2）引入虚拟“头”节点

1.便于处理边界条件

2.方便我们对链表进行操作

要考虑很多的边界条件

3.不要吝啬空间，大胆定义变量

4.快慢双指针

1.判断链表是否存在环

找到链表的入口

找到链表中倒数第n个节点

2.链表中的常用操作

1.创建一个新节点new

2.尾插

3.头插、

链表逆序，用头插贼方便，创建一个虚拟头节点，进行遍历就可以逆序。

那么就进入例题吧：

1. 两数相加（medium）

本题题意比较简单，意思就是两个已经被反转的链表只要直接相加即可，返回其相加后的链表，这里要注意的就是进位操作。

解析：

1）暴力：

我第一次做的时候，确实是个小白，什么都不会，将所有数字都存入字符串内，然后进行相加，也要考虑进位，或许将字符串转成int类型然后相加，在to_string()转成字符串也可以，但是这样太太太麻烦了。挺锻炼代码能力的，有兴趣可以试试。

2）优化：

在两个链表上设置移动指针cur1和cur2，然后设置进位next，在while里面判断cur1 和 cur2 是否为空，或者next是否存在进位，但凡有一个满足条件就能继续相加，添加到新链表的后端。这里注意的是，链表不一样长，那么就为了避免访问空指针的情况，就要先判断cur1==nullptr 和 cur2==nullptr，那么在这种情况下下，如果为空，就说明该链表已经遍历完，+0即可。

这里的进位需要注意的是先算出sum的总数，然后添加到链表的是sum%10 的余数，next表示进位，就让sum/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* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* head=new ListNode();
        ListNode* l=head;
        int next=0;
        while(l1||l2||next)
        {
            int sum=(l1?l1->val:0)+(l2?l2->val:0)+next;
            head->next=new ListNode(sum%10);
            next=sum/10;
            
            if(l1) l1=l1->next;
            if(l2) l2=l2->next;
            head=head->next;
        }
        return l->next;
    }
};

总结：

两个链表相加考虑进位，其实是挺简单的链表操作，可以直接在原链表上操作，一定要想清楚再写代码，这样负担很小，不要直接上手就写，但凡有一点思路不清楚就去画图！！！

2. 两两交换链表中的节点（medium）

题意很简单，两两交换链表间的节点，比如【1，2】【3，4】【5，6】等等，没有重复的节点，那么就要考虑的是，交换之后，怎么有链接回原来的链表。

解析：

1）暴力：

就是创建新的链表，然后分奇偶添加，但是这题不让创建新的链表。

2）优化：

这题实质就是模拟，再原链表上进行交换，那么只需要考虑的是原链表上交换的节点，又要连接到原链表上，就是要创建新的指针指向节点，这样交换后就不会存在节点丢失的情况。

那么本题就是两个节点间的交换，实质就是创建三个指针指向两个节点和交换后要链接的原链表上的节点。设置prev=head ，now=head->next，next=now->next;

这里专门设置了一个虚拟头节点，是为了能让反转的链表重新连接回来，其实这里也可以选择设置四个指针，再指向next后面的一个节点。这样就可以无脑交换连接，是不是很简单。这里就是要注意的是不要吝啬空间，想创建指针就创建，这样不会存在找不到原链表的情况。

两两交换完后，那么这三个指针就再次往后移动，让prev移动到被交换后的最后一个节点，这样能保证prev再次充当虚拟头节点。

/**
 * 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* l) {
        ListNode* head=new ListNode();
        head->next=l;
        ListNode* prev=head;
        ListNode* now=head->next;
        ListNode* next=nullptr;
        if(now) next=now->next;

        ListNode* l1=head;
        
        while(now!=nullptr&&next!=nullptr)
        {
            now->next=next->next;
            prev->next=next;
            next->next=now;

            prev=now;
            now=prev->next;
            if(now)
            next=now->next;
        }
        return l1->next;
    }
};

总结：

关于在原链表内进行交换节点，那么就要考虑三个指针的遍历指向链表上的节点，然后进行无脑交换就OK，这样不用担心创建的新链表不会链接不上的问题。

3. 重排链表（medium）

题意比较简单就是模拟问题，重新排列这个链表

解析：

模拟：

第一步：eg：链表1->2->3->4->5

当都设指针prev和cur开始从第一个节点开始走，让cur先手走两步，prev走一步，达到快慢指针的目的，就能证明在cur走到链表尽头的时候，prev正好在链表的中间节点。

那么此时就将链表分开，形成两段链表。

eg:链表1->2->3->4->5

形成：h1->1->2;

h2->3->4->5;

第二步：

翻转h2->3->4->5;

h2->5->4->3;

我这里单独创建了一个翻转链表的函数，还是比较简单的，利用头插法，新界一个头节点，然后进行头插，自然就反转了链表。

第三步：

然后模拟h1 和 h2 交换链接的过程，h->1->5->2->4->3,即可。

模拟两个链表相互交换的过程，合并两个链表，不用吝啬空间，直接上去每个链表创建虚拟头节点，然后进行交换相连，然后再将三个指针往前移动即可。直到最后若存在没有被遍历完的节点直接连接到最后即可。

/**
 * 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:
    void reorderList(ListNode* l) {
        //将l分成两段链表
        //快慢双指针记录
        ListNode* cur=l,*prev=l;

        //prev停的位置就是链表的中点
        while(cur)
        {
            cur=cur->next;
            if(cur) cur=cur->next;
            prev=prev->next;
        }
        cur=l;
        while(cur->next!=prev)
            cur=cur->next;cur->next=nullptr;
 
        //创建两个链表 h1,h2;
        ListNode* h1=new ListNode(),*h2=new ListNode();
        h1->next=l;
        h2->next=prev;

        ListNode* t=h1->next;
        while(t)
        {
            cout<<t->val<<" ";
            t=t->next;
        }
        cout<<endl;


        ListNode* e=h2->next;
        while(e)
        {
            cout<<e->val<<" ";
            e=e->next;
        }      
        cout<<endl;

        //翻转链表(头插法)
        h2=turnlist(h2);  

         e=h2->next;
        while(e)
        {
            cout<<e->val<<" ";
            e=e->next;
        }      
        cout<<endl;
        

        //合并链表
        ListNode* r1=h1->next,*r2=nullptr; if(r1) r2=r1->next;
        ListNode* r3=h2->next,*r4=nullptr; if(r3) r4=r3->next;
        while(r1)
        {
            r1->next=r3;
            r1=r2;
            if(r2)
            r2=r2->next;
            if(r3)
            r3->next=r1;
            r3=r4;
            if(r4)
            r4=r4->next;
        }

    }

    ListNode* turnlist(ListNode* h)
    {
        ListNode* l1=h->next;
        ListNode* l=new ListNode();
        ListNode* l2=l;
        while(l1)
        {
            ListNode* newnode=new ListNode(l1->val);
            newnode->next=l->next;
            l->next=newnode;
            l1=l1->next;
        }
        return l2;

    }


};

总结：

这题确实很锻炼代码的模拟能力，十分推荐自己动手敲一遍。

4. 合并 K 个升序链表（hard）

题意很简单合并k个升序链表

解析：

1）暴力：

创建一个链表然后两两进行合并，每次两个链表都进行每个节点判断大小，小的添加到链表上，但是这样时间复杂度肯定很高，并且很麻烦，不过十分锻炼代码能力跟上题一样，有时间可以试试。

2）优化：

1）大小堆：

其实能想到用堆，优先级队列，这题是真简单，直接ac，属于秒杀题了，leetcode真是分不清，有些中等题难的要死。

这题如果用优先级队列，priority_queue(head->val),这里是大根堆，如果不进行翻转priority_queue(head->val,vector<int>,greater<int>) 小根堆的话，那么大根堆就进行头插，这样就可以保证完全有序，然后再插入新的链表，完成一个完整的新链表的创建。

总结：这里我之前用过set，虽然能排序，但会去重，我就又去multiset不会去重，但是每次删除的时候都会把所有相同的元素全都删除，那么唯一满足条件的就是优先级队列了priority_queue。

/**
 * 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* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<int> q;
        int n=lists.size();
        for(int i=0;i<n;i++)
        {
            ListNode* cur=lists[i];
            while(cur)
            {
                q.push(cur->val);
                cur=cur->next;
            }
        }

        ListNode* head=new ListNode();
        while(!q.empty())
        {
            ListNode* newnode=new ListNode(q.top());
            q.pop();
            newnode->next=head->next;
            head->next=newnode;
        }
        return head->next;
    }
};

2）分治_归并

这种思想就是让数组一直细分，一直细分到最后，然后向上进行归并，根上一个专题介绍的一模一样，代码模板简直都是一模一样的，一定要取尝试一下。

步骤：

1.传送区间范围，计算中间值

2.递归左右两边

3.一左一右，合并两个链表

4.进行合并

/**
 * 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* mergeKLists(vector<ListNode*>& lists) {
        return mergeSort(lists,0,lists.size()-1);
    }
    ListNode* mergeSort(vector<ListNode*>& lists,int left,int right)
    {
        if(left>right) return 0;
        if(left==right) return lists[left];

        //计算中间值
        int mid=(left+right)>>1;

        //数组分两块【left,mid】 【mid+1,right】
        ListNode* l1=mergeSort(lists,left,mid);
        ListNode* l2=mergeSort(lists,mid+1,right);

        //合并两个链表
        return mergeTowlist(l1,l2);
    }

    ListNode* mergeTowlist(ListNode* l1,ListNode* l2)
    {
        ListNode* head=new ListNode();
        ListNode* cur1=l1,*cur2=l2,*prev=head;

        while(cur1&&cur2)
        {
            if(cur1->val<=cur2->val)
            {
                prev=prev->next=cur1;
                cur1=cur1->next;
            }
            else 
            {
                prev=prev->next=cur2;
                cur2=cur2->next;
            }
        }

        if(cur1) prev->next=cur1;
        if(cur2) prev->next=cur2;

        return head->next;
    }
    
};

总结：

本题有很多种办法，这里两种优化的方法都推荐取试试，真的写的很爽。

5. K个⼀组翻转链表（hard）

题意很简单理解，就是不停的翻转k个节点

解析：

模拟：

其实这就是简单的模拟题，思想挺简单的，有点暴力内味hhh~

就是开头遍历节点个数，然后计算count得出要经过多少次循环，每次循环都进行k个节点的翻转就ok，真的挺简单的，那么主要就是进行链表的翻转，然后再重新接回来。

开始我想到挺简单的，创建新的链表，然后进行链接，就是采用头插法，本来挺成功的，就这里卡了我一个小时，各种调试都没过，最后还是去看题解了，才发现用头插法连接到原链表上居然失效了，只能再原链表上直接进行翻转。

那么这里就要补充一个狠狠狠重要的只是点了，三指针翻转链表：

三指针原链表反转：
步骤：
1.node=prev->next；用node来记录当前节点的下一个节点，这样在反转后能够找到下一个节点
2.prev->next=head ; 让当前节点指向head，head就相当于一个标记节点表示反转链表的头部
3.head=prev; 每次反转成功后，head都往后移动到prev的位置，重新表示反转链表的头部
4.prev->next=node; 然后进入下一轮反转，要prev再次表示当前节点，就重新指向node

那么每次传入区间内的链表的节点，只要实现这三指针，就可以完美的完成链表的原地翻转，妈妈再也不用担心浪费空间了~

/**
 * 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* chang(ListNode* prev, ListNode* cur)
{
	ListNode* node=nullptr,*head=nullptr;
    while(prev!=cur)
    {
        node=prev->next;
        prev->next=head;
        head=prev;
        prev=node;
    }
    return head;
}


ListNode* reverseKGroup(ListNode* l, int k) {
	ListNode* head = new ListNode();
	head->next = l;
	ListNode* cur = head->next, * prev = head;
	int n = 0;
	while (prev->next) prev = prev->next, n++;
	int count = n / k;
	prev = head;
		
	while (count--)
	{
		ListNode* next = prev->next;
		for (int e = 0; e < k && cur != nullptr; e++) cur = cur->next;
		prev->next = chang(prev->next, cur);
		next->next = cur;
		prev = next;
	}



	return head->next;
}
};