为什么这段代码会给我超时错误？答案

【问题标题】：Why does this code gives me timeout error?为什么这段代码会给我超时错误？
【发布时间】：2020-07-19 09:56:24
【问题描述】：

我正在解决this 问题。

给定两个排序数组 arr1[] 和 arr2[] 以非递减顺序排列，大小为 n 和 m。任务是将两个排序后的数组合并为一个排序后的数组（按非递减顺序）。

注意：预期时间复杂度为 O((n+m) log(n+m))。不要使用额外的空间。
以下代码的时间复杂度为 O(n log m)。不过，它给了我一个超时错误。

我哪里错了？



import java.util.*;
import java.lang.*;
import java.io.*;

class GFG {
    public static void main (String[] args) throws IOException {
        
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        
        while(t-- > 0){
            StringTokenizer st = new StringTokenizer(br.readLine());
            int len1 = Integer.parseInt(st.nextToken());
            int len2 = Integer.parseInt(st.nextToken());
            int[] nums1 = new int[len1];
            int[] nums2 = new int[len2];
            
             st = new StringTokenizer(br.readLine());
            
            for(int i = 0; i<len1; i++)
                nums1[i] = Integer.parseInt(st.nextToken());
                
             st = new StringTokenizer(br.readLine());
            
            for(int i = 0; i<len2; i++)
                nums2[i] = Integer.parseInt(st.nextToken());
                
            int temp;
            for(int i =0; i<len1; i++){
                if (nums1[i] > nums2[0]){
                     temp = nums1[i];
                     nums1[i] = nums2[0];
                     nums2[0] = temp;
                     Heapify(nums2,0,len2);
                }
                
            } 
            
            
            for(int i = 0; i<len1; i++)
                System.out.print(nums1[i]+" ");
                
            Arrays.sort(nums2);
            for(int i = 0; i<len2; i++)
                System.out.print(nums2[i]+" ");
            System.out.println();
            
            
        }
        
    }
    
    static void Heapify(int[] nums, int i, int len){
        
        int l = 2 * i+1;
        int r = 2 * i + 2;
        int smallest = i;
        
        if (l < len && nums[l] < nums[i] ){
            smallest = l;
        }
        if (r < len && nums[r] < nums[smallest] ){
            smallest = r;
        }
        if (smallest != i){
            int temp = nums[i];
            nums[i] = nums[smallest];
            nums[smallest] = temp;
            Heapify(nums,smallest,len);
        }
        
    }
    
}

【问题讨论】：

不是你的问题的答案，但代码复杂度 O((n+m) log m) [你省略了排序 num2 的复杂性] 并使用 O(log m) 空间（因为heapify 和 Arrays.sort)。我想要满足问题的要求，您需要避免 heapify 中的递归，并使用堆排序而不是 Arrays.sort（双轴快速排序）对 num2 进行排序。
使用给定的约束，您可以简单地将两个数组视为一个数组，然后对其进行堆排序。这甚至不需要两个数组开始排序。
@PaulHankin，超时只是由于许多读写操作。

标签： java algorithm data-structures timeout heap

【解决方案1】：

网站有一些问题。多次提交相同的解决方案。

超时是由于涉及到大量的读写操作。

您使用 BufferedReader 为读取操作优化了它。

我在以下实现中使用 BufferedWriter 针对写入操作对其进行了优化：

import java.util.*;
import java.lang.*;
import java.io.*;

class GFG {
    public static void main (String[] args) throws IOException {
        
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        
        while(t-- > 0){
            StringTokenizer st = new StringTokenizer(br.readLine());
            int len1 = Integer.parseInt(st.nextToken());
            int len2 = Integer.parseInt(st.nextToken());
            int[] nums1 = new int[len1];
            int[] nums2 = new int[len2];
            
             st = new StringTokenizer(br.readLine());
            
            for(int i = 0; i<len1; i++)
                nums1[i] = Integer.parseInt(st.nextToken());
                
             st = new StringTokenizer(br.readLine());
            
            for(int i = 0; i<len2; i++)
                nums2[i] = Integer.parseInt(st.nextToken());
                
            int temp;
            for(int i =0; i<len1; i++){
                if (nums1[i] > nums2[0]){
                     temp = nums1[i];
                     nums1[i] = nums2[0];
                     nums2[0] = temp;
                     Heapify(nums2,0,len2);
                }
                
            } 
            
            BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
            
        
            
            
            for(int i = 0; i<len1; i++)
                log.write(nums1[i]+" ");
                
            Arrays.sort(nums2);
            for(int i = 0; i<len2; i++)
                log.write(nums2[i]+" ");
            log.write("\n");
            
            log.flush();    
            
        }
        
    }
    
    static void Heapify(int[] nums, int i, int len){
        
        int l = 2 * i+1;
        int r = 2 * i + 2;
        int smallest = i;
        
        if (l < len && nums[l] < nums[i] ){
            smallest = l;
        }
        if (r < len && nums[r] < nums[smallest] ){
            smallest = r;
        }
        if (smallest != i){
            int temp = nums[i];
            nums[i] = nums[smallest];
            nums[smallest] = temp;
            Heapify(nums,smallest,len);
        }
        
    }
    
}

对于上述代码，Geeks for Geeks 的判决接受：

PS：尝试多次提交相同的解决方案。你会得到正确的答案作为判决。

【讨论】：