2016-03-15 1 views
3

. Приведенный список номеров, вы должны сортировать их в неубывающем порядке. ВходCodeChef TurboSort (Сортировка с использованием int vs Integer)

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 (худший случай п^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 спосо что теперь сортирует объекты Integer с использованием сортировкой слияния Algo, что гарантирует 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()); 
    } 

} 

Однако этот вопрос в настоящее время является то, что согласно логике, слиянию алго (т.е. реализации сортировки объектов Integer) следует принимать меньше или равное время относительно Quicksort алгоритм), т.е. Int буквальной сортировочной реализации занимает меньше времени ...

Integer объект реализация сортировки - 0.94sec ИНТА буквальной сортировки реализация - 0.53sec

Я что-то пропустил? В чем причина этого лишнего времени? Это из-за autoboxing и autounboxing?! Является то, что причина этого лишнего времени ...

+1

btw, как вы знаете, что ваши элементы являются ints и <10^6, вы можете отсортировать их по линейной сложности. –

+0

Возможно, потому, что вы не измеряете то, что, по-вашему, вы измеряете. Вероятно, вы измеряете время компиляции HotSpot, время запуска JVM, пропускную способность вашего диска и т. Д. Сначала прочтите этот пост, а затем опубликуйте новые результаты тестов: http://stackoverflow.com/questions/504103/how-do-i-write -a-correct-micro-benchmark-in-java –

ответ

0

Я хотел бы поблагодарить вас за то, что вы напомнили мне, что у меня была учетная запись 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 = "".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(); 
    } 
} 
+0

извините .21 секунды для запуска. – SmashCode

+0

Целое число объекта, и для его обработки обычно требуется много времени. – SmashCode

+0

wow ... это абстрактно, чтобы быть нечитаемым .. (я новичок), так что это было бы от вас, если бы вы могли объяснить, что здесь происходит ..... иначе я просто буду прибегать к случайным googling, как всегда, и надеюсь, что я получу понимание этого кода .. Спасибо! – Vonn

1

Для начала, как сортировка сортировки, так и быстрая сортировка на практике имеют схожую производительность. Фактически, быстрая сортировка обычно немного опережает его случайными данными. Но даже если сортировка слияния была немного лучше, сортировка целых всегда будет значительно медленнее, потому что сортировка объектов более жесткая, чем примитивы. Они не работают с вашим кешем, а также с примитивами.

1

Сортировка занимает больше времени, главным образом потому, что с помощью Integer вы храните объект, что является большим количеством накладных расходов.