Add ru version (#1865)

* Add Russian docs site baseline

* Add Russian localized codebase

* Polish Russian code wording

* Update ru code translation.

* Update code translation and chapter covers.

* Fix pythontutor extraction.

* Add README and landing page.

* placeholder of profiles

* Use figures of English version

* Remove chapter paperbook
This commit is contained in:
Yudong Jin
2026-03-28 04:24:07 +08:00
committed by GitHub
parent 2ca570cc33
commit 772183705e
1958 changed files with 108186 additions and 0 deletions
@@ -0,0 +1,126 @@
/**
* File: array_hash_map.dart
* Created Time: 2023-03-29
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* Пара ключ-значение */
class Pair {
int key;
String val;
Pair(this.key, this.val);
}
/* Хеш-таблица на основе массива */
class ArrayHashMap {
late List<Pair?> _buckets;
ArrayHashMap() {
// Инициализировать массив, содержащий 100 корзин
_buckets = List.filled(100, null);
}
/* Хеш-функция */
int _hashFunc(int key) {
final int index = key % 100;
return index;
}
/* Операция поиска */
String? get(int key) {
final int index = _hashFunc(key);
final Pair? pair = _buckets[index];
if (pair == null) {
return null;
}
return pair.val;
}
/* Операция добавления */
void put(int key, String val) {
final Pair pair = Pair(key, val);
final int index = _hashFunc(key);
_buckets[index] = pair;
}
/* Операция удаления */
void remove(int key) {
final int index = _hashFunc(key);
_buckets[index] = null;
}
/* Получить все пары ключ-значение */
List<Pair> pairSet() {
List<Pair> pairSet = [];
for (final Pair? pair in _buckets) {
if (pair != null) {
pairSet.add(pair);
}
}
return pairSet;
}
/* Получить все ключи */
List<int> keySet() {
List<int> keySet = [];
for (final Pair? pair in _buckets) {
if (pair != null) {
keySet.add(pair.key);
}
}
return keySet;
}
/* Получить все значения */
List<String> values() {
List<String> valueSet = [];
for (final Pair? pair in _buckets) {
if (pair != null) {
valueSet.add(pair.val);
}
}
return valueSet;
}
/* Вывести хеш-таблицу */
void printHashMap() {
for (final Pair kv in pairSet()) {
print("${kv.key} -> ${kv.val}");
}
}
}
/* Driver Code */
void main() {
/* Инициализация хеш-таблицы */
final ArrayHashMap map = ArrayHashMap();
/* Операция добавления */
// Добавить пару (key, value) в хеш-таблицу
map.put(12836, "Сяо Ха");
map.put(15937, "Сяо Ло");
map.put(16750, "Сяо Суань");
map.put(13276, "Сяо Фа");
map.put(10583, "Сяо Я");
print("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
map.printHashMap();
/* Операция поиска */
// Ввести в хеш-таблицу ключ key и получить значение value
String? name = map.get(15937);
print("\nДля номера 15937 найдено имя $name");
/* Операция удаления */
// Удалить пару (key, value) из хеш-таблицы
map.remove(10583);
print("\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение");
map.printHashMap();
/* Обход хеш-таблицы */
print("\nОтдельный обход пар ключ-значение");
map.pairSet().forEach((kv) => print("${kv.key} -> ${kv.val}"));
print("\nОтдельный обход ключей");
map.keySet().forEach((key) => print("$key"));
print("\nОтдельный обход значений");
map.values().forEach((val) => print("$val"));
}
@@ -0,0 +1,34 @@
/**
* File: built_in_hash.dart
* Created Time: 2023-06-25
* Author: liuyuxin (gvenusleo@gmail.com)
*/
import '../chapter_stack_and_queue/linkedlist_deque.dart';
/* Driver Code */
void main() {
int _num = 3;
int hashNum = _num.hashCode;
print("Хеш-значение целого числа $_num = $hashNum");
bool bol = true;
int hashBol = bol.hashCode;
print("Хеш-значение булева значения $bol = $hashBol");
double dec = 3.14159;
int hashDec = dec.hashCode;
print("Хеш-значение десятичного числа $dec = $hashDec");
String str = "Hello Algo";
int hashStr = str.hashCode;
print("Хеш-значение строки $str = $hashStr");
List arr = [12836, "Сяо Ха"];
int hashArr = arr.hashCode;
print("Хеш-значение массива $arr = $hashArr");
ListNode obj = new ListNode(0);
int hashObj = obj.hashCode;
print("Хеш-значение объекта узла $obj = $hashObj");
}
@@ -0,0 +1,41 @@
/**
* File: hash_map.dart
* Created Time: 2023-03-29
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* Driver Code */
void main() {
/* Инициализация хеш-таблицы */
final Map<int, String> map = {};
/* Операция добавления */
// Добавить пару (key, value) в хеш-таблицу
map[12836] = "Сяо Ха";
map[15937] = "Сяо Ло";
map[16750] = "Сяо Суань";
map[13276] = "Сяо Фа";
map[10583] = "Сяо Я";
print("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
map.forEach((key, value) => print("$key -> $value"));
/* Операция поиска */
// Ввести в хеш-таблицу ключ key и получить значение value
final String? name = map[15937];
print("\nДля номера 15937 найдено имя $name");
/* Операция удаления */
// Удалить пару (key, value) из хеш-таблицы
map.remove(10583);
print("\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение");
map.forEach((key, value) => print("$key -> $value"));
/* Обход хеш-таблицы */
print("\nОтдельный обход пар ключ-значение");
map.forEach((key, value) => print("$key -> $value"));
print("\nОтдельный обход ключей");
map.keys.forEach((key) => print(key));
print("\nОтдельный обход значений");
map.forEach((key, value) => print("$value"));
map.values.forEach((value) => print(value));
}
@@ -0,0 +1,138 @@
/**
* File: hash_map_chaining.dart
* Created Time: 2023-06-24
* Author: liuyuxin (gvenusleo@gmail.com)
*/
import 'array_hash_map.dart';
/* Хеш-таблица с цепочками */
class HashMapChaining {
late int size; // Число пар ключ-значение
late int capacity; // Вместимость хеш-таблицы
late double loadThres; // Порог коэффициента загрузки для запуска расширения
late int extendRatio; // Коэффициент расширения
late List<List<Pair>> buckets; // Массив корзин
/* Конструктор */
HashMapChaining() {
size = 0;
capacity = 4;
loadThres = 2.0 / 3.0;
extendRatio = 2;
buckets = List.generate(capacity, (_) => []);
}
/* Хеш-функция */
int hashFunc(int key) {
return key % capacity;
}
/* Коэффициент загрузки */
double loadFactor() {
return size / capacity;
}
/* Операция поиска */
String? get(int key) {
int index = hashFunc(key);
List<Pair> bucket = buckets[index];
// Обойти корзину; если найден key, вернуть соответствующее val
for (Pair pair in bucket) {
if (pair.key == key) {
return pair.val;
}
}
// Если key не найден, вернуть null
return null;
}
/* Операция добавления */
void put(int key, String val) {
// Когда коэффициент загрузки превышает порог, выполнить расширение
if (loadFactor() > loadThres) {
extend();
}
int index = hashFunc(key);
List<Pair> bucket = buckets[index];
// Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть
for (Pair pair in bucket) {
if (pair.key == key) {
pair.val = val;
return;
}
}
// Если такого key нет, добавить пару ключ-значение в конец
Pair pair = Pair(key, val);
bucket.add(pair);
size++;
}
/* Операция удаления */
void remove(int key) {
int index = hashFunc(key);
List<Pair> bucket = buckets[index];
// Обойти корзину и удалить из нее пару ключ-значение
for (Pair pair in bucket) {
if (pair.key == key) {
bucket.remove(pair);
size--;
break;
}
}
}
/* Расширить хеш-таблицу */
void extend() {
// Временно сохранить исходную хеш-таблицу
List<List<Pair>> bucketsTmp = buckets;
// Инициализация новой хеш-таблицы после расширения
capacity *= extendRatio;
buckets = List.generate(capacity, (_) => []);
size = 0;
// Перенести пары ключ-значение из исходной хеш-таблицы в новую
for (List<Pair> bucket in bucketsTmp) {
for (Pair pair in bucket) {
put(pair.key, pair.val);
}
}
}
/* Вывести хеш-таблицу */
void printHashMap() {
for (List<Pair> bucket in buckets) {
List<String> res = [];
for (Pair pair in bucket) {
res.add("${pair.key} -> ${pair.val}");
}
print(res);
}
}
}
/* Driver Code */
void main() {
/* Инициализация хеш-таблицы */
HashMapChaining map = HashMapChaining();
/* Операция добавления */
// Добавить пару (key, value) в хеш-таблицу
map.put(12836, "Сяо Ха");
map.put(15937, "Сяо Ло");
map.put(16750, "Сяо Суань");
map.put(13276, "Сяо Фа");
map.put(10583, "Сяо Я");
print("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
map.printHashMap();
/* Операция поиска */
// Ввести в хеш-таблицу ключ key и получить значение value
String? name = map.get(13276);
print("\nДля номера 13276 найдено имя ${name}");
/* Операция удаления */
// Удалить пару (key, value) из хеш-таблицы
map.remove(12836);
print("\nПосле удаления 12836 хеш-таблица имеет вид\nКлюч -> Значение");
map.printHashMap();
}
@@ -0,0 +1,157 @@
/**
* File: hash_map_open_addressing.dart
* Created Time: 2023-06-25
* Author: liuyuxin (gvenusleo@gmail.com)
*/
import 'array_hash_map.dart';
/* Хеш-таблица с открытой адресацией */
class HashMapOpenAddressing {
late int _size; // Число пар ключ-значение
int _capacity = 4; // Вместимость хеш-таблицы
double _loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения
int _extendRatio = 2; // Коэффициент расширения
late List<Pair?> _buckets; // Массив корзин
Pair _TOMBSTONE = Pair(-1, "-1"); // Удалить метку
/* Конструктор */
HashMapOpenAddressing() {
_size = 0;
_buckets = List.generate(_capacity, (index) => null);
}
/* Хеш-функция */
int hashFunc(int key) {
return key % _capacity;
}
/* Коэффициент загрузки */
double loadFactor() {
return _size / _capacity;
}
/* Найти индекс корзины, соответствующий key */
int findBucket(int key) {
int index = hashFunc(key);
int firstTombstone = -1;
// Выполнять линейное пробирование и завершить при встрече с пустой корзиной
while (_buckets[index] != null) {
// Если встретился key, вернуть соответствующий индекс корзины
if (_buckets[index]!.key == key) {
// Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс
if (firstTombstone != -1) {
_buckets[firstTombstone] = _buckets[index];
_buckets[index] = _TOMBSTONE;
return firstTombstone; // Вернуть индекс корзины после перемещения
}
return index; // Вернуть индекс корзины
}
// Записать первую встретившуюся метку удаления
if (firstTombstone == -1 && _buckets[index] == _TOMBSTONE) {
firstTombstone = index;
}
// Вычислить индекс корзины; при выходе за конец вернуться к началу
index = (index + 1) % _capacity;
}
// Если key не существует, вернуть индекс точки добавления
return firstTombstone == -1 ? index : firstTombstone;
}
/* Операция поиска */
String? get(int key) {
// Найти индекс корзины, соответствующий key
int index = findBucket(key);
// Если пара ключ-значение найдена, вернуть соответствующее val
if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {
return _buckets[index]!.val;
}
// Если пары ключ-значение не существует, вернуть null
return null;
}
/* Операция добавления */
void put(int key, String val) {
// Когда коэффициент загрузки превышает порог, выполнить расширение
if (loadFactor() > _loadThres) {
extend();
}
// Найти индекс корзины, соответствующий key
int index = findBucket(key);
// Если пара ключ-значение найдена, перезаписать val и вернуть
if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {
_buckets[index]!.val = val;
return;
}
// Если пары ключ-значение нет, добавить ее
_buckets[index] = new Pair(key, val);
_size++;
}
/* Операция удаления */
void remove(int key) {
// Найти индекс корзины, соответствующий key
int index = findBucket(key);
// Если пара ключ-значение найдена, заменить ее меткой удаления
if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {
_buckets[index] = _TOMBSTONE;
_size--;
}
}
/* Расширить хеш-таблицу */
void extend() {
// Временно сохранить исходную хеш-таблицу
List<Pair?> bucketsTmp = _buckets;
// Инициализация новой хеш-таблицы после расширения
_capacity *= _extendRatio;
_buckets = List.generate(_capacity, (index) => null);
_size = 0;
// Перенести пары ключ-значение из исходной хеш-таблицы в новую
for (Pair? pair in bucketsTmp) {
if (pair != null && pair != _TOMBSTONE) {
put(pair.key, pair.val);
}
}
}
/* Вывести хеш-таблицу */
void printHashMap() {
for (Pair? pair in _buckets) {
if (pair == null) {
print("null");
} else if (pair == _TOMBSTONE) {
print("TOMBSTONE");
} else {
print("${pair.key} -> ${pair.val}");
}
}
}
}
/* Driver Code */
void main() {
/* Инициализация хеш-таблицы */
HashMapOpenAddressing map = HashMapOpenAddressing();
/* Операция добавления */
// Добавить пару (key, value) в хеш-таблицу
map.put(12836, "Сяо Ха");
map.put(15937, "Сяо Ло");
map.put(16750, "Сяо Суань");
map.put(13276, "Сяо Фа");
map.put(10583, "Сяо Я");
print("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
map.printHashMap();
/* Операция поиска */
// Ввести в хеш-таблицу ключ key и получить значение value
String? name = map.get(13276);
print("\nДля номера 13276 найдено имя $name");
/* Операция удаления */
// Удалить пару (key, value) из хеш-таблицы
map.remove(16750);
print("\nПосле удаления 16750 хеш-таблица имеет вид\nКлюч -> Значение");
map.printHashMap();
}
@@ -0,0 +1,62 @@
/**
* File: simple_hash.dart
* Created Time: 2023-06-25
* Author: liuyuxin (gvenusleo@gmail.com)
*/
/* Аддитивное хеширование */
int addHash(String key) {
int hash = 0;
final int MODULUS = 1000000007;
for (int i = 0; i < key.length; i++) {
hash = (hash + key.codeUnitAt(i)) % MODULUS;
}
return hash;
}
/* Мультипликативное хеширование */
int mulHash(String key) {
int hash = 0;
final int MODULUS = 1000000007;
for (int i = 0; i < key.length; i++) {
hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;
}
return hash;
}
/* XOR-хеширование */
int xorHash(String key) {
int hash = 0;
final int MODULUS = 1000000007;
for (int i = 0; i < key.length; i++) {
hash ^= key.codeUnitAt(i);
}
return hash & MODULUS;
}
/* Хеширование с циклическим сдвигом */
int rotHash(String key) {
int hash = 0;
final int MODULUS = 1000000007;
for (int i = 0; i < key.length; i++) {
hash = ((hash << 4) ^ (hash >> 28) ^ key.codeUnitAt(i)) % MODULUS;
}
return hash;
}
/* Dirver Code */
void main() {
String key = "Hello Algo";
int hash = addHash(key);
print("Хеш-сумма сложением = $hash");
hash = mulHash(key);
print("Хеш-сумма умножением = $hash");
hash = xorHash(key);
print("Хеш-сумма XOR = $hash");
hash = rotHash(key);
print("Хеш-сумма с циклическим сдвигом = $hash");
}