萱仔求职系列——链表练习

由于我这几天面到的一些图像算法岗也提到了我不熟悉c++的软肋，我准备复习算法的时候顺带复习复习c++，也算是不浪费一丝一毫的刷题时间！

141. 环形链表

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

一开始我以为可以直接记录下来有没有这个内容，字典中，如果有的话就相当于有环，但是这样就比较的复杂， 相当于空间复杂度为O（n）。

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        visited = {}  # 用字典记录访问过的节点
        
        current = head
        while current:
            if current in visited:
                return True  # 如果节点已访问，说明有环
            visited[current] = True  # 将节点标记为已访问
            current = current.next
        
        return False  # 遍历结束后，若没有重复节点则无环

 C++版本！

class Solution {
public:
    bool hasCycle(ListNode *head) {
        unordered_set<ListNode*> visited;  // 记录访问过的节点
        
        ListNode *current = head;
        while (current) {
            if (visited.find(current) != visited.end()) {
                return true;  // 如果节点已访问，说明有环
            }
            visited.insert(current);  // 将节点标记为已访问
            current = current->next;
        }
        
        return false;  // 如果遍历完成仍没有重复节点，说明无环
    }
};

但是我看了题解中写的快慢指针，非常简单，相当于如果有一个快指针夺走一步，满指针每次只走一步，如果遇见了那就是有圈！

def hasCycle(head: ListNode) -> bool:
    if not head or not head.next:
        return False
    
    slow, fast = head, head.next
    
    while fast and fast.next:
        if slow == fast:
            return True
        slow = slow.next
        fast = fast.next.next
    
    return False

class Solution {
public:
    bool hasCycle(ListNode *head) {
        // 如果链表为空或只有一个节点，肯定没有环
        if (!head || !head->next) {
            return false;
        }

        // 初始化快慢指针
        ListNode *slow = head;
        ListNode *fast = head->next;

        // 开始遍历链表，快指针每次走两步，慢指针走一步
        while (fast && fast->next) {
            if (slow == fast) {
                return true;  // 如果快慢指针相遇，则说明有环
            }
            slow = slow->next;         // 慢指针走一步
            fast = fast->next->next;   // 快指针走两步
        }

        return false;  // 如果遍历结束没有相遇，说明没有环
    }
};

 

2. 两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        if not l1:
            return l2
        if not l2:
            return l1 
        #l3=ListNode(0)
        l1.val = l1.val+l2.val
        if l1.val >=10:
            l1.next = self.addTwoNumbers(ListNode(l1.val // 10), l1.next) 
            # 以l1为基准,遇到需要进位则递归为l1进位
            l1.val = l1.val % 10
        l1.next = self.addTwoNumbers(l1.next, l2.next)
        return l1