Java 改进插入排序的运行时

为了练习和提高我的编程技能，我决定在InterviewStreet上解决这些问题。我决定开始使用SimpleInsertionSort（我希望它很简单）。 我能得到正确的答案。然而，运行时是一个问题。测试用例允许的最大运行时间为5s。然而，我有点过火了。 我使用了一些技巧（比如从代码中删除一些内容，存储str.lenght（）的结果等等）。然而，我仍然有点过火

十个测试用例的当前运行时为：

1成功通过0.160537

2次成功通过0.182606

3次成功通过0.172744

4次成功通过0.186676

超过了5个失败的时间限制。5.19279

超过了6个失败的时间限制。5.16129

7通过成功2.91226

超过了8个失败的时间限制。5.14609

超过了9个失败的时间限制。5.14648

超过10个失败的时间限制。5.16734

我不知道测试用例是什么。 请帮助我改进运行时。 多谢各位

import java.util.Scanner;
import java.io.*;
//import java.io.BufferedWriter;
//import java.io.FileInputStream;
//import java.io.FileOutputStream;

public class Solution {
    public static int[] A=new int[100001]; 
    public static int swap=0;
    public static void InsertionSort(int n){
    for (int i=1; i<=n; i++){    
        for (int var=i; var>0; var--){
            if (A[var]<A[var-1]){
                int temp=A[var-1];
                A[var-1]=A[var];
                A[var]=temp;
                swap++;
            }
            else {
                break;
            }
        }
    }
    }


    public static void main(String[] args) throws IOException  {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String str = br.readLine();
        int number_of_cases =Integer.parseInt(str);
        int counter;
        int [] spacearray = new int[100000];

        for (int j=0; j<number_of_cases; j++){
            swap=0;
            str = br.readLine();
            int arraylength = Integer.parseInt(str);

            str = br.readLine();
            counter=0;
            int strlen=str.length();
            for (int i=0; i<strlen-1; i++){
                if (str.charAt(i) == ' '){
                    spacearray[counter]=i;
                    counter++;
                }
            }
            spacearray[counter]=strlen;

            A[0]=Integer.parseInt(str.substring(0, spacearray[0]));
            for (int i=1; i<=arraylength-1; i++){
                A[i] = Integer.parseInt(str.substring(spacearray[i-1]+1,spacearray[i]));
            }

            InsertionSort(arraylength-1);

            System.out.println(swap);
        }
    }
}

import java.util.Scanner；
导入java.io.*；
//导入java.io.BufferedWriter；
//导入java.io.FileInputStream；
//导入java.io.FileOutputStream；
公共类解决方案{
公共静态int[]A=新int[100001]；
公共静态整数交换=0；
公共静态void InsertionSort（int n）{
对于（int i=1；i0；var--）{
如果（A[var]使用二叉索引树来解决这个问题，这里的瓶颈是插入排序算法。它的时间复杂度是O（n^2）当n达到10^5时，在interviewstreet judge机器上很容易超过5秒。此外，当抛出TLE信号时，您的程序停止执行。因此，5的轻微开销并不是实际运行所需时间的指标。它是由检测TLE和停止执行之间的延迟引起的

从历史的角度来看，这个问题最初是作为codesprint-1的一部分出现的。在这里使用插入排序不是继续的方式，否则这个问题将是一个完全的放弃

提示

使用所有值都在[1,10^6]范围内的事实。这里真正要做的是查找数组A中的反转数，即查找iA[j]的所有对。考虑一种数据结构，它允许您以对数时间复杂度查找每个插入操作所需的交换数（如）当然，还有其他方法。
考虑到插入排序是
O（n^2）
并且
n
可能达到100000，有可能需要一种比模拟更好的算法。在
a[i]中读取也可能更好<代码> >代码> > StrtotoKeisher 。我猜你浪费了太多的时间解析你的东西。考虑使用预编译模式而不是子字符串。噢，是的！所以，实际上不是交换……实际上我可以计算元素的右边的元素的数目。这比计算NU要复杂一些。更大元素的数量。如果你检查一下提示，我认为有一个
O（logn）
算法。