力扣 剑指offer中链表题解法思路总结

这几天把剑指offer题库中的链表题刷了一遍，总结了下链表题常见的解法思路。
对每个常见的解法举典型例子展示下。

双指针法

剑指offer22 链表中倒数第K个节点
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。
示例：
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.

该题最简单的方法时先遍历一遍计算下节点数，在遍历到倒数第K个节点输出后序节点。
而双指针解法的思想在于，虽然我们不知道节点总数但我们知道需要输出的节点数目，我们可以使用前后两个相差K-1的指针同时向后遍历，当前指针到达尾节点时，后节点刚好到达倒数第K个节点。

class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        ListNode* list1,* list2;
        list1 = head;
        list2 = head;
        for(int i = k-1;i>0;i--)
            list1 = list1->next;
        while(list1->next != NULL)
        {
            list1 = list1->next;
            list2 = list2->next;
        }
        return list2;
    }
};

递归法

剑指offer24 反转链表
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
限制：
0 <= 节点个数 <= 5000

反转链表这种需要先处理后面的问题很自然的就想到能不能使用递归方法。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
    if(head == NULL || head->next == NULL)
        return head;
    ListNode *tail = reverseList(head->next);
    head->next->next = head;
    head->next = NULL;
    return tail;
    }
};

此代码中重点语句是head->next->next = head;
具体分析可以查看https://blog.csdn.net/Aquaman_/article/details/108412495

迭代法

迭代法就是利用链表的链式结构一步一步向后迭代实现所要求的内容。

剑指offer 25 合并两个排序的链表
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
示例1：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
限制：
0 <= 链表长度 <= 1000

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
     	//定义哨兵节点
        ListNode* dummy = new ListNode(-1); 
        ListNode* cur = dummy;
        while(l1 && l2) {
        	//加入节点l1
            if(l1->val < l2->val) {
                cur->next = l1;
                l1 = l1->next;
            }
            //加入节点l2
            else {
                cur->next = l2; 
                l2 = l2->next; 
            }
            cur = cur->next; 
        }
        //加入剩余节点
        cur->next = l1 == NULL ? l2 : l1; 
        return dummy->next;
    }
};

利用栈、map、vector、哈希表等数据结构的方法。

根据栈先进后出，哈希表的哈希映射，map的键值对等等特点可以很好的解决一些特定问题。

剑指offer 35 复杂链表的复制
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。
示例：

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]
提示：
-10000 <= Node.val <= 10000
Node.random 为空（null）或指向链表中的节点。
节点数目不超过 1000 。
处。

本题涉及到链表的深拷贝，比较麻烦的是random指针的存在。此时就可以使用map这种数据结构来帮助我们是实现拷贝。
C++中有三种类型的map:

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(logn)	O(logn)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(logn)	O(logn)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

因为我们主要是查找next、random节点，所以我们用底层是哈希表实现的unordered_map。

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == NULL)return head;
        unordered_map<Node*,Node*>map;
        Node * list = head;
        while(list != NULL)
        {
            map[list] = new Node(list->val);
            list = list->next;
        }
        list = head;
        while(list != NULL)
        {
            if(list->next)
            {
                map[list]->next = map[list->next]; 
            }
            if(list->random)
            {
                map[list]->random = map[list->random];
            }
            list = list->next;
        }
        return map[head];
    }
};

unordered_map<node*,node*>map,实现的是复制与深拷贝后节点的一一对应。
刚开始的深拷贝，将原先的节点深拷贝后的儿子放入map与其父亲一一对应
    map[list]=new Node(list->val);
next与random指针的复制对应关系:
    map[list]->next=map[list->next];
    map[list]->random=map[list->random];
此问题除了利用map来实现外，还有一个很巧妙地方法
拆分法

class Solution {
public:
	Node *copyRandomList(Node *head) {
	    if (head == nullptr) return head;
	    copyNodes(head);
	    connectRandomNode(head);
	    return splitCopyNodeList(head);
	}
	void copyNodes(Node *head) {//复制节点并将复制节点连接到原节点后
	    Node *node = head;
	    while (node != nullptr) {
	        Node *copyNode = new Node(0);
	        copyNode->val = node->val; 
	        copyNode->next = node->next;
	        copyNode->random = nullptr;
	        node->next = copyNode;
	        node = copyNode->next;
	    }
	}
	void connectRandomNode(Node *head) {//连接random指针
	    Node *node = head;
	    while (node != nullptr) {
	        Node *copyNode = node->next;
	        if (node->random != nullptr) {
	            copyNode->random = node->random->next;
	        }
	        node = copyNode->next;
	    }
	}
	
	Node *splitCopyNodeList(Node *head) {//拆分链表
	    Node *node = head;
	    Node *copyHead = node->next;
	    Node *copyNode = copyHead;
	    node = copyNode->next;
	    while (node != nullptr) {
	        copyNode->next = node->next;
	        copyNode = copyNode->next;
	        node->next = copyNode->next;
	        node = node->next;
	    }
	    return copyHead;
	}
};

https://leetcode-cn.com/problems/fu-za-lian-biao-de-fu-zhi-lcof/solution/fu-za-lian-biao-de-fu-zhi-jian-dan-yi-dong-de-san-/
这个题解里有描述拆分法的详细的图解。

链表题一般都是比较简单的题，使用的方法也无外乎上述的方法。一刷总结。