Простая сортировка выбора: (выберите минимальное значение, сначала положите его, а затем первый бит движется назад, так что петля) Первый бит сравнивается с каждым после следующего, каждый раз, когда наименьший бит увенчан, а первый бит обратно Продвигайте (то есть первая только что выбранная цифра является минимальным значением, больше не участвует в сравнении, количество сравнений уменьшается на 1)
Сложность: количество операций, необходимых для выполнения записей, составляет 0-3 (N-1). / 2. Общая временная сложность - O (N2);
Сложность пространства O (1)
Улучшение алгоритма: каждый раз, когда вы сравниваете, он должен положить наименьшее значение в первую очередь, чтобы вы могли сравнить его с концом, найти минимальное значение и положить его непосредственно, устраняя бессмысленные операции переключения и перемещения. Вы также можете изменить направление, сравнить последний бит с каждым предыдущим, и каждый раз сделать максимальное значение дно и выдвигать последний бит вперед.
Исходный код Java:
Кода -копия выглядит следующим образом:
public static void selectsort (date [] days) {
int min;
Дата температура;
для (int i = 0; i <days.length; i ++) {
min = i;
for (int j = min+1; j <days.length; j ++) {
if (days [min] .compare (days [j])> 0) {
min = j;
}
}
if (min! = i) {
Temp = Days [i];
Дни [i] = дни [мин];
Дни [min] = темп;
}
}
}
Дата класса {
int Год, месяц, день;
Дата (int y, int m, int d) {
Год = у;
месяц = м;
день = D;
}
public int compare (дата дата) {
Возврат Год> Дата
: Месяц> Дата
: day> Date.day?
}
public void print () {
System.out.println (год + "" + месяц + "" + день);
}
}
Простой выбор сортировки:
Простая сортировка выбора аналогична сортировке пузырьков (Sort Sort). Единственное отличие состоит в том, что сортировка пузырьков меняет местоположение элемента каждый раз, когда он обнаруживает, что он меньше (или больше), чем текущее значение, в то время как простая сортировка выбора - это выбрать наибольшее значение в оставшихся элементах и обмена данными в текущая позиция.
Например, для набора элементов r = {37, 40, 38, 42, 461, 5, 7, 9, 12}
В первом порядке: 37 прямо обменивается с 5, образуя новую последовательность R1 = {5,40,38,42,461,37,7,9,12}
Во втором порядке: 40 обменивается напрямую с 7, образуя новую последовательность R2 = {5,7,38,42,461,37,40,9,12}
И так далее до последнего элемента (примечание: во втором порядке 38 меньше 42, но они не обмениваются данными).
Вот версия реализации Java, которая просто выбирает сортировку:
Кода -копия выглядит следующим образом:
public static void selectionort (int [] data) {
if (data == null || data.length <= 1)
возвращаться;
int i, j, value, minpos, len = data.length;
int Outter = Len - 1, TMP;
for (i = 0; i <over; i ++) {
value = data [i];
minpos = -1;
for (j = i+1; j <len; j ++) {
if (data [j] <value) {
minpos = j;
value = data [j];
}
}
if (minpos! = -1) {
tmp = data [i];
data [i] = value;
Данные [minpos] = tmp;
}
// for (int k = 0; k <len; k ++) {
// System.out.print (data [k] + ",");
//}
// System.out.println ();
}
}
public static void main (string [] args) {
int [] coll = {
37, 40, 38, 42, 461, 5, 7, 9, 12
};
SelectionSt (Coll);
для (int i = 0; i <coll.length; i ++) {
System.out.print (coll [i] + ",");
}
}
Выбор деревьев
Алгоритм сортировки выбора деревьев - это типичный алгоритм, который торгует пространством на время по сравнению с простой сортировкой выбора. Идея состоит в том, чтобы обработать N -элементы, сортируемые, построить относительно небольшие (n+1)/2 числа, а затем построить относительно небольшие [n+1]/4 числа, пока не появится только один элемент. Построено в полностью двоичное дерево.
При сортировке элемент является наименьшим.
Вот версия для выбора деревьев Java Sortection:
Кода -копия выглядит следующим образом:
public static void treeselectionsort (int [] data) {
if (data == null || data.length <= 1)
возвращаться;
int len = data.length, low = 0, i, j;
// Добавить вспомогательное пространство
int [] tmp = new int [2*len -1];
int tsize = tmp.length;
// построить дерево
for (i = len-1, j = tmp.length-1; i> = 0; i-, j-) {
tmp [j] = data [i];
}
for (i = tsize -1; i> 0; i- = 2) {
tmp [(i-1)/2] = tmp [i]> tmp [i-1]?
}
//конец
// Удалить минимальный узел.
while (low <len) {
данные [low ++] = tmp [0];
for (j = tsize-1; tmp [j]! = tmp [0]; j--);
tmp [j] = integer.max_value;
while (j> 0) {
if (j%2 == 0) {// Если это правый узел
TMP [(J-1)/2] = TMP [J]> TMP [J-1]? TMP [J-1]: TMP [J];
J = (J-1)/2;
} else {// Если это левый узел
TMP [J/2] = TMP [J]> TMP [J+1]?
J = J/2;
}
}
}
}
При построении полного двоичного дерева требуется вспомогательное пространство 2*n -1 для коллекции n элементов.
Код:
Кода -копия выглядит следующим образом:
while (j> 0) {
if (j%2 == 0) {// Если это правый узел
TMP [(J-1)/2] = TMP [J]> TMP [J-1]? TMP [J-1]: TMP [J];
J = (J-1)/2;
} else {// Если это левый узел
TMP [J/2] = TMP [J]> TMP [J+1]?
J = J/2;
}
}
Затем реализуйте рекурсивную конструкцию минимального значения в новом наборе.