mirror of
https://github.com/krahets/hello-algo.git
synced 2026-08-19 06:50:59 +00:00
Fix multilingual content typos (#1958)
This commit is contained in:
Yudong Jin
@@ -31,7 +31,7 @@ VS Code обладает мощной экосистемой расширени
|
||||
|
||||
### Среда C#
|
||||
|
||||
1. Загрузите и установите [.Net 8.0](https://dotnet.microsoft.com/en-us/download).
|
||||
1. Загрузите и установите [.NET 8.0](https://dotnet.microsoft.com/en-us/download).
|
||||
2. В магазине расширений VS Code найдите `C# Dev Kit` и установите C# Dev Kit ([руководство по настройке](https://code.visualstudio.com/docs/csharp/get-started)).
|
||||
3. Также можно использовать Visual Studio ([руководство по установке](https://learn.microsoft.com/zh-cn/visualstudio/install/install-visual-studio?view=vs-2022)).
|
||||
|
||||
|
||||
@@ -166,7 +166,7 @@
|
||||
// Конструктор
|
||||
class ListNode(x: Int) {
|
||||
val _val: Int = x // Значение узла
|
||||
val next: ListNode? = null // Ссылка на следующий узел
|
||||
var next: ListNode? = null // Ссылка на следующий узел
|
||||
}
|
||||
```
|
||||
|
||||
@@ -658,8 +658,8 @@
|
||||
// Конструктор
|
||||
class ListNode(x: Int) {
|
||||
val _val: Int = x // Значение узла
|
||||
val next: ListNode? = null // Ссылка на следующий узел
|
||||
val prev: ListNode? = null // Ссылка на предыдущий узел
|
||||
var next: ListNode? = null // Ссылка на следующий узел
|
||||
var prev: ListNode? = null // Ссылка на предыдущий узел
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
@@ -30,7 +30,7 @@
|
||||
|
||||
Чтобы гарантировать, что каждый элемент выбирается только один раз, введем булев массив `selected` , где `selected[i]` обозначает, был ли уже выбран `choices[i]` , и на его основе выполним следующую обрезку.
|
||||
|
||||
- После того как сделан выбор `choice[i]` , мы присваиваем `selected[i]` значение $\text{True}$ , тем самым отмечая, что этот элемент уже выбран.
|
||||
- После того как сделан выбор `choices[i]` , мы присваиваем `selected[i]` значение $\text{True}$ , тем самым отмечая, что этот элемент уже выбран.
|
||||
- При обходе списка вариантов `choices` пропускаем все уже выбранные элементы, то есть выполняем обрезку.
|
||||
|
||||
Как показано на рисунке ниже, если в первом раунде мы выберем 1 , во втором - 3 , а в третьем - 2 , то во втором раунде нужно отсечь ветвь элемента 1 , а в третьем - ветви элементов 1 и 3 .
|
||||
|
||||
@@ -23,8 +23,8 @@
|
||||
$$
|
||||
\begin{aligned}
|
||||
& 1 + (-2) \newline
|
||||
& \rightarrow 0000 \. 0001 + 1000 \. 0010 \newline
|
||||
& = 1000 \. 0011 \newline
|
||||
& \rightarrow 0000 \; 0001 + 1000 \; 0010 \newline
|
||||
& = 1000 \; 0011 \newline
|
||||
& \rightarrow -3
|
||||
\end{aligned}
|
||||
$$
|
||||
@@ -34,10 +34,10 @@ $$
|
||||
$$
|
||||
\begin{aligned}
|
||||
& 1 + (-2) \newline
|
||||
& \rightarrow 0000 \. 0001 \. \text{(прямой код)} + 1000 \. 0010 \. \text{(прямой код)} \newline
|
||||
& = 0000 \. 0001 \. \text{(обратный код)} + 1111 \. 1101 \. \text{(обратный код)} \newline
|
||||
& = 1111 \. 1110 \. \text{(обратный код)} \newline
|
||||
& = 1000 \. 0001 \. \text{(прямой код)} \newline
|
||||
& \rightarrow 0000 \; 0001 \; \text{(прямой код)} + 1000 \; 0010 \; \text{(прямой код)} \newline
|
||||
& = 0000 \; 0001 \; \text{(обратный код)} + 1111 \; 1101 \; \text{(обратный код)} \newline
|
||||
& = 1111 \; 1110 \; \text{(обратный код)} \newline
|
||||
& = 1000 \; 0001 \; \text{(прямой код)} \newline
|
||||
& \rightarrow -1
|
||||
\end{aligned}
|
||||
$$
|
||||
@@ -46,8 +46,8 @@ $$
|
||||
|
||||
$$
|
||||
\begin{aligned}
|
||||
+0 & \rightarrow 0000 \. 0000 \newline
|
||||
-0 & \rightarrow 1000 \. 0000
|
||||
+0 & \rightarrow 0000 \; 0000 \newline
|
||||
-0 & \rightarrow 1000 \; 0000
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
@@ -55,25 +55,25 @@ $$
|
||||
|
||||
$$
|
||||
\begin{aligned}
|
||||
-0 \rightarrow \. & 1000 \. 0000 \. \text{(прямой код)} \newline
|
||||
= \. & 1111 \. 1111 \. \text{(обратный код)} \newline
|
||||
= 1 \. & 0000 \. 0000 \. \text{(дополнительный код)} \newline
|
||||
-0 \rightarrow \; & 1000 \; 0000 \; \text{(прямой код)} \newline
|
||||
= \; & 1111 \; 1111 \; \text{(обратный код)} \newline
|
||||
= 1 \; & 0000 \; 0000 \; \text{(дополнительный код)} \newline
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
При добавлении $1$ к обратному коду отрицательного нуля возникает перенос, но длина типа `byte` составляет всего 8 бит, поэтому переполнившаяся в 9-й бит единица отбрасывается. Иными словами, **дополнительный код отрицательного нуля равен $0000 \. 0000$ и совпадает с дополнительным кодом положительного нуля**. Значит, в представлении дополнительного кода существует только один ноль, и проблема неоднозначности положительного и отрицательного нуля тем самым устраняется.
|
||||
При добавлении $1$ к обратному коду отрицательного нуля возникает перенос, но длина типа `byte` составляет всего 8 бит, поэтому переполнившаяся в 9-й бит единица отбрасывается. Иными словами, **дополнительный код отрицательного нуля равен $0000 \; 0000$ и совпадает с дополнительным кодом положительного нуля**. Значит, в представлении дополнительного кода существует только один ноль, и проблема неоднозначности положительного и отрицательного нуля тем самым устраняется.
|
||||
|
||||
Остается последний вопрос: диапазон типа `byte` равен $[-128, 127]$ , откуда берется лишнее отрицательное число $-128$ ? Мы замечаем, что у всех целых чисел из интервала $[-127, +127]$ есть соответствующие прямой, обратный и дополнительный коды, а прямой и дополнительный коды можно преобразовывать друг в друга.
|
||||
|
||||
Однако **дополнительный код $1000 \. 0000$ является исключением: у него нет соответствующего прямого кода**. Согласно правилу преобразования, прямой код для этого дополнительного кода должен быть равен $0000 \. 0000$ . Это очевидное противоречие, потому что такой прямой код обозначает число $0$ , а его дополнительный код должен совпадать с ним самим. Компьютер просто определяет, что этот особый дополнительный код $1000 \. 0000$ представляет число $-128$ . На самом деле результат вычисления $(-1) + (-127)$ в дополнительном коде как раз и равен $-128$ .
|
||||
Однако **дополнительный код $1000 \; 0000$ является исключением: у него нет соответствующего прямого кода**. Согласно правилу преобразования, прямой код для этого дополнительного кода должен быть равен $0000 \; 0000$ . Это очевидное противоречие, потому что такой прямой код обозначает число $0$ , а его дополнительный код должен совпадать с ним самим. Компьютер просто определяет, что этот особый дополнительный код $1000 \; 0000$ представляет число $-128$ . На самом деле результат вычисления $(-1) + (-127)$ в дополнительном коде как раз и равен $-128$ .
|
||||
|
||||
$$
|
||||
\begin{aligned}
|
||||
& (-127) + (-1) \newline
|
||||
& \rightarrow 1111 \. 1111 \. \text{(прямой код)} + 1000 \. 0001 \. \text{(прямой код)} \newline
|
||||
& = 1000 \. 0000 \. \text{(обратный код)} + 1111 \. 1110 \. \text{(обратный код)} \newline
|
||||
& = 1000 \. 0001 \. \text{(дополнительный код)} + 1111 \. 1111 \. \text{(дополнительный код)} \newline
|
||||
& = 1000 \. 0000 \. \text{(дополнительный код)} \newline
|
||||
& \rightarrow 1111 \; 1111 \; \text{(прямой код)} + 1000 \; 0001 \; \text{(прямой код)} \newline
|
||||
& = 1000 \; 0000 \; \text{(обратный код)} + 1111 \; 1110 \; \text{(обратный код)} \newline
|
||||
& = 1000 \; 0001 \; \text{(дополнительный код)} + 1111 \; 1111 \; \text{(дополнительный код)} \newline
|
||||
& = 1000 \; 0000 \; \text{(дополнительный код)} \newline
|
||||
& \rightarrow -128
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
- Прямой код, обратный код и дополнительный код - это три способа кодирования чисел в компьютере, между которыми можно выполнять взаимные преобразования. В прямом коде старший бит целого числа является знаковым, а остальные биты представляют значение числа.
|
||||
- Целые числа в компьютере хранятся в виде дополнительного кода. В таком представлении компьютер может одинаково обрабатывать сложение положительных и отрицательных чисел без специальной аппаратной схемы для вычитания, и при этом исчезает неоднозначность положительного и отрицательного нуля.
|
||||
- Кодирование числа с плавающей точкой состоит из 1 бита знака, 8 битов экспоненты и 23 битов мантиссы. Благодаря наличию экспоненты диапазон значений у чисел с плавающей точкой намного больше, чем у целых, но это достигается ценой потери точности.
|
||||
- ASCII - это самый ранний набор английских символов длиной 1 байт, включающий в общей сложности 127 символов. Набор GBK - распространенный китайский набор символов, включающий более двадцати тысяч иероглифов. Unicode стремится предоставить единый полный стандарт набора символов, включающий символы всех языков мира, чтобы решить проблемы искаженного текста, вызванные несовместимыми способами кодирования.
|
||||
- ASCII - это самый ранний набор английских символов длиной 1 байт, включающий в общей сложности 128 символов. Набор GBK - распространенный китайский набор символов, включающий более двадцати тысяч иероглифов. Unicode стремится предоставить единый полный стандарт набора символов, включающий символы всех языков мира, чтобы решить проблемы искаженного текста, вызванные несовместимыми способами кодирования.
|
||||
- UTF-8 - самый популярный способ кодирования Unicode, обладающий очень хорошей универсальностью. Это кодировка переменной длины, хорошо расширяемая и эффективно использующая память. UTF-16 и UTF-32 относятся к кодировкам фиксированной длины. При кодировании китайского текста UTF-16 занимает меньше места, чем UTF-8. Такие языки программирования, как Java и C#, по умолчанию используют UTF-16.
|
||||
|
||||
### Q & A
|
||||
|
||||
@@ -35,7 +35,7 @@
|
||||
|
||||
Подзадача, соответствующая состоянию $[i, j]$ , такова: **минимальное число операций редактирования, необходимое для преобразования первых $i$ символов строки $s$ в первые $j$ символов строки $t$**.
|
||||
|
||||
Отсюда получается двумерная таблица $dp$ размера $(i+1) \times (j+1)$ .
|
||||
Отсюда получается двумерная таблица $dp$ размера $(n+1) \times (m+1)$ .
|
||||
|
||||
**Шаг 2: найти оптимальную подструктуру и на ее основе вывести уравнение перехода состояния**
|
||||
|
||||
|
||||
@@ -134,7 +134,7 @@ $$
|
||||
|
||||
### Оптимизация пространства
|
||||
|
||||
Поскольку каждое состояние зависит только от состояния в предыдущей строке, можно использовать два массива, которые будут продвигаться вперед по очереди, и тем самым уменьшить пространственную сложность с $O(n^2)$ до $O(n)$ .
|
||||
Поскольку каждое состояние зависит только от состояния в предыдущей строке, можно использовать два массива, которые будут продвигаться вперед по очереди, и тем самым уменьшить пространственную сложность с $O(n \times cap)$ до $O(cap)$ .
|
||||
|
||||
Если пойти дальше, можно спросить: можно ли оптимизировать память так, чтобы использовать только один массив? Наблюдение показывает, что каждое состояние зависит от клетки прямо сверху и клетки слева сверху. Предположим, что у нас есть только один массив, и в момент начала обхода строки $i$ он еще хранит состояния строки $i-1$ .
|
||||
|
||||
|
||||
@@ -21,5 +21,5 @@
|
||||
**Задача о расстоянии редактирования**
|
||||
|
||||
- Расстояние редактирования (расстояние Левенштейна) используется для измерения сходства двух строк и определяется как минимальное число операций редактирования, необходимых для преобразования одной строки в другую. Допустимые операции - вставка, удаление и замена.
|
||||
- В задаче о расстоянии редактирования состояние определяется как минимальное число шагов редактирования, необходимых для преобразования первых $i$ символов строки $s$ в первые $j$ символов строки $t$ . Если $s[i] \ne t[j]$ , то существуют три решения: вставка, удаление и замена, и каждому из них соответствует своя остаточная подзадача. На этой основе выводятся оптимальная подструктура и уравнение перехода состояния. Если же $s[i] = t[j]$ , то редактировать текущий символ не нужно.
|
||||
- В задаче о расстоянии редактирования состояние определяется как минимальное число шагов редактирования, необходимых для преобразования первых $i$ символов строки $s$ в первые $j$ символов строки $t$ . Если $s[i-1] \ne t[j-1]$ , то существуют три решения: вставка, удаление и замена, и каждому из них соответствует своя остаточная подзадача. На этой основе выводятся оптимальная подструктура и уравнение перехода состояния. Если же $s[i-1] = t[j-1]$ , то редактировать текущий символ не нужно.
|
||||
- В задаче о расстоянии редактирования состояние зависит от значений сверху, слева и слева сверху. Поэтому после оптимизации памяти ни прямой, ни обратный обход сам по себе не дает корректного перехода состояния. Для решения этой проблемы значение слева сверху временно сохраняется в отдельной переменной, что делает ситуацию эквивалентной задаче о полном рюкзаке и позволяет использовать прямой обход.
|
||||
|
||||
@@ -91,4 +91,4 @@
|
||||
- **Задача о дробном рюкзаке**: дана группа предметов и грузоподъемность. Требуется выбрать предметы так, чтобы их общий вес не превышал ограничение, а общая ценность была максимальной. Если каждый раз выбирать предмет с наилучшим отношением стоимости к весу, то в некоторых случаях жадный алгоритм дает оптимальный ответ.
|
||||
- **Задача о покупке и продаже акций**: дана история цен акции. Можно совершать несколько сделок, но если акция уже куплена, то до продажи покупать снова нельзя. Цель - получить максимальную прибыль.
|
||||
- **Код Хаффмана**: это жадный алгоритм для сжатия данных без потерь. Построив дерево Хаффмана и каждый раз объединяя два узла с наименьшей частотой, мы получаем дерево с минимальной взвешенной длиной пути, то есть минимальной длиной кодирования.
|
||||
- **Алгоритм Дейкстры**: это жадный алгоритм решения задачи о кратчайших путях от заданной исходной вершины до всех остальных вершин.
|
||||
- **Алгоритм Дейкстры**: для графов с неотрицательными весами ребер это жадный алгоритм решения задачи о кратчайших путях от заданной исходной вершины до всех остальных вершин.
|
||||
|
||||
@@ -51,7 +51,7 @@ $$
|
||||
1. Для заданного целого $n$ непрерывно выделять из него множитель $3$, пока остаток не станет равным $0$, $1$ или $2$.
|
||||
2. Если остаток равен $0$, это означает, что $n$ кратно $3$, и больше ничего делать не нужно.
|
||||
3. Если остаток равен $2$, дальнейшее разбиение не требуется, его нужно сохранить.
|
||||
4. Если остаток равен $1$, то поскольку $2 \times 2 > 1 \times 3$, последний множитель $3$ следует заменить на $2$.
|
||||
4. Если остаток равен $1$, то поскольку $2 \times 2 > 1 \times 3$, последний множитель $3$ и оставшуюся единицу следует заменить двумя множителями $2$.
|
||||
|
||||
### Код реализации
|
||||
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
- Коэффициент загрузки определяется как отношение числа элементов в хеш-таблице к числу бакетов, отражает степень серьезности хеш-коллизий и часто используется как условие запуска расширения хеш-таблицы.
|
||||
- Метод цепочек превращает одиночный элемент в связный список и хранит все конфликтующие элементы в одном списке. Однако слишком длинный список снижает эффективность поиска, поэтому его можно дополнительно преобразовать в красно-черное дерево.
|
||||
- Открытая адресация обрабатывает хеш-коллизии за счет многократного пробирования. Линейное пробирование использует фиксированный шаг, его недостатки - невозможность прямого удаления элементов и склонность к кластеризации. Повторное хеширование использует несколько хеш-функций и по сравнению с линейным пробированием меньше подвержено кластеризации, но требует больше вычислений.
|
||||
- Разные языки программирования выбирают разные стратегии реализации хеш-таблиц. Например, `HashMap` в Java использует метод цепочек, а `Dict` в Python - открытую адресацию.
|
||||
- Разные языки программирования выбирают разные стратегии реализации хеш-таблиц. Например, `HashMap` в Java использует метод цепочек, а `dict` в Python - открытую адресацию.
|
||||
- Для хеш-таблицы желательно, чтобы хеш-алгоритм был детерминированным, быстрым и обеспечивал равномерное распределение. В криптографии от него дополнительно требуют устойчивости к коллизиям и эффекта лавины.
|
||||
- В качестве модуля хеш-алгоритмы обычно используют большое простое число, чтобы максимально обеспечить равномерность распределения хеш-значений и снизить число хеш-коллизий.
|
||||
- К распространенным хеш-алгоритмам относятся MD5, SHA-1, SHA-2 и SHA-3. MD5 часто применяли для проверки целостности файлов, а SHA-2 широко используется в протоколах и приложениях, связанных с безопасностью.
|
||||
|
||||
@@ -31,7 +31,7 @@
|
||||
|
||||
Теперь попробуем оценить временную сложность второго способа построения кучи.
|
||||
|
||||
- Пусть число узлов полного двоичного дерева равно $n$ , тогда число листовых узлов равно $(n + 1) / 2$ , где $/$ означает целочисленное деление вниз. Следовательно, число узлов, которые нужно упорядочивать, равно $(n - 1) / 2$ .
|
||||
- Пусть число узлов полного двоичного дерева равно $n$ , тогда число листовых узлов равно $(n + 1) / 2$ , где $/$ означает целочисленное деление вниз. Следовательно, число узлов, которые нужно упорядочивать, равно $n / 2$ .
|
||||
- В процессе упорядочивания сверху вниз каждый узел в худшем случае может просеяться до листа, поэтому максимальное число итераций равно высоте двоичного дерева $\log n$ .
|
||||
|
||||
Перемножив эти два значения, можно получить временную сложность построения кучи $O(n \log n)$ . **Но эта оценка неточна, потому что мы не учли свойство двоичного дерева: на нижних уровнях узлов гораздо больше, чем на верхних**.
|
||||
|
||||
@@ -41,7 +41,7 @@
|
||||
|
||||
### Преобразование в поиск элемента
|
||||
|
||||
Мы знаем, что если массив не содержит `target` , то в конце поиска указатели $i$ и $j$ будут указывать соответственно на первый элемент, больший `target` , и на первый элемент, меньший `target` .
|
||||
Мы знаем, что если массив не содержит `target` , то в конце поиска указатели $i$ и $j$ будут указывать соответственно на первый элемент, больший `target` , и на самый правый элемент, меньший `target` .
|
||||
|
||||
Следовательно, как показано на рисунке ниже, для поиска левой и правой границы можно сконструировать элемент, которого нет в массиве.
|
||||
|
||||
|
||||
@@ -20,7 +20,7 @@
|
||||
|
||||
Рассмотрим процесс двоичного поиска подробнее: когда `nums[m] < target` , указатель $i$ сдвигается вправо и тем самым приближается к элементу, который больше либо равен `target` . Аналогично указатель $j$ постепенно приближается к элементу, который меньше либо равен `target` .
|
||||
|
||||
Следовательно, после завершения двоичного поиска обязательно выполняется следующее: указатель $i$ указывает на первый элемент, больший `target` , а указатель $j$ указывает на первый элемент, меньший `target` . **Нетрудно сделать вывод, что если массив не содержит `target` , то индекс вставки равен $i$** . Код приведен ниже:
|
||||
Следовательно, после завершения двоичного поиска обязательно выполняется следующее: указатель $i$ указывает на первый элемент, больший `target` , а указатель $j$ указывает на самый правый элемент, меньший `target` . **Нетрудно сделать вывод, что если массив не содержит `target` , то индекс вставки равен $i$** . Код приведен ниже:
|
||||
|
||||
```src
|
||||
[file]{binary_search_insertion}-[class]{}-[func]{binary_search_insertion_simple}
|
||||
@@ -48,7 +48,7 @@
|
||||
- Когда `nums[m] < target` или `nums[m] > target` , это означает, что `target` еще не найден, поэтому используется стандартная операция сужения интервала в двоичном поиске, **благодаря чему указатели $i$ и $j$ приближаются к `target`**.
|
||||
- Когда `nums[m] == target` , это означает, что элементы меньше `target` находятся в интервале $[i, m - 1]$ , поэтому мы используем $j = m - 1$ для сужения интервала, **тем самым приближая указатель $j$ к элементам, меньшим `target`**.
|
||||
|
||||
После завершения цикла указатель $i$ будет указывать на самый левый `target` , а указатель $j$ - на первый элемент, меньший `target` , **поэтому индекс $i$ и является точкой вставки**.
|
||||
После завершения цикла указатель $i$ будет указывать на самый левый `target` , а указатель $j$ - на самый правый элемент, меньший `target` , **поэтому индекс $i$ и является точкой вставки**.
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Блочная сортировка
|
||||
|
||||
Рассмотренные выше алгоритмы сортировки относятся к «сортировкам на основе сравнений»: они упорядочивают данные, сравнивая элементы друг с другом. Временная сложность таких алгоритмов не может быть лучше $O(n \log n)$ . Далее мы рассмотрим несколько «сортировок без сравнений», чья временная сложность может достигать линейного порядка.
|
||||
Рассмотренные выше алгоритмы сортировки относятся к «сортировкам на основе сравнений»: они упорядочивают данные, сравнивая элементы друг с другом. Нижняя граница их временной сложности в худшем случае равна $\Omega(n \log n)$ . Далее мы рассмотрим несколько «сортировок без сравнений», чья временная сложность может достигать линейного порядка.
|
||||
|
||||
<u>Блочная сортировка (bucket sort)</u> является типичным применением стратегии «разделяй и властвуй». Она создает набор упорядоченных по величине блоков, где каждый блок соответствует определенному диапазону данных. Затем элементы равномерно распределяются по этим блокам, внутри каждого блока отдельно выполняется сортировка, а в конце результаты объединяются в порядке блоков.
|
||||
|
||||
|
||||
@@ -51,7 +51,7 @@
|
||||
|
||||
## Характеристики алгоритма
|
||||
|
||||
- **Временная сложность равна $O(n^2)$, сортировка не является адаптивной**: внешний цикл выполняется $n - 1$ раз. В первом раунде длина неотсортированного диапазона равна $n$ , а в последнем - $2$ , то есть отдельные раунды содержат $n$, $n - 1$, $\dots$, $3$, $2$ проходов внутреннего цикла, их сумма равна $\frac{(n - 1)(n + 2)}{2}$ .
|
||||
- **Временная сложность равна $O(n^2)$, сортировка не является адаптивной**: внешний цикл выполняется $n - 1$ раз. Внутренний цикл выполняется $n - 1$ раз в первом раунде и $1$ раз в последнем. Таким образом, число итераций внутреннего цикла по раундам равно $n - 1$, $n - 2$, $\dots$, $2$, $1$, а их сумма равна $\frac{n(n - 1)}{2}$ .
|
||||
- **Пространственная сложность равна $O(1)$, сортировка выполняется на месте**: указатели $i$ и $j$ используют константный объем дополнительной памяти.
|
||||
- **Нестабильная сортировка**: как показано на рисунке ниже, элемент `nums[i]` может быть переставлен вправо от другого равного ему элемента, из-за чего их относительный порядок изменится.
|
||||
|
||||
|
||||
@@ -37,7 +37,7 @@
|
||||
|
||||
**Адаптивность**: <u>адаптивная сортировка</u> умеет использовать уже существующий порядок входных данных, чтобы сократить вычисления и добиться лучшей эффективности. Лучшая временная сложность адаптивных алгоритмов обычно лучше их средней временной сложности.
|
||||
|
||||
**Основанность на сравнении**: <u>сортировка на основе сравнений</u> использует операторы сравнения ($<$, $=$, $>$), чтобы определить относительный порядок элементов и отсортировать массив. Ее теоретически лучшая временная сложность равна $O(n \log n)$ . А вот <u>сортировка без сравнений</u> не опирается на операторы сравнения, поэтому может достигать $O(n)$ , но универсальность у нее ниже.
|
||||
**Основанность на сравнении**: <u>сортировка на основе сравнений</u> использует операторы сравнения ($<$, $=$, $>$), чтобы определить относительный порядок элементов и отсортировать массив. Нижняя граница ее временной сложности в худшем случае равна $\Omega(n \log n)$ . А вот <u>сортировка без сравнений</u> не опирается на операторы сравнения, поэтому может достигать $O(n)$ , но универсальность у нее ниже.
|
||||
|
||||
## Идеальный алгоритм сортировки
|
||||
|
||||
|
||||
@@ -175,7 +175,7 @@
|
||||
|
||||
/* Извлечь элемент из очереди */
|
||||
// Поскольку в основе лежит массив, removeFirst имеет сложность O(n)
|
||||
let pool = queue.removeFirst()
|
||||
let pop = queue.removeFirst()
|
||||
|
||||
/* Получить длину очереди */
|
||||
let size = queue.count
|
||||
|
||||
@@ -205,9 +205,9 @@ AVL-дерево одновременно является и двоичным
|
||||
```kotlin title=""
|
||||
/* Класс узла AVL-дерева */
|
||||
class TreeNode(val _val: Int) { // Значение узла
|
||||
val height: Int = 0 // Высота узла
|
||||
val left: TreeNode? = null // Левый дочерний узел
|
||||
val right: TreeNode? = null // Правый дочерний узел
|
||||
var height: Int = 0 // Высота узла
|
||||
var left: TreeNode? = null // Левый дочерний узел
|
||||
var right: TreeNode? = null // Правый дочерний узел
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
@@ -181,8 +181,8 @@
|
||||
```kotlin title=""
|
||||
/* Класс узла двоичного дерева */
|
||||
class TreeNode(val _val: Int) { // Значение узла
|
||||
val left: TreeNode? = null // Ссылка на левого дочернего узла
|
||||
val right: TreeNode? = null // Ссылка на правого дочернего узла
|
||||
var left: TreeNode? = null // Ссылка на левого дочернего узла
|
||||
var right: TreeNode? = null // Ссылка на правого дочернего узла
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
Reference in New Issue
Block a user