Я пытаюсь понять различия между Сортировка вставки и Сортировка выбора.
Оба они, похоже, имеют два компонента: несортированный список и отсортированный список. Они оба, кажется, берут один элемент из несортированного списка и помещают его в отсортированный список в нужном месте. Я видел некоторые сайты/книги, говорящие, что сортировка сортировки делает это путем замены по одному, а сортировка вставки просто находит нужное место и вставляет его. Тем не менее, я видел, что в других статьях говорится что-то, говоря, что сортировка вставки также своп. Следовательно, я смущен. Есть ли какой-нибудь канонический источник?
15 ответов
Учитывая список, возьмите текущий элемент и обменивайте его с наименьшим элементом в правой части текущего элемента.
Учитывая список, возьмите текущий элемент и вставьте его в соответствующую позицию списка, настроив список каждый раз, когда вы вставляете. Это похоже на размещение карт в карточной игре.
Время Сложность сортировки выбора всегда n(n - 1)/2 , тогда как сортировка вставки имеет более сложную временную сложность, так как ее наихудшая сложность n(n - 1)/2 . Как правило, это будет меньше или равно сравнению, тогда n(n - 1)/2 .
Оба сортировки сортировки и выбора сортировки имеют внешний цикл (по каждому индексу) и внутренний цикл (по подмножеству индексов). Каждый проход внутреннего контура расширяет отсортированную область на один элемент за счет несортированной области, пока не закончится несортированные элементы.
Разница заключается в том, что делает внутренний цикл:
В сортировке сортировки внутренний цикл находится над несортированными элементами. Каждый проход выбирает один элемент и перемещает его в свое конечное местоположение (в текущем конце отсортированной области).
При сортировке вставки каждый проход внутреннего цикла повторяется по отсортированным элементам. Сортированные элементы смещаются до тех пор, пока петля не найдет нужное место для вставки следующего несортированного элемента.
Итак, в сортировке сортируются отсортированные элементы в порядке вывода и остаются на месте после их поиска. И наоборот, при сортировке вставки несортированные элементы остаются включенными до тех пор, пока не будут использованы в порядке ввода, тогда как элементы отсортированной области будут перемещаться вокруг.
Что касается обмена: выбор сортировки делает одну свопинг за проход внутреннего цикла. Сортировка вставки обычно сохраняет элемент, который должен быть вставлен как temp , перед внутренним циклом, оставляя место для внутреннего цикла смещать отсортированные элементы на единицу, а затем копирует temp в точку ввода после.
Возможно, путаница заключается в том, что вы сравниваете описание сортировки связанного списка с описанием сортировки массива. Но я не могу быть уверен, так как вы не указали свои источники.
Самый простой способ понять алгоритмы сортировки - это часто, чтобы получить подробное описание алгоритма (не такие неопределенные вещи, как "этот сорт использует swap. Где-то я не говорю, где"), получить игровые карты (5-10 должно быть достаточно для простых алгоритмов сортировки) и запустить алгоритм вручную.
Сортировка сортировки: сканирование через несортированные данные, которые ищут наименьший оставшийся элемент, затем поменяйте его на позицию сразу после отсортированных данных. Повторяйте до конца. При сортировке списка вам не нужно менять минимальный элемент на позицию, вместо этого вы можете удалить список node из его старой позиции и вставить его в новый.
Вставка сортировки: возьмите элемент сразу после отсортированных данных, просмотрите отсортированные данные, чтобы найти место для его размещения, и поместите туда. Повторяйте до конца.
Вставка сортировки может использовать swap во время фазы "сканирования", но не обязательно, и это не самый эффективный способ, если вы не сортируете массив типа данных, который: (a) не может быть перемещен, только скопирован или местами; и (b) дороже копирования, чем для обмена. Если сортировка вставки использует swap, то, как она работает, является то, что вы одновременно выполняете поиск места и помещаете туда новый элемент, многократно меняя новый элемент с элементом непосредственно перед ним, до тех пор, пока элемент до него больше, чем Это. Когда вы достигнете элемента, который не больше, вы нашли правильное местоположение и перейдете к следующему новому элементу.
Логика для обоих алгоритмов весьма схожа. Оба они имеют частично отсортированную подматрицу в начале массива. Единственное различие заключается в том, как они ищут следующий элемент, который будет помещен в отсортированный массив.
Сортировка вставки : добавляет следующий элемент в правильное положение;
Сортировка сортировки : выбирает наименьший элемент и обменивает его с текущим элементом;
Кроме того, Сортировка вставки стабильна, в отличие от Выбор Сортировка .
Я реализовал оба в python, и стоит отметить, насколько они похожи:
Def insertion(data): data_size = len(data) current = 1 while current < data_size: for i in range(current): if data < data[i]: temp = data[i] data[i] = data data = temp current += 1 return data
С небольшим изменением можно выполнить алгоритм выбора Сортировка.
Def selection(data): data_size = len(data) current = 0 while current < data_size: for i in range(current, data_size): if data[i] < data: temp = data[i] data[i] = data data = temp current += 1 return data
В двух словах, я думаю, что сортировка сортировки сначала ищет наименьшее значение в массиве, а затем выполняет обмен, тогда как сортировка вставки принимает значение и сравнивает его с каждым значением, оставшимся до него (за ним). Если значение меньше, оно меняет местами. Затем одно и то же значение сравнивается снова, и если оно меньше позади него, оно снова меняет местами. Надеюсь, это имеет смысл!
Выбор Сортировка: по мере того как вы начинаете создавать отсортированный подсписчик, алгоритм гарантирует, что отсортированный подсписчик всегда полностью сортируется не только по его собственным элементам, но также и по полному массиву, то есть как отсортированному, так и несортированному подсписку. Таким образом, новый наименьший элемент, однажды найденный из несортированного подсписок, будет просто добавлен в конец отсортированного подсписок.
Вставка Сортировка: алгоритм снова разделяет массив на две части, но здесь элемент выбирается из второй части и вставлен в правильное положение в первую часть. Это никогда не гарантирует, что первая часть будет сортироваться в терминах полного массива, хотя, конечно, в последнем проходе каждый элемент находится в правильной сортированной позиции.
Я дам еще одну попытку: рассмотрим, что происходит в счастливом случае почти отсортированного массива.
При сортировке массив можно представить как имеющее две части: левая сторона - отсортированная, правая сторона - несортированная.
Вставка сортировки - выберите первый несортированный элемент и попытайтесь найти место для него среди уже отсортированной части. Поскольку вы выполняете поиск справа налево, вполне может случиться так, что первый отсортированный элемент, который вы сравниваете (самый большой, самый правый в левой части), меньше выбранного элемента, поэтому вы можете немедленно продолжить следующий несортированный элемент.
Сортировка сортировки - выберите первый несортированный элемент и попытайтесь найти наименьший элемент всей несортированной части и замените эти два, если желательно. Проблема состоит в том, что, поскольку правая часть является несортированной, вы должны каждый раз мыслить каждый элемент, так как вы не можете быть уверены, есть ли или нет даже меньший элемент, чем выбранный.
ВЫБОР СОРТИРОВКИ
Предположим, что существует массив чисел, написанных определенным/случайным образом, и мы можем сказать, что мы должны упорядочиваться в порядке возрастания. Также возьмите по одному числу за раз и замените их наименьшим номером. доступных в списке. сделав этот шаг, мы в конечном итоге получим желаемый результат.
ВСТАВКА СОРТИРОВКА
Помните о том же предположении, но единственное отличие состоит в том, что на этот раз мы выбираем по одному числу за раз и вставляем его в предварительно отредактированную часть, что уменьшает сравнение и, следовательно, более эффективно.
Короче говоря,
Сортировка сортировки: Выберите первый элемент из несортированного массива и сравните его с оставшимися несортированными элементами. Он похож на сортировку Bubble, но вместо того, чтобы заменять каждый меньший элемент, сохраняет индекс наименьшего элемента обновленным и заменяет его в конце каждого цикла.
Сортировка вставки: . Она противоположна сортировке выбора, где он выбирает первый элемент из несортированного подматрица и сравнивает его с отсортированным подматрицей и вставляет самый маленький найденный элемент и сдвигает все отсортированные элементы от его права до первого несортированного элемента.
Внутренний цикл сортировки вставки проходит через уже отсортированные элементы (в отличие от сортировки сортировки). Это позволяет ему прервать внутренний цикл, когда найдено правильное положение . Который означает, что:
Сортировка выбора должна всегда проходить через все внутренние элементы цикла. Вот почему сортировка вставки в основном предпочтительна для сортировки. Но, с другой стороны, сортировка выбора делает гораздо меньше элементарных свопов, что может быть более важным в некоторых случаях.
Привет, уважаемые читатели. Каким образом выполняется сортировка списка в ? Конечно, можно это сделать в ручную, перетаскивая один за другим. Удобно? Не думаю. Давайте я вам расскажу способ по лучше.
Пример своей работы я буду показывать на примере Word 2013, но этот способ подойдет и к версии Word 2010 и 2007.
Для демонстрации сортировки по возрастанию в Word я возьму небольшой список с именами.
Прежде, чем приступить к делу, необходимо выделить его левой кнопкой мыши. Затем, на вкладке «Главная » в разделе «Абзац » есть специальная кнопка. Какая? Посмотрите на гифке ниже.
В окне «Сортировка текста » можно выбрать Тип данных: текст, число или дата; а также выбрать способ: по возрастанию или убыванию. Я выбрал по возрастанию и тип текст.
Кстати, если нажать на кнопку «Параметры », то можно настроить дополнительные параметры сортировки в Ворде.
Теперь, чтобы завершить наше дело, нужно нажать на кнопку «ОК ». После этого у нас получился список, в котором имена расположены от А до Я.
Если нужно выполнить сортировку в таблице Word, то принцип такой же. Выделяете столбец и делаете те же самые действия. А если у вас цифры, то укажите в типе Числа .
В общем, это все. Даже если нужно отсортировать в Word 2010 по алфавиту, в этом нет ничего сложного, ведь интерфейсы похожи.
Сортировка данных в Excel – инструмент для представления информации в удобном для пользователя виде.
Числовые значения можно отсортировать по возрастанию и убыванию, текстовые – по алфавиту и в обратном порядке. Доступны варианты – по цвету и шрифту, в произвольном порядке, по нескольким условиям. Сортируются столбцы и строки.
Существует два способа открыть меню сортировки:
Часто используемые методы сортировки представлены одной кнопкой на панели задач:
Сортировка таблицы по отдельному столбцу:
Если выделить всю таблицу и выполнить сортировку, то отсортируется первый столбец. Данные в строках станут в соответствии с положением значений в первом столбце.
Программа Excel предоставляет пользователю богатые возможности форматирования. Следовательно, можно оперировать разными форматами.
Сделаем в учебной таблице столбец «Итог» и «зальем» ячейки со значениями разными оттенками. Выполним сортировку по цвету:
Программа отсортировала ячейки по акцентам. Пользователь может самостоятельно выбрать порядок сортировки цвета. Для этого в списке возможностей инструмента выбираем «Настраиваемую сортировку».
В открывшемся окне вводим необходимые параметры:
Здесь можно выбрать порядок представления разных по цвету ячеек.
По такому же принципу сортируются данные по шрифту.
Как задать порядок вторичной сортировки в Excel? Для решения этой задачи нужно задать несколько условий сортировки.
Программа позволяет добавить сразу несколько критериев чтобы выполнить сортировку в особом порядке.
По умолчанию сортируются данные по столбцам. Как осуществить сортировку по строкам в Excel:
Таким образом выполняется сортировка таблицы в Excel по нескольким параметрам.
Встроенные параметры сортировки не позволяют расположить данные в столбце случайным образом. С этой задачей справится функция СЛЧИС.
Например, нужно расположить в случайном порядке набор неких чисел.
Ставим курсор в соседнюю ячейку (слева-справа, не важно). В строку формул вводим СЛЧИС(). Жмем Enter. Копируем формулу на весь столбец – получаем набор случайных чисел.
Теперь отсортируем полученный столбец по возрастанию /убыванию – значения в исходном диапазоне автоматически расположатся в случайном порядке.
Если применить к таблице стандартную сортировку, то при изменении данных она не будет актуальной. Нужно сделать так, чтобы значения сортировались автоматически. Используем формулы.
Если необходимо сделать динамическую сортировку по убыванию, используем функцию НАИБОЛЬШИЙ.
Для динамической сортировки текстовых значений понадобятся формулы массива.
Впоследствии при добавлении данных в таблицу процесс сортирования будет выполняться автоматически.
Создадим массив, в котором после завершения алгоритма будет лежать ответ. Будем поочередно вставлять элементы из исходного массива так, чтобы элементы в массиве-ответе всегда были отсортированы. Асимптотика в среднем и худшем случае – O(n 2), в лучшем – O(n). Реализовывать алгоритм удобнее по-другому (создавать новый массив и реально что-то вставлять в него относительно сложно): просто сделаем так, чтобы отсортирован был некоторый префикс исходного массива, вместо вставки будем менять текущий элемент с предыдущим, пока они стоят в неправильном порядке.Реализация:
void insertionsort(int* l, int* r) { for (int *i = l + 1; i < r; i++) { int* j = i; while (j > l && *(j - 1) > *j) { swap(*(j - 1), *j); j--; } } }
Несколько полезных ссылок:
Реализации:
void shellsort(int* l, int* r) { int sz = r - l; int step = sz / 2; while (step > < r; i++) { int *j = i; int *diff = j - step; while (diff >= l && *diff > *j) { swap(*diff, *j); j = diff; diff = j - step; } } step /= 2; } } void shellsorthib(int* l, int* r) { int sz = r - l; if (sz <= 1) return; int step = 1; while (step < sz) step <<= 1; step >>= 1; step--; while (step >= 1) { for (int *i = l + step; i < r; i++) { int *j = i; int *diff = j - step; while (diff >= l && *diff > *j) { swap(*diff, *j); j = diff; diff = j - step; } } step /= 2; } } int steps; void shellsortsedgwick(int* l, int* r) { int sz = r - l; steps = 1; int q = 1; while (steps * 3 < sz) { if (q % 2 == 0) steps[q] = 9 * (1 << q) - 9 * (1 << (q / 2)) + 1; else steps[q] = 8 * (1 << q) - 6 * (1 << ((q + 1) / 2)) + 1; q++; } q--; for (; q > < r; i++) { int *j = i; int *diff = j - step; while (diff >= l && *diff > *j) { swap(*diff, *j); j = diff; diff = j - step; } } } } void shellsortpratt(int* l, int* r) { int sz = r - l; steps = 1; int cur = 1, q = 1; for (int i = 1; i < sz; i++) { int cur = 1 << i; if (cur > sz / 2) break; for (int j = 1; j < sz; j++) { cur *= 3; if (cur > sz / 2) break; steps = cur; } } insertionsort(steps, steps + q); q--; for (; q >= 0; q--) { int step = steps[q]; for (int *i = l + step; i < r; i++) { int *j = i; int *diff = j - step; while (diff >= l && *diff > *j) { swap(*diff, *j); j = diff; diff = j - step; } } } } void myshell1(int* l, int* r) { int sz = r - l, q = 1; steps = 1; while (steps < sz) { int s = steps; steps = s * 4 + s / 4; } q--; for (; q >= 0; q--) { int step = steps[q]; for (int *i = l + step; i < r; i++) { int *j = i; int *diff = j - step; while (diff >= l && *diff > *j) { swap(*diff, *j); j = diff; diff = j - step; } } } } void myshell2(int* l, int* r) { int sz = r - l, q = 1; steps = 1; while (steps < sz) { int s = steps; steps = s * 3 + s / 3; } q--; for (; q >= 0; q--) { int step = steps[q]; for (int *i = l + step; i < r; i++) { int *j = i; int *diff = j - step; while (diff >= l && *diff > *j) { swap(*diff, *j); j = diff; diff = j - step; } } } } void myshell3(int* l, int* r) { int sz = r - l, q = 1; steps = 1; while (steps < sz) { int s = steps; steps = s * 4 - s / 5; } q--; for (; q >= 0; q--) { int step = steps[q]; for (int *i = l + step; i < r; i++) { int *j = i; int *diff = j - step; while (diff >= l && *diff > *j) { swap(*diff, *j); j = diff; diff = j - step; } } } }
Реализация:
void treesort(int* l, int* r) {
multiset
Реализация:
void gnomesort(int* l, int* r) { int *i = l; while (i < r) { if (i == l || *(i - 1) <= *i) i++; else swap(*(i - 1), *i), i--; } }
Реализация:
void selectionsort(int* l, int* r) { for (int *i = l; i < r; i++) { int minz = *i, *ind = i; for (int *j = i + 1; j < r; j++) { if (*j < minz) minz = *j, ind = j; } swap(*i, *ind); } }
Реализация:
template
Реализация:
void quicksort(int* l, int* r) { if (r - l <= 1) return; int z = *(l + (r - l) / 2); int* ll = l, *rr = r - 1; while (ll <= rr) { while (*ll < z) ll++; while (*rr > z) rr--; if (ll <= rr) { swap(*ll, *rr); ll++; rr--; } } if (l < rr) quicksort(l, rr + 1); if (ll < r) quicksort(ll, r); } void quickinssort(int* l, int* r) { if (r - l <= 32) { insertionsort(l, r); return; } int z = *(l + (r - l) / 2); int* ll = l, *rr = r - 1; while (ll <= rr) { while (*ll < z) ll++; while (*rr > z) rr--; if (ll <= rr) { swap(*ll, *rr); ll++; rr--; } } if (l < rr) quickinssort(l, rr + 1); if (ll < r) quickinssort(ll, r); }
Реализация:
void merge(int* l, int* m, int* r, int* temp) { int *cl = l, *cr = m, cur = 0; while (cl < m && cr < r) { if (*cl < *cr) temp = *cl, cl++; else temp = *cr, cr++; } while (cl < m) temp = *cl, cl++; while (cr < r) temp = *cr, cr++; cur = 0; for (int* i = l; i < r; i++) *i = temp; } void _mergesort(int* l, int* r, int* temp) { if (r - l <= 1) return; int *m = l + (r - l) / 2; _mergesort(l, m, temp); _mergesort(m, r, temp); merge(l, m, r, temp); } void mergesort(int* l, int* r) { int* temp = new int; _mergesort(l, r, temp); delete temp; } void _mergeinssort(int* l, int* r, int* temp) { if (r - l <= 32) { insertionsort(l, r); return; } int *m = l + (r - l) / 2; _mergeinssort(l, m, temp); _mergeinssort(m, r, temp); merge(l, m, r, temp); } void mergeinssort(int* l, int* r) { int* temp = new int; _mergeinssort(l, r, temp); delete temp; }
1) Не будем создавать новых массивов. Для этого воспользуемся техникой сортировки подсчетом – подсчитаем количество элементов в каждом блоке, префиксные суммы и, таким образом, позицию каждого элемента в массиве.
2) Не будем запускаться из пустых блоков. Занесем индексы непустых блоков в отдельный массив и запустимся только от них.
3) Проверим, отсортирован ли массив. Это не ухудшит время работы, так как все равно нужно сделать проход с целью нахождения минимума и максимума, однако позволит алгоритму ускориться на частично отсортированных данных, ведь элементы вставляются в новые блоки в том же порядке, что и в исходном массиве.
4) Поскольку алгоритм получился довольно громоздким, при небольшом количестве элементов он крайне неэффективен. До такой степени, что переход на сортировку вставками ускоряет работу примерно в 10 раз.
Осталось только понять, какое количество блоков нужно выбрать. На рандомизированных тестах мне удалось получить следующую оценку: 1500 блоков для 10 7 элементов и 3000 для 10 8 . Подобрать формулу не удалось – время работы ухудшалось в несколько раз.
Реализация:
void _newbucketsort(int* l, int* r, int* temp) { if (r - l <= 64) { insertionsort(l, r); return; } int minz = *l, maxz = *l; bool is_sorted = true; for (int *i = l + 1; i < r; i++) { minz = min(minz, *i); maxz = max(maxz, *i); if (*i < *(i - 1)) is_sorted = false; } if (is_sorted) return; int diff = maxz - minz + 1; int numbuckets; if (r - l <= 1e7) numbuckets = 1500; else numbuckets = 3000; int range = (diff + numbuckets - 1) / numbuckets; int* cnt = new int; for (int i = 0; i <= numbuckets; i++) cnt[i] = 0; int cur = 0; for (int* i = l; i < r; i++) { temp = *i; int ind = (*i - minz) / range; cnt++; } int sz = 0; for (int i = 1; i <= numbuckets; i++) if (cnt[i]) sz++; int* run = new int; cur = 0; for (int i = 1; i <= numbuckets; i++) if (cnt[i]) run = i - 1; for (int i = 1; i <= numbuckets; i++) cnt[i] += cnt; cur = 0; for (int *i = l; i < r; i++) { int ind = (temp - minz) / range; *(l + cnt) = temp; cur++; cnt++; } for (int i = 0; i < sz; i++) { int r = run[i]; if (r != 0) _newbucketsort(l + cnt, l + cnt[r], temp); else _newbucketsort(l, l + cnt[r], temp); } delete run; delete cnt; } void newbucketsort(int* l, int* r) { int *temp = new int; _newbucketsort(l, r, temp); delete temp; }
Реализация:
int digit(int n, int k, int N, int M) { return (n >> (N * k) & (M - 1)); } void _radixsort(int* l, int* r, int N) { int k = (32 + N - 1) / N; int M = 1 << N; int sz = r - l; int* b = new int; int* c = new int[M]; for (int i = 0; i < k; i++) { for (int j = 0; j < M; j++) c[j] = 0; for (int* j = l; j < r; j++) c++; for (int j = 1; j < M; j++) c[j] += c; for (int* j = r - 1; j >= l; j--) b[--c] = *j; int cur = 0; for (int* j = l; j < r; j++) *j = b; } delete b; delete c; } void radixsort(int* l, int* r) { _radixsort(l, r, 8); }
Реализация:
void _radixsortmsd(int* l, int* r, int N, int d, int* temp) { if (d == -1) return; if (r - l <= 32) { insertionsort(l, r); return; } int M = 1 << N; int* cnt = new int; for (int i = 0; i <= M; i++) cnt[i] = 0; int cur = 0; for (int* i = l; i < r; i++) { temp = *i; cnt++; } int sz = 0; for (int i = 1; i <= M; i++) if (cnt[i]) sz++; int* run = new int; cur = 0; for (int i = 1; i <= M; i++) if (cnt[i]) run = i - 1; for (int i = 1; i <= M; i++) cnt[i] += cnt; cur = 0; for (int *i = l; i < r; i++) { int ind = digit(temp, d, N, M); *(l + cnt) = temp; cur++; cnt++; } for (int i = 0; i < sz; i++) { int r = run[i]; if (r != 0) _radixsortmsd(l + cnt, l + cnt[r], N, d - 1, temp); else _radixsortmsd(l, l + cnt[r], N, d - 1, temp); } delete run; delete cnt; } void radixsortmsd(int* l, int* r) { int* temp = new int; _radixsortmsd(l, r, 8, 3, temp); delete temp; }
Реализация:
void bitseqsort(int* l, int* r, bool inv) { if (r - l <= 1) return; int *m = l + (r - l) / 2; for (int *i = l, *j = m; i < m && j < r; i++, j++) { if (inv ^ (*i > *j)) swap(*i, *j); } bitseqsort(l, m, inv); bitseqsort(m, r, inv); } void makebitonic(int* l, int* r) { if (r - l <= 1) return; int *m = l + (r - l) / 2; makebitonic(l, m); bitseqsort(l, m, 0); makebitonic(m, r); bitseqsort(m, r, 1); } void bitonicsort(int* l, int* r) { int n = 1; int inf = *max_element(l, r) + 1; while (n < r - l) n *= 2; int* a = new int[n]; int cur = 0; for (int *i = l; i < r; i++) a = *i; while (cur < n) a = inf; makebitonic(a, a + n); bitseqsort(a, a + n, 0); cur = 0; for (int *i = l; i < r; i++) *i = a; delete a; }
Подробнее timsort описан здесь:
Реализация:
void _timsort(int* l, int* r, int* temp) {
int sz = r - l;
if (sz <= 64) {
insertionsort(l, r);
return;
}
int minrun = sz, f = 0;
while (minrun >= 64) {
f |= minrun & 1;
minrun >>= 1;
}
minrun += f;
int* cur = l;
stack
Поскольку картинок очень много, они скрыты спойлерами. Немного комментариев по поводу обозначений. Сортировки названы так, как выше, если это сортировка Шелла, то в скобочках указан автор последовательности, к названиям сортировок, переходящих на сортировку вставками, приписано Ins (для компактности). В диаграммах у второй группы тестов обозначена возможная длина отсортированных подмассивов, у третьей группы - количество свопов, у четвертой - количество замен. Общий результат рассчитывался как среднее по четырем группам.
Таблицы
Таблицы
Таблицы
Таблицы
Таблицы
За счет своего абсолютного безразличия к массиву, сортировка выбором, работавшая быстрее всех на случайных данных, все же проиграла сортировке вставками. Гномья сортировка оказалась заметно хуже последней, из-за чего ее практическое применение сомнительно. Шейкерная и пузырьковая сортировки оказались медленнее всех.
Таблицы, 1е6 элементов
Таблицы, 1е7 элементов
Таблицы, 1е6 элементов
Таблицы, 1е7 элементов
Таблицы, 1е6 элементов
Таблицы, 1е7 элементов
Таблицы, 1е6 элементов
Таблицы, 1е7 элементов
Таблицы, 1е6 элементов
Таблицы, 1е7 элементов
Убедительное первое место заняла сортировка Шелла по Хиббарду, не уступив ни в одной промежуточной группе. Возможно, стоило ее отправить в первую группу сортировок, но… она слишком слаба для этого, да и тогда почти никого не было бы в группе. Битонная сортировка довольно уверенно заняла второе место. Третье место при миллионе элементах заняла другая сортировка Шелла, а при десяти миллионах сортировка деревом (асимптотика сказалась). Стоит обратить внимание, что при десятикратном увеличении размера входных данных все алгоритмы, кроме древесной сортировки, замедлились почти в 20 раз, а последняя всего лишь в 13.
Таблицы, 1е7 элементов
Таблицы, 1е8 элементов
Таблицы, 1е7 элементов
Таблицы, 1е8 элементов
Сортировка данных - неотъемлемая часть их анализа. Вам может потребоваться расположить имена в списке по алфавиту, составить список складских запасов и отсортировать его по убыванию или упорядочить строки по цветам или значкам. Сортировка данных помогает быстро визуализировать данные и лучше понимать их, упорядочивать и находить необходимую информацию и в итоге принимать более правильные решения.
Сортировать данные можно по тексту (от А к Я или от Я к А), числам (от наименьших к наибольшим или от наибольших к наименьшим), а также датам и времени (от старых к новым или от новых к старым) в одном или нескольких столбцах. Можно также выполнять сортировку по настраиваемым спискам, которые создаете вы сами (например, списку, состоящему из элементов "Большой", "Средний" и "Маленький"), или по формату, включая цвет ячеек и цвет шрифта, а также по значкам.
Примечания:
Примечания: Возможные проблемы
Сортировка чисел
Примечания:
Сортировка значений даты и времени
Примечания: Возможные проблемы
Сортировка по нескольким столбцам или строкам
Возможно, вы захотите выполнить сортировку по двум или нескольким столбцам или строкам, чтобы сгруппировать данные с одинаковыми значениями в одном столбце или строке, а затем отсортировать эти группы с одинаковыми значениями по другому столбцу или строке. Например, если есть столбцы "Отдел" и "Сотрудник", можно сначала выполнить сортировку по столбцу "Отдел" (для группировки всех сотрудников по отделам), а затем - по имени (для расположения имен сотрудников каждого отдела в алфавитном порядке). Можно одновременно выполнять сортировку по 64 столбцам.
Примечание: Для получения наилучших результатов в сортируемый диапазон нужно включить заголовки столбцов.
Сортировка по цвету ячейки, цвету шрифта или значку
Если диапазон ячеек или столбец таблицы был отформатирован вручную или с помощью условного форматирования с использованием цвета ячеек или цвета шрифта, можно также выполнить сортировку по цветам. Кроме того, можно выполнить сортировку по набору значков, созданных с помощью условного форматирования.
Сортировка по настраиваемым спискам
Для сортировки в порядке, заданном пользователем, можно применять настраиваемые списки. Например, столбец может содержать значения, по которым вы хотите выполнить сортировку, такие как "Высокий", "Средний" и "Низкий". Как настроить сортировку, чтобы сначала отображались значения "Высокий", затем - "Средний", а в конце - "Низкий"? Если отсортировать их в алфавитном порядке (от А до Я), то значения "Высокий" будут отображаться вверху, но за ними окажутся значения "Низкий", а не "Средний". А при сортировке от Я до А значения "Средний" окажутся в самом верху. В действительности значения "Средний" всегда, независимо от порядка сортировки должны отображаться в середине. Вы можете решить эту проблему, создав настраиваемый список.
Сортировка с учетом регистра
Сортировка слева направо
Как правило, сортировка выполняется сверху вниз, однако значения можно отсортировать слева направо.
Примечание: Таблицы не поддерживают возможность сортировки слева направо. Сначала преобразуйте таблицу в диапазон: выделите в ней любую ячейку и выберите пункты Работа с таблицами > Преобразовать в диапазон .
Примечание: При сортировке строк, являющихся частью структуры листа, в Excel сортируются группы наивысшего уровня (уровень 1) таким образом, что порядок расположения строк или столбцов детализации не изменится, даже если они скрыты.
Сортировка по части значения в столбце
Чтобы выполнить сортировку по части значения в столбце, например части кода (789-WDG -34), фамилии (Регина Покровская) или имени (Покровская Регина), сначала необходимо разбить столбец на две или несколько частей таким образом, чтобы значение, по которому нужно выполнить сортировку, оказалось в собственном столбце. Чтобы разбить значения в ячейке на части, можно воспользоваться текстовыми функциями или мастером текстов. Дополнительные сведения и примеры см. в статьях Разбивка текста по разным ячейкам и Разбивка текста по разным столбцам с помощью функций .
Сортировка меньшего диапазона в пределах большего
Предупреждение: Вы можете отсортировать значения в диапазоне, который является частью другого диапазона, однако делать это не рекомендуется, так как в результате будет разорвана связь между отсортированным диапазоном и исходными данными. Если отсортировать данные, как показано ниже, выбранные сотрудники окажутся связаны с другими отделами.
К счастью, Excel выдает предупреждение, если обнаруживает подобную попытку:
Если вы не собирались сортировать данные таким образом, выберите вариант автоматически расширить выделенный диапазон , в противном случае - сортировать в пределах указанного выделения .
Если результат не соответствует желаемому, нажмите кнопку Отменить .
Примечание: Отсортировать подобным образом значения в таблице нельзя.
Дополнительные сведения об основных проблемах с сортировкой
Если результаты сортировки данных не соответствуют ожиданиям, сделайте следующее.
Проверьте, не изменились ли значения, возвращаемые формулами Если сортируемые данные содержат одну или несколько формул, значения, возвращаемые ими, при пересчете листа могут измениться. В этом случае примените сортировку повторно, чтобы получить актуальные результаты.
Перед сортировкой отобразите скрытые строки и столбцы При сортировке по столбцам скрытые строки не перемещаются, а при сортировке по строкам не перемещаются скрытые столбцы. Перед сортировкой данных целесообразно отобразить скрытые строки и столбцы.
Проверьте текущий параметр языкового стандарта Порядок сортировки зависит от выбранного языка. Убедитесь в том, что на панели управления в разделе Региональные параметры или Язык и региональные стандарты задан правильный языковой стандарт. Сведения о том, как изменить параметр языкового стандарта, см. в справке Microsoft Windows.
Вводите заголовки столбцов только в одну строку Если необходимо использовать заголовки из нескольких строк, установите перенос слов в ячейке.
Включите или отключите строку заголовков Обычно рекомендуется отображать строку заголовков при сортировке по столбцам, так как она облегчает восприятие данных. По умолчанию значение в заголовке не включается в сортировку. Но в некоторых случаях может потребоваться включить или отключить заголовок, чтобы значение в заголовке включалось или не включалось в сортировку. Выполните одно из следующих действий.
Чтобы исключить из сортировки первую строку данных (заголовок столбца), на вкладке Главная в группе Редактирование нажмите кнопку Сортировка и фильтр , выберите команду Настраиваемая сортировка и установите флажок .
Чтобы включить в сортировку первую строку данных (так как она не является заголовком столбца), на вкладке Главная в группе Редактирование нажмите кнопку Сортировка и фильтр , выберите команду Настраиваемая сортировка и снимите флажок Мои данные содержат заголовки .