CodeChef TurboSort（使用int vs Integer排序）

Question

給定數字列表，您將按非遞減順序對它們進行排序。 輸入

t - 列表中的數字數，然后t行跟隨[t <= 10 ^ 6]。 每行包含一個整數：N [0 <= N <= 10 ^ 6]輸出

以非遞減順序輸出給定數字。 例

輸入：5 5 3 6 7 1輸出：1 3 5 6 7

首先使用文字int值並使用Arrays.sort（）函數實現，該函數使用Quicksort Algo對文字進行排序（最差情況n ^ 2，平均情況 - nlogn）

import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {

  public static void main(String[] args) {

    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    PrintWriter out = new PrintWriter(outputStream);

    int num = in.nextInt();

    int[] n = new int[num];

    for (int i = 0; i < n.length; i++) {

      n[i] = in.nextInt();

    }

    Arrays.sort(n);


    for (int i = 0; i < n.length; i++) out.println(n[i]);


    out.close();

  }
}


class InputReader {
  private BufferedReader reader;
  private StringTokenizer tokenizer;

  public InputReader(InputStream stream) {
    reader = new BufferedReader(new InputStreamReader(stream));
    tokenizer = null;
  }

  public String next() {
    while (tokenizer == null || !tokenizer.hasMoreTokens()) {
      try {
        tokenizer = new StringTokenizer(reader.readLine());
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }

  public int nextInt() {
    return Integer.parseInt(next());
  }

} 

下一個實現是將int文字存儲和排序為Integer對象，並使用Arrays.sort（）方法，該方法現在使用MergeSort算法對Integer對象進行排序，以保證nlogn性能

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;
import java.io.InputStream;

/* Name of the class has to be "Main" only if the class is public. */
class Codechef {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    PrintWriter out = new PrintWriter(outputStream);
    int T = in.nextInt();

    Integer[] ARR = new Integer[T];

    for (int i = 0; i < T; i++) ARR[i] = in.nextInt();

    Arrays.sort(ARR);

    for (int i : ARR) out.println(i);

    out.close();
  }

}

class InputReader {
  private BufferedReader reader;
  private StringTokenizer tokenizer;

  public InputReader(InputStream stream) {
    reader = new BufferedReader(new InputStreamReader(stream));
    tokenizer = null;
  }

  public String next() {
    while (tokenizer == null || !tokenizer.hasMoreTokens()) {
      try {
        tokenizer = new StringTokenizer(reader.readLine());
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }

  public int nextInt() {
    return Integer.parseInt(next());
  }

} 

然而現在的問題是，根據邏輯，mergesort算法（即整數對象排序實現）相對於Quicksort算法應該花費更少或相等的時間），即int文字排序實現花費更少的時間......

整數對象排序實現 - 0.94sec int文字排序實現 - 0.53秒

我錯過了什么嗎？ 超時的原因是什么？ 是因為自動裝箱和自動裝箱？！這就是這個多余時間的原因......

Answer 1

對於初學者來說，實踐中的合並排序和快速排序都具有相似的性能。 事實上，快速排序通常會略微優於隨機數據。 但即使合並排序稍好一些，排序整數總是會明顯變慢，因為排序對象比基元更難。 它們不適用於緩存和原語。

Answer 2

排序需要更長的時間主要是因為使用Integer，您正在存儲一個對象，這是一個很大的開銷。

Answer 3

我想感謝你提醒我，我有一個我已經傾倒了很長時間的codechef帳戶。這是我當時做的解決方案花了我.20秒運行代碼有點大希望你找到這個有用的謝謝..

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

class Reader
{
    private static final int  BUFSIZE   = 0x10000;
    private final byte[]      buffer    = new byte[BUFSIZE];
    private final ByteBuffer  bb        = ByteBuffer.wrap(buffer);
    private final FileChannel channel;

    int                       bufSize   = -1;                     // non empty buffer
    int                       bufOffset = 0;                      // non valid buffer

    private FileInputStream getFileInputStream(InputStream in)
    {
        try
        {
            if (in instanceof BufferedInputStream)
            {
                Field field = in.getClass().getSuperclass().getDeclaredField("in");
                field.setAccessible(true);
                return (FileInputStream) field.get(in);
            }
        }
        catch (Throwable e)
        {
            e.printStackTrace();
        }
        return (FileInputStream) in;
    }

    Reader(InputStream in) throws IOException
    {
        this.channel = this.getFileInputStream(in).getChannel();
    }

    void fetchBuffer() throws IOException
    {
        bb.clear();
        bufSize = channel.read(bb);
        bufOffset = 0;
    }

    boolean isFinished()
    {
        return bufSize <= 0;
    }

    private int peek() throws IOException
    {
        if (bufOffset < bufSize)
            return buffer[bufOffset];
        fetchBuffer();
        if (bufSize > 0)
            return buffer[0];
        return -1;
    }

    private void skipSpace() throws IOException
    {
        int v = peek();
        while (v <= ' ' && v != -1)
        {
            bufOffset++;
            v = peek();
        }
    }

    void nextLine() throws IOException
    {
        int v = peek();
        while (v != -1 && v != '\n' && v != '\r')
        {
            bufOffset++;
            v = peek();
        }
        if (v == '\r')
        {
            bufOffset++;
            v = peek();
            if (v == '\n')
                bufOffset++;
        }
        else if (v == '\n')
        {
            bufOffset++;
            v = peek();
            if (v == '\r')
                bufOffset++;
        }
    }

    int readInt() throws IOException
    {
        skipSpace();
        int result = 0;
        int v = peek();
        while (v > ' ')
        {
            result = result * 10 + v - '0';
            bufOffset++;
            v = peek();
        }
        return result;
    }

}

class Writer
{
    private static final int       BUFSIZE = 0x10000;
    private final FileOutputStream fos;
    private final byte[]           buffer  = new byte[BUFSIZE];
    private int                    offset  = 0;

    private FileOutputStream getFileOutputStream(PrintStream out)
    {
        try
        {
            Field field = out.getClass().getSuperclass().getDeclaredField("out");
            field.setAccessible(true);
            OutputStream os = (OutputStream) field.get(out);
            if (os instanceof BufferedOutputStream)
            {
                BufferedOutputStream bos = (BufferedOutputStream) os;
                field = bos.getClass().getSuperclass().getDeclaredField("out");
                field.setAccessible(true);
                return (FileOutputStream) field.get(bos);
            }
            return (FileOutputStream) field.get(out);
        }
        catch (Throwable e)
        {
            e.printStackTrace();
        }
        return null;
    }

    Writer(PrintStream out) throws IOException
    {
        fos = getFileOutputStream(out);
    }

    private static final int[]  boundaries = new int[]
    {
        9, 99, 999, 9999, 99999, 999999, 9999999,
        99999999, 999999999
    };
    private static final int[]  divs       = new int[]
    {
        1, 10, 100, 1000, 10000, 100000, 1000000,
        10000000, 100000000
    };
    private static final byte[] numbers    = "0123456789".getBytes();

    void writeln(int number) throws IOException
    {
        if (offset > BUFSIZE - 100)
            flush();
        int index;
        for (index = 0; index < boundaries.length; index++)
            if (number <= boundaries[index])
                break;
        for (; index >= 0; index--)
        {
            int mult = number / divs[index];
            buffer[offset++] = numbers[mult];
            number -= mult * divs[index];
        }
        buffer[offset++] = '\n';
    }

    void flush() throws IOException
    {
        if (offset > 0)
        {
            fos.write(buffer, 0, offset);
            offset = 0;
        }
    }
}



class Solution {

    public static void main(String[] args) throws java.lang.Exception {
        Reader r=new Reader(System.in);
        Writer w=new Writer(System.out);

        int x,k;
        int[] arr2 = new int[1000000];
        x = r.readInt();
        for (int i = 0; i < x; i++) {
            arr2[r.readInt()]++;
        }
        for (int i = 0; i < 1000000; i++) {

                 k= arr2[i];
               while(k-- > 0){
                   w.writeln(i);
               }


        }
        w.flush();
    }
}