反转数字的时间复杂度

Question

借助 while 循环，反转数字是一项简单的任务，假设数字是 var num = 123 我们创建一个 while 循环，例如 - while num != 0.... {//代码} 这段代码适用于正整数和负整数

但是当我解决leet代码问题时我使用

当 num > 0 {//代码}

在此之上，我声明一个 var 包含一个 bool 值 false 并检查整数是负数还是正数（如果是负数）我将 true 分配给 bool 变量并将数字乘以 -1 将其转换为正数，然后在反转后创建布尔值的 if 语句，如果为 true，则该数字再次乘以 -1 以将其再次转换为负数。

所以问题是，与第二种方法相比，第一个同时适用于负数和正数的 while 循环具有更多的时间复杂度，为什么......？ 下面提供了两种方法的代码...

时间复杂度较低的第一种方法

class Solution {
func reverse(_ x: Int) -> Int {
        var temp = x
        var result = 0
        var bool = false
        if temp < 0 {
            temp = temp * -1
            bool = true
        }
        while temp > 0 {
            let dig = temp % 10
            result = result*10 + dig
            temp /= 10
        }
        if result >= Int32.min && result <= Int32.max {
            if bool {
                return result * -1
            } else {
            return result
        }
        } else {
            return 0
        }
    }
}

第二种方法时间复杂度更高

class Solution {
    func reverse(_ x: Int) -> Int {
        var temp = x
        var result = 0
        while temp != 0 {
            let dig = temp % 10
            result = result*10 + dig
            temp /= 10
        }
        if result >= Int32.min && result <= Int32.max {
            return result
        }
        else {
            return 0
        }
    }
}

Answer 1

为什么不直接这样做呢？

func reverse(_ number: Int) -> Int {
    // Grab the sign (+/- of the number). This is -1 for negative,
    // and 1 for positive numbers.
    let sign = number.signum()
    
    // Make a mutable copy of the number that's always positive.
    var number = number * sign

    // To accumulate the result in.
    var result = 0
    
    while number > 0 {
        // Quotient is number / divisor; remainder is number % divisor.
        // Many CPU architectures can do both of these in one operation.
        let (quotient, remainder) = number.quotientAndRemainder(dividingBy: 10)
        // reassign number to number/10
        number = quotient

        // accumulate results
        result *= 10
        result += remainder
    }

    // Multiply by the sign to make negative numbers negative again
    return result * sign
}

在我的测试中，所有三种方法的性能相差不到百分之一，而且我发现这更容易阅读。