链表简单算法相关练习

单链表反转：

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

事例

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

输入：head = []
输出：[]

迭代方式实现：

迭代图解

//迭代方式实现
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
       ListNode* cur;//当前节点
       ListNode* pre;//上一个节点
       ListNode* temp;//临时节点
       while(cur){
           //1.临时节点记录当前节点的下一个节点
           temp  = cur.next;
           //2.当前节点的下一个节点指向为上一个节点
           cur.next = pre;
           //3.当前节点设置为上个节点
           pre = cur;
           //4.当前节点指向下一个节点
           cur = temp;
       }
       //返回pre节点，当循环结束pre节点就相当于当前节点
       return pre
    }
};

复杂度分析：

• 时间复杂度：O(n)O(n)，其中 nn 是链表的长度。需要遍历链表一次。

• 空间复杂度：O(1)O(1)。

递归方式实现：

递归图解

//递归方式实现(理解难度偏高)
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        //如果为空直接返回
        if(!head||!head.next){
             return head;
        }
        //递归调用，将cur设置为head的下一个节点
        ListNode* cur = reverseList(head.next);
        // head节点的下一个节点反向指向head节点，这一句进行倒转
        head.next.next = head;
        //将 head节点的下一个节点设置为空，一遍后续的递归判断
        head.next = nullptr;
        //返回当前节点
        return cur;
    }

复杂度分析：

• 时间复杂度：O(n)O(n)，其中 nn 是链表的长度。需要对链表的每个节点进行反转操作。

• 空间复杂度：O(n)O(n)，其中 nn 是链表的长度。空间复杂度主要取决于递归调用的栈空间，最多为 nn 层。

链表中环的检测和入口节点寻找：

给定一个链表，返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。

事例1

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

事例2

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

哈希表方式实现：

我们遍历链表中的每个节点，并将它记录下来；一旦遇到了此前遍历过的节点，就可以判定链表中存在环。借助哈希表可以很方便地实现。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
         //定义一个哈希表
        unordered_set visited;
        while(!head){
            //如果存在该节点直接返回该节点
            if(visited.count(head)){
                return head;
            }
            //不存在则加入到表中
            visited.insert(head);
            //设置下一个
            head = head->next;
        }
        //没有则返回空
        return nullptr;
    }
};

复杂度分析：

• 时间复杂度：O(N)O(N)，其中 NN 为链表中节点的数目。我们恰好需要访问链表中的每一个节点。

• 空间复杂度：O(N)O(N)，其中 NN 为链表中节点的数目。我们需要将链表中的每个节点都保存在哈希表当中。

Java知识点：如果用Java实现使用的是HastSet。Set是一个继承于Collection的接口，Set是一种不包括重复元素的Collection。它维持它自己的内部排序，所以随机访问没有任何意义。与List一样，它同样运行null的存在但是仅有一个。由于Set接口的特殊性，所有传入Set集合中的元素都必须不同，关于API方面。Set的API和Collection完全一样。实现了Set接口的集合有：HashSet、TreeSet、LinkedHashSet、EnumSet。
HashSet堪称查询速度最快的集合，因为其内部是以HashCode来实现的。集合元素可以是null,但只能放入一个null。它内部元素的顺序是由哈希码来决定的，所以它不保证set的迭代顺序；特别是它不保证该顺序恒久不变。需要重写 hashCode 和 equals 方法。

快慢指针方式实现：

我们使用两个指针，fast 与 slow。它们起始都位于链表的头部。随后，slow 指针每次向后移动一个位置，而 fast 指针向后移动两个位置。如果链表中存在环，则 fast 指针最终将再次与 slow 指针在环中相遇。而相遇后起点到相遇点的距离通过计算正好等于入环点到环入口的距离，所以初始化一个节点从头开始，和slow节点同步前进，相遇的点就是环入口节点。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        //初始化快慢指针
        ListNode *fast = head;
        ListNode *slow = head;
        //当 fast 为空停止
        while(fast != nullptr){
          //slow前进一步
          slow = slow.next;
          //fast为空直接返回
          if(fast.next = nullptr){
            return nullprt;
          }
          //fast前进两步
          fast = fast.next.next;
          //fast和slow相遇
          if(slow == fast){
           //初始化一个新的节点设置为头
           ListNode *ptr = head;
           //循环前进直到他们相遇
           while (ptr != slow) {
             ptr = ptr->next;
             slow = slow->next;
           }
           //返回相遇的点，而这个点就是环入口点
           return ptr;
          }
        }
        return nullptr;
    }
};

复杂度分析

• 时间复杂度：O(N)O(N)，其中 NN 为链表中节点的数目。在最初判断快慢指针是否相遇时，slow 指针走过的距离不会超过链表的总长度；随后寻找入环点时，走过的距离也不会超过链表的总长度。因此，总的执行时间为 O(N)+O(N)=O(N)O(N)+O(N)=O(N)。

• 空间复杂度：O(1)O(1)。我们只使用了slow,fast,ptr 三个指针。

合并两个有序链表：

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

事例

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

输入：l1 = [], l2 = []
输出：[]

输入：l1 = [], l2 = [0]
输出：[0]

递归方式实现：

待续...