为什么具有 O(n) 时间复杂度的 leetcode 提交需要比 O(n log n) 时间复杂度更多的时间来运行？

Question

I was solving below question on Leetcode -

Given two arrays, write a function to compute their intersection.

Input: nums1 = [1,2,2,1], nums2 = [2,2]
Output: [2,2]

I devised a solution with O(n) TC in java using a HashMap as below:

Approach-1

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
       int res[] = new int[nums1.length];
       Map<Integer,Integer> freqMap = new HashMap<Integer,Integer>();
        for(int i=0;i<nums1.length;i++){
          freqMap.put(nums1[i],freqMap.getOrDefault(nums1[i],0)+1);
        }
    int k = 0;
    for(int i=0;i<nums2.length;i++){
        if(freqMap.get(nums2[i]) != null && freqMap.get(nums2[i]) != 0){
           res[k] = nums2[i]; 
           freqMap.put(nums2[i],freqMap.get(nums2[i])-1);
           k++;
        }
      }
     return Arrays.copyOfRange(res,0,k);
    }
}

I saw another accepted solution with O(nlogn) TC using sorting approach as below:

Approach-2

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
    Arrays.sort(nums1);
    Arrays.sort(nums2);
    int i = 0, j = 0, k = 0;
    while (i < nums1.length && j < nums2.length) {
        if (nums1[i] < nums2[j]) {
            ++i;
        } else if (nums1[i] > nums2[j]) {
            ++j;
        } else {
            nums1[k++] = nums1[i++];
            ++j;
        }
    }
    return Arrays.copyOfRange(nums1, 0, k);
}
}

Now, theoretically speaking Approach-1 solution should run faster than Approach-2 but the Approach-2 solution ran in 1ms whereas Approach-1 solution ran in 2ms.

Can anyone explain why this can happen?

PS - The runtimes were calculated by leetcode on submission

Edit- With the new comments I'm pondering over some new questions now.

Since this looks to be affected by constant factor in big O . I would like to know which are the factors which can cause time difference in this specific case?

And is using Array sort over Hashmap always better for calculations with integer value of n?

Answer 1

Threre are endless variables that can affect runtime, variance, connection, proseccor load, how things are placed in memory and so on. This is the reason we use O(n) notation, as its the only reasonable way to compare two algorithms.

Also some algoritms have a large fixed cost, which means they are slower when n is small because the scaling factor doesnt get enough data to scale.

When we calculate O(n) we cut out the fixed costs as when n gets large the fixced costs mean less and less in terms of time used. This way, our big O notation will not differentiate between 999n and n, even though the latter does less operations. Remember that 10n is slower(more operations) than n^2 when n < 10, even though O(n) is considered faster than O(n^2)