Це швидше додати до колекції, а потім відсортувати її, або додати до відсортованої колекції?

Якщо у мене Mapтаке:

HashMap<Integer, ComparableObject> map;

і я хочу отримати колекцію значень, відсортованих за природним упорядкуванням, який метод найшвидший?

(A)

Створіть екземпляр сортуваної колекції, наприклад ArrayList, додайте значення, а потім сортуйте:

List<ComparableObject> sortedCollection = new ArrayList<ComparableObject>(map.values());
Collections.sort(sortedCollection);

(B)

Створіть екземпляр упорядкованої колекції типу TreeSet, а потім додайте значення:

Set<ComparableObject> sortedCollection = new TreeSet<ComparableObject>(map.values());

Зверніть увагу, що отриманий збір ніколи не змінюється, тому сортування потрібно провести лише один раз.

TreeSet має log(n)гарантію складності часу на add()/remove()/contains()методи. Сортування an ArrayListзаймає n*log(n)операції, але add()/get()займає лише 1операцію.

Отже, якщо ви переважно отримуєте і не сортуєте часто, ArrayListто кращий вибір. Якщо ви часто сортуєте, але не отримуєте такого, TreeSetнайкращим вибором буде.

Теоретично сортування в кінці має бути швидшим. Підтримання відсортованого стану в процесі може зажадати додаткового часу процесора.

З точки зору CS, обидві операції є NlogN, але 1 сортування має мати нижчу константу.

Чому б не використовувати найкраще з обох світів? Якщо ви більше ніколи не використовуєте його, сортуйте за допомогою TreeSet та ініціалізуйте ArrayList із вмістом

List<ComparableObject> sortedCollection = 
    new ArrayList<ComparableObject>( 
          new TreeSet<ComparableObject>(map.values()));

РЕДАГУВАТИ:

Я створив орієнтир (ви можете отримати до нього доступ за адресою pastebin.com/5pyPMJav ), щоб перевірити три підходи (ArrayList + Collections.sort, TreeSet та мій найкращий з обох світів), і мій завжди виграє. Тестовий файл створює карту з 10000 елементами, значення яких мають навмисно жахливий компаратор, і тоді кожна з трьох стратегій отримує шанс а) сортувати дані та б) перебирати їх. Ось декілька зразків результатів (ви можете самі перевірити):

EDIT: Я додав аспект, який реєструє виклики до Thingy.compareTo (Thingy), а також додав нову стратегію, засновану на PriorityQueues, яка набагато швидша за будь-яке з попередніх рішень (принаймні при сортуванні).

compareTo() calls:123490
Transformer ArrayListTransformer
    Creation: 255885873 ns (0.255885873 seconds) 
    Iteration: 2582591 ns (0.002582591 seconds) 
    Item count: 10000

compareTo() calls:121665
Transformer TreeSetTransformer
    Creation: 199893004 ns (0.199893004 seconds) 
    Iteration: 4848242 ns (0.004848242 seconds) 
    Item count: 10000

compareTo() calls:121665
Transformer BestOfBothWorldsTransformer
    Creation: 216952504 ns (0.216952504 seconds) 
    Iteration: 1604604 ns (0.001604604 seconds) 
    Item count: 10000

compareTo() calls:18819
Transformer PriorityQueueTransformer
    Creation: 35119198 ns (0.035119198 seconds) 
    Iteration: 2803639 ns (0.002803639 seconds) 
    Item count: 10000

Дивно, але мій підхід має найкращі результати в ітерації (я міг би подумати, що не буде відмінностей від підходу ArrayList в ітерації, чи є у мене помилка у моєму тесті?)

Застереження: Я знаю, що це, мабуть, жахливий орієнтир, але це допомагає донести точку до вас, і я, звичайно, не маніпулював ним, щоб перемогти у своєму підході.

(Код має залежність від apache commons / lang для будівельників equals / hashcode / compareTo, але його слід легко переформатувати)

Обов’язково прочитайте мій коментар про TreeSet внизу, якщо ви вирішите реалізувати B)

Якщо ваша програма виконує лише епізодичні сортування, але багато разів перебирає їх, я б сказав, що вам краще використовувати прямий невідсортований список. Відсортуйте його один раз, а потім скористайтеся швидшою ітерацією. Ітерація особливо швидка в списку масивів.

Однак, якщо ви хочете, щоб порядок сортування був гарантований постійно, або, можливо, ви часто додаєте / видаляєте елементи, використовуйте відсортовану колекцію та виконайте хіт на ітерації.

Тож у вашому випадку я б сказав, що А) - кращий варіант. Список сортується один раз, не змінюється і тому виграє від того, що він масив. Ітерація повинна бути дуже швидкою, особливо якщо ви знаєте її ArrayList і можете безпосередньо використовувати ArrayList.get () замість ітератора.

Я б також додав, що TreeSet за визначенням є набором, що означає, що об'єкти є унікальними. TreeSet визначає рівність за допомогою порівнянняTo на вашому Comparator / Comparable. Ви можете легко виявити відсутні дані, якщо спробувати додати два об’єкти, порівняння яких повертає значення 0. Наприклад, додавання "C", "A", "B", "A" до TreeSet поверне "A", "B "," С "

Collections.sort використовує mergeSort, який має O (nlog n).

TreeSetмає червоно-чорне дерево в основі, основні операції має O (logn). Звідси n елементів також має O (nlog n).

Отже, обидва є однаковим великим алгоритмом O.

Вставка в SortedSet є O (log (n)) (АЛЕ! Поточний n, а не остаточний n). Вставка в список - 1.

Сортування за набором SortedSet вже включено до вставки, тому воно дорівнює 0. Сортування у списку - O (n * log (n)).

Отже, загальна складність SortedSet становить O (n * k), k <log (n) для всіх випадків, крім останнього. Натомість загальна складність списку - O (n * log (n) + n), отже O (n * log (n)).

Отже, SortedSet математично має найкращі показники. Але врешті-решт, у вас є набір замість списку (оскільки SortedList не існує), і Set надає вам менше функцій, ніж List. Отже, на мій погляд, найкращим рішенням для доступних функцій та продуктивності є те, що запропонував Шон Патрік Флойд:

• використовуйте SortedSet для вставки,
• помістіть SortedSet як параметр для створення списку для повернення.

Чудове запитання та чудові відповіді. Просто думав, що додам кілька моментів, щоб врахувати:

1. Якщо ваша Колекція для сортування недовговічна, наприклад, використовується як аргумент методу, і вам потрібен список, відсортований у методі, тоді використовуйте Collections.sort (колекція). Або якщо це довгожитель, але сортувати його потрібно дуже рідко.

Обґрунтування: Відсортований збірник потрібен для чогось конкретного, і ви, ймовірно, не будете часто додавати чи видаляти. Тож ви насправді не піклуєтесь про елементи колекції, як тільки вона буде відсортована. Ви в основному:

сортувати -> використовувати -> забути

Якщо ви додасте новий елемент до відсортованої колекції, вам доведеться сортувати колекцію ще раз, оскільки порядок не гарантується при вставці нового елемента.

2. Якщо ваша Колекція, яку потрібно відсортувати, є довгожителем та / або якщо це поле в класі, і Вам потрібно її сортувати постійно, тоді слід використовувати відсортовану структуру даних, таку як TreeSet.

Обґрунтування: Ви завжди дбаєте про порядок збору. Ви хочете, щоб його постійно сортували. Отже, якщо ви постійно додаєте або видаляєте елементи, ви маєте гарантію, що колекція сортується. Отже, в основному:

вставити / видалити -> використовувати його (весь час ви маєте гарантію, що колекція сортується)

Не існує конкретного моменту, коли вам потрібно сортувати колекцію, натомість ви хочете, щоб колекція постійно сортувалась.

Недоліком використання TreeSet є ресурси, необхідні для збереження відсортованої колекції. Він використовує червоно-чорне дерево, і йому потрібні O (log n) витрати часу на операції get, put.

Тоді як якщо ви використовуєте просту колекцію, таку як ArrayList, операції get, add мають O (1) постійний час.