LeetCode 1658两种O(1)空间解法为何空间占比差异巨大？

我用两种极为相似的方法解决了LeetCode 1658题，两种方法的空间复杂度均为O(1)，但其中一种的空间复杂度排名为36%，另一种为90%。请问为何两者的空间占比差异如此之大？

Code 1: 空间复杂度排名 36% #

def minOperations(self, nums: List[int], x: int) -> int:
    length = len(nums)
    if length == 1:
        return 1 if nums[0] == x else -1
    if sum(nums) < x:
        return -1

    start, end, maximum = 0, 1, -1                                
    currsum = nums[0]                                         
    target = sum(nums) - x

    while start <= end and end < length:
        while currsum < target and end < length:
            currsum += nums[end]
            end += 1
        
        while currsum > target:
            currsum -= nums[start]
            start += 1
        
        if currsum == target:
            maximum = max(end - start, maximum)
            currsum -= nums[start]
            start += 1
    
    return length - maximum if maximum != -1 else -1

Code 2: 空间复杂度排名 90% #

class Solution:
    def minOperations(self, nums: List[int], x: int) -> int:
        length = len(nums)
        if length == 1:
            return 1 if nums[0] == x else -1
        if sum(nums) < x:
            return -1

        start, end, maximum = 0, 1, -1
        currsum = nums[0]
        target = sum(nums) - x
        if nums[0] == target:
            maximum = 1

        while end < length:
            currsum += nums[end]
            end += 1
            
            while currsum > target:
                currsum -= nums[start]
                start += 1
            
            if currsum == target:
                maximum = max(end - start, maximum)

        return length - maximum if maximum != -1 else -1

原因分析 #

LeetCode的空间复杂度排名并非严格依据理论复杂度划分，而是基于代码在所有测试用例上的实际运行内存占用进行相对排名。即使理论复杂度都是O(1)，实际运行中的细微内存差异也会导致排名出现明显差距，具体到这两段代码，可能的影响因素包括：

• 循环结构的差异：Code 1采用嵌套双层while循环（外层循环+内层处理currsum < target的循环），而Code 2将累加逻辑整合到主循环中。Python解释器处理不同循环结构时，栈帧复用、临时变量管理的效率存在细微差别，导致Code 1实际内存占用略高。
• 变量操作的累积开销：Code 1在匹配到目标和值后，会主动修改currsum并移动start指针，这一步额外的变量操作在多次循环中会累积出微小的内存开销；而Code 2的逻辑更线性，没有这一步额外操作。
• 平台统计的随机性：LeetCode的内存统计存在一定波动，同一代码在不同时间运行，排名可能略有变化，尤其当内存差异极小时，这种波动会被放大。
• 解释器优化差异：Code 2的逻辑更简洁线性，Python解释器可能对其进行了更高效的字节码优化，减少了不必要的内存消耗；而Code 1的嵌套结构难以触发同等优化。

内容的提问来源于stack exchange，提问作者darkdragontr