请求分析Java代码的时间复杂度（Big-O表示法）及计算步骤

以下是我编写的一段采用Transform & Conquer策略的Java代码，我已尝试单独计算各循环与条件语句的时间复杂度，但不确定如何合并得到最终结果。请分析该代码的时间复杂度（以Big-O表示法呈现）并说明计算步骤：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) throws FileNotFoundException {
        File file = new File("C:\\Users\\yousu\\OneDrive\\سطح المكتب\\textfile\\OptimizeBusInput.txt");
        Scanner scan = new Scanner(file);
        while(true) {
            int n = 0;
            int d = 0;
            int r = 0;
            int outcome = 0;
            
            n = scan.nextInt();
            d = scan.nextInt();
            r = scan.nextInt();

            if ( n + d + r == 0) break;

            int[] morning = new int[n];
            int[] afternoon = new int[n];

            for (int i = 0; i < n; i++) {
                morning[i] = scan.nextInt();
            }
            for (int i = 0; i < n; i++) {
                afternoon[i] = -scan.nextInt();
            }
            Arrays.sort(morning);
            Arrays.sort(afternoon);

            for (int i = 0; i < n; i++) {
                int sum = morning[i] + (-afternoon[i]) - d;
                if (sum > 0) outcome += sum * r;
            }
            System.out.printf("%d\n", outcome);
        }
    }
}

时间复杂度计算步骤 #

1. 外层循环次数：假设输入包含T组有效测试用例（每组对应一次循环迭代，直到n+d+r=0时终止），外层循环共执行T次。

2. 单组测试用例的操作复杂度：

   • 读取n、d、r及终止判断：均为常数时间操作，记为O(1)。
   • 数组初始化：分配长度为n的数组，时间与n成正比，记为O(n)。
   • 填充morning和afternoon数组：各执行n次常数时间的读操作，总时间为O(n) + O(n) = O(n)。
   • 数组排序：Java的Arrays.sort()采用双枢轴快速排序，时间复杂度为O(n log n)；对两个数组排序的总时间为O(n log n) + O(n log n) = O(n log n)。
   • 计算outcome的循环：执行n次常数时间的计算与条件判断，记为O(n)。
   • 输出结果：常数时间操作，记为O(1)。

3. 合并单组操作的复杂度：在Big-O表示法中，我们只保留增长速度最快的项。单组操作中，O(n log n)的增长速度远快于O(n)和O(1)，因此单组测试用例的时间复杂度可简化为O(n log n)。

4. 总时间复杂度：外层循环执行T次，每次的时间复杂度为O(n log n)，因此整体时间复杂度为O(T * n log n)。

若所有测试用例的n取值相同（或取最大的n作为代表），且T为常数时，可进一步简化为O(n log n)，但通常保留T以体现测试用例数量对总时间的影响。

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