leecode第3天

26、删除有序数组中的重复项

class Solution(object):
    #太慢耗时3327ms
    def removeDuplicates(self, nums):
        """
        从有序列表中移除重复元素，使每个元素只出现一次，并返回新长度。
        原地修改输入列表，不需要额外空间(空间复杂度O(1))。
        
        :type nums: List[int]
        :rtype: int
        Args:
            nums: 待处理的整数列表(需有序)，函数会直接修改该列表
        
        Returns:
            去重后的新列表长度
        """
        # 逆序遍历避免删除元素时索引错位
        i=len(nums)-1
        while i>=0:
            # 当元素出现多次时，移除当前实例
            if nums.count(nums[i]) > 1:
                nums.pop(i)
            i-=1
            
        return len(nums)
    
    #双指针1ms
    def removeDuplicates1(self, nums):
        """
        使用双指针算法移除有序数组中的重复元素
        
        :type nums: List[int] 输入的有序整数数组（可能包含重复元素）
        :rtype: int 返回去重后数组的新长度
        算法说明：
        - 使用慢指针k标记非重复元素的插入位置
        - 快指针i遍历整个数组
        - 时间复杂度O(n)，空间复杂度O(1)
        """
        k=1  # 初始化非重复元素指针，至少保留第一个元素
        
        # 遍历数组，当发现新元素时更新慢指针位置
        for i in range(1,len(nums)):
            if nums[i] != nums[i-1]:
                # 将新发现的非重复元素移动到数组前部
                nums[k]=nums[i]
                k+=1  # 移动慢指针准备接收下一个非重复元素
        return k

flowchart TD
    A[开始] --> B[初始化k=1]
    B --> C{遍历i从1到末尾}
    C -->|未结束| D{当前元素≠前元素?}
    D -->|是| E[覆盖到k位置并k+1]
    D -->|否| C
    E --> C
    C -->|遍历结束| F[返回k值]

总结：

• 避免遍历时动态修改列表长度（用反向遍历或新建列表）
• 明确需求是保留唯一元素还是去重
• 时间复杂度优化建议：使用哈希表统计频率可提升效率。

206、反转链表

# Definition for singly-linked list.
class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution(object):
    #自己
    def reverseList(self, head):
        """
        反转单向链表

        通过迭代方式将链表节点指针反向。每次循环将最后一个节点移动到已反转部分的末尾，
        时间复杂度为O(n^2)，空间复杂度为O(1)

        :type head: Optional[ListNode] 原链表的头节点
        :rtype: Optional[ListNode] 反转后新链表的头节点（即原链表的尾节点）
        """
        # 处理空链表或单节点链表的边界情况
        if not head or not head.next:
            return head

        # 定位尾节点并计算链表长度
        current = head
        su = 0  # 链表长度计数器（实际比节点数少1）
        while current.next is not None:
            current = current.next
            su += 1
        end = current  # 保存原始尾节点作为最终返回结果

        # 迭代反转链表核心逻辑
        for i in range(su):
            current = head
            # 定位当前链表的倒数第二个节点
            while current.next.next is not None:
                current = current.next

            # 节点指针重定向操作：
            # 1. 最后一个节点指向当前倒数第二个节点
            # 2. 断开原倒数第二个节点与最后一个节点的连接
            current.next.next = current
            current.next = None

        return end
    
    #leecode
    def reverseList(self, head):
        """
        反转单链表
        
        参数说明：
        :type head: Optional[ListNode]  原链表的头节点
        :rtype: Optional[ListNode]      反转后新链表的头节点
        """
        # 初始化指针：当前节点指针和前驱节点指针
        cur, pre = head, None
        
        # 遍历链表进行反转操作
        while cur:
            # 暂存当前节点的下一个节点
            temp = cur.next
            
            # 反转当前节点的指针方向
            cur.next = pre
            
            # 移动双指针向前
            pre = cur
            cur = temp
        
        # 返回反转后的新链表头节点
        return pre