Java 加速全计数排序的方法

我遇到了一个关于hackerrank的问题。

由于超时，我的第一次尝试通过了除最后一次之外的所有测试用例。 在没有找到更有效的算法之后，我改进了代码，使用StringBuilder而不是直接连接字符串。这使运行时间从5秒以上增加到3.5秒

我的问题是，有没有其他方法可以提高运行时间？ 谢谢

下面是我的代码

public class Solution {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int N = scanner.nextInt();
        scanner.nextLine();

        int[] oriNum = new int[N];        
        String[] oriStr = new String[N];
        int[] count = new int[100];
        int[] indices = new int[100];
        int[] output = new int[N];

        // save the originals and the count array
        for (int i = 0; i < N; i++) {
            oriNum[i] = scanner.nextInt();
            oriStr[i] = scanner.nextLine().trim();
            count[oriNum[i]]++;
        }

        // accumulate the count array
        indices[0] = 0;
        for (int i = 1; i < 100; i++) {
            indices[i] = indices[i-1] + count[i-1];
        }

        // output order
        for (int i = 0; i < N; i++) {
            int num = oriNum[i];
            output[indices[num]++] = i;
        }

        int bar = N/2;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < N; i++) {            
            int index = output[i];
            if (index < bar) 
                sb.append("- ");
            else 
                sb.append(oriStr[index]+ " ");
        }
        System.out.println(sb.toString());
    }
}

公共类解决方案{
公共静态void main（字符串[]args）{
扫描仪=新的扫描仪（System.in）；
int N=scanner.nextInt（）；
scanner.nextLine（）；
int[]oriNum=新的int[N]；
字符串[]oriStr=新字符串[N]；
int[]计数=新的int[100]；
int[]索引=新的int[100]；
int[]输出=新的int[N]；
//保存原始数据和计数数组
对于（int i=0；i

您应该尝试普通缓冲读卡器，而不是扫描仪。Scanner的速度惊人地慢，我参加过编程竞赛，其中Scanner是“超过时间限制”的唯一原因； 导入java.util.*； 导入java.text.*； 导入java.math.*； 导入java.util.regex.*； 公共类解决方案 { 公共静态void main（字符串[]args）引发异常 { BufferedReader in=新的BufferedReader（新的InputStreamReader（System.in））； int n=Integer.parseInt（in.readLine（））； int[]c=新的int[100]； 字符串[][]dt=新字符串[100][10300]；

---

对于（inti=0；i，这是我解决问题的方法。（它是用c++编写的）

void counting\u sort（向量&arr、整数大小、向量foo、向量前半部分）
{
int max=*max_元素（arr.begin（），arr.end（））；
int min=*min_元素（arr.begin（），arr.end（））；
整数范围=最大-最小+1；
整数计数[范围]={0}；
//数组中数字的计数频率
对于（int i=0；i=0；i--）//从后遍历以获得稳定性
{
输出[count[arr[i]-min]-1]=foo[i]；
计数[arr[i]-min]--；
}
//在原始数组中复制已排序的数组
int j=0；
对于（int i=0；i不能代替sb.append（oriStr[index]+“”）；使用sb.append（oriStr[index]）。append（“”）；这个问题似乎与主题无关，因为它要求进行代码审查，因此属于代码审查SE。如果您在搜索如何使计数排序稳定（如所引用的HackerRank问题所要求）时偶然发现了这个线程，请参阅本文-我试过BufferedReader，运行时间缩短了从3.5秒到1.4秒。很好的建议，谢谢！不客气。我也遇到过同样的情况。
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Solution 
{
    public static void main(String[] args)throws Exception 
{
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(in.readLine());
    int[] c=new int[100];
    String[][] dt=new String[100][10300];
    for(int i=0;i<n;i++)
    {
        String[] str=in.readLine().split(" ");
        int val=Integer.parseInt(str[0]);
        if(i<n/2)
            dt[val][c[val]]="-";
        else
             dt[val][c[val]]=str[1];
        c[val]++;
     }
  StringBuilder sb=new StringBuilder("");
    for(int i=0;i<100;i++)
       if(i<n)
        for(int k=0;k<c[i];k++)
            if(dt[i][k]!=null)
               sb.append(dt[i][k]+" ");
            else break;
    System.out.println(sb.toString());
 }
}

void counting_sort(vector<int> &arr, int size,  vector<vector<string> > foo, vector<int> first_half)
{
    int max = *max_element(arr.begin(), arr.end());
    int min = *min_element(arr.begin(), arr.end());

    int range = max - min + 1;

    int count[range] = {0};

    // counting frequency of numbers in array
    for (int i = 0; i < size; i++)
    {
        count[arr[i] - min]++;
    }

    // calculating cumulative sum
    for (int i = 1; i < range; i++)
    {
        count[i] += count[i - 1];
    }

    vector<vector<string> > output(size);

    // making the new sorted array
    for (int i = size - 1; i >= 0; i--) // traversing from backward for stability
    {
        output[count[arr[i]-min] - 1] = foo[i];
        count[arr[i]-min]--;
    }

    // copying the sorted array in original array
    int j=0;
    for (int i = 0; i < size; i++)
    {
        if(stoi(output[i][0]) == first_half[j])
        {
            cout << "- ";
            j++;
        }
        else
        {
            cout << output[i][1] << ' ';
        }
    }
}

// Complete the countSort function below.
void countSort(vector<vector<string>> arr) {

    vector<int> num;
    vector<int> first_half;
    for(int i=0; (unsigned)i<arr.size(); i++)
    {
        num.push_back(stoi(arr[i][0]));
        if(i < ((unsigned)arr.size()/2))
        {
            first_half.push_back(stoi(arr[i][0]));
        }
    }

    sort(first_half.begin(), first_half.end());
    counting_sort(num, num.size(), arr, first_half);
}