为什么基数排序的大 O 不是二次的？

Question

function getDigit(num, i) {
  return Math.floor(Math.abs(num) / Math.pow(10, i)) % 10;
}

function digitCount(num) {
  if (num === 0) return 1;
  return Math.floor(Math.log10(Math.abs(num))) + 1;
}

function mostDigits(nums) {
  let maxDigits = 0;
  for (let i = 0; i < nums.length; i++) {
    maxDigits = Math.max(maxDigits, digitCount(nums[i]));
  }
  return maxDigits;
}

function radixSort(nums){
    let maxDigitCount = mostDigits(nums);
    for(let k = 0; k < maxDigitCount; k++){
        let digitBuckets = Array.from({length: 10}, () => []);
        for(let i = 0; i < nums.length; i++){
            let digit = getDigit(nums[i],k);
            digitBuckets[digit].push(nums[i]);
        }
        nums = [].concat(...digitBuckets);
    }
    return nums;
}

So this is the radix sort code that I learned. But if you look at radixSort function, for loops in there are nested, which from what I learned means that the Big O of radix sort is O(n 2). But according to the material I learned, it says that the time complexity of radix sort is O(nk). n being the length of array and k being the number of digits(average). I can't figure out why it's not O(n 2).

Answer 1

Big O notation , in computer science, is used to classify algorithms according to how their run time or space requirements grow as the input size grows.

Radix sort has linear complexity O(nk) . This is because k is the constant number (nuber of digits) and n can grow (length of array).

k affects the slope of the function, but it is far from O(n ² ) complexity (graph n=1 to 30):