From f55e3c220268d106b19689ef5ac1c2d36ea36437 Mon Sep 17 00:00:00 2001
From: name <your mail>
Date: Mon, 8 Aug 2022 08:38:11 -0700
Subject: [PATCH 1/6] update-readme
---
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 4a870ccfed..f261b86e30 100644
--- a/README.md
+++ b/README.md
@@ -277,7 +277,7 @@ npm test -- 'LinkedList'
**Troubleshooting**
-In case if linting or testing is failing try to delete the `node_modules` folder and re-install npm packages:
+If linting or testing is failing, try to delete the `node_modules` folder and re-install npm packages:
```
rm -rf ./node_modules
From 13521b2fc486354a467386e7ed9d092e7992268a Mon Sep 17 00:00:00 2001
From: name <your mail>
Date: Tue, 9 Aug 2022 16:17:36 -0700
Subject: [PATCH 2/6] deploy
---
src/algorithms/graph/breadth-first-search/README.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/algorithms/graph/breadth-first-search/README.md b/src/algorithms/graph/breadth-first-search/README.md
index 32ec3e815c..06073abd8b 100644
--- a/src/algorithms/graph/breadth-first-search/README.md
+++ b/src/algorithms/graph/breadth-first-search/README.md
@@ -1,7 +1,7 @@
# Breadth-First Search (BFS)
-Breadth-first search (BFS) is an algorithm for traversing
-or searching tree or graph data structures. It starts at
+Breadth-first search (BFS) is an algorithm for traversing,
+searching tree, or graph data structures. It starts at
the tree root (or some arbitrary node of a graph, sometimes
referred to as a 'search key') and explores the neighbor
nodes first, before moving to the next level neighbors.
From 7e8d5689ab48b3bcd92ea1c70abd9d48dcd299b3 Mon Sep 17 00:00:00 2001
From: name <your mail>
Date: Thu, 25 Aug 2022 16:41:58 -0700
Subject: [PATCH 3/6] deploy
---
README.ma-MA.md | 364 ++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 364 insertions(+)
create mode 100644 README.ma-MA.md
diff --git a/README.ma-MA.md b/README.ma-MA.md
new file mode 100644
index 0000000000..0f75b78a12
--- /dev/null
+++ b/README.ma-MA.md
@@ -0,0 +1,364 @@
+# Algoritma JavaScript dan Struktur Data
+
+> 🇺🇦 UKRAINE [SEDANG DISERANG](https://twitter.com/MFA_Ukraine) OLEH TENTERA RUSIA. ORANG AWAM SEMAKIN DIBUNUH. KAWASAN KEDIAMAN SEMAKIN DIBOM.
+> - Bantu Ukraine melalui [Bank Negara Ukraine](https://bank.gov.ua/en/news/all/natsionalniy-bank-vidkriv-spetsrahunok-dlya-zboru-koshtiv-na-potrebi-armiyi)
+> - Bantu Ukraine melalui dana [SaveLife](https://savelife.in.ua/en/donate-en/)
+> - Maklumat lanjut tentang [war.ukraine.ua](https://war.ukraine.ua/)
+
+[](https://github.com/trekhleb/javascript-algorithms/actions?query=workflow% 3ACI+cawangan%3Amaster)
+[](https://codecov.io/gh/trekhleb/javascript-algorithms)
+
+Repositori ini mengandungi banyak contoh berasaskan JavaScript
+algoritma dan struktur data yang popular.
+
+Setiap algoritma dan struktur data mempunyai README tersendiri
+dengan penjelasan dan pautan berkaitan untuk bacaan lanjut (termasuk yang
+kepada video YouTube).
+
+_Baca ini dalam bahasa lain:_
+[_简体中文_](README.zh-CN.md),
+[_繁體中文_](README.zh-TW.md),
+[_한국어_](README.ko-KR.md),
+[_日本語_](README.ja-JP.md),
+[_Polski_](README.pl-PL.md),
+[_Français_](README.fr-FR.md),
+[_Español_](README.es-ES.md),
+[_Português_](README.pt-BR.md),
+[_Русский_](README.ru-RU.md),
+[_Türk_](README.tr-TR.md),
+[_Italiana_](README.it-IT.md),
+[_Bahasa Indonesia_](README.id-ID.md),
+[_Українська_](README.uk-UA.md),
+[_Arab_](README.ar-AR.md),
+[_Tiếng Việt_](README.vi-VN.md),
+[_Deutsch_](README.de-DE.md)
+
+*☝ Ambil perhatian bahawa projek ini bertujuan untuk digunakan untuk tujuan pembelajaran dan penyelidikan
+sahaja, dan ia **tidak** bertujuan untuk digunakan untuk pengeluaran.*
+
+## Struktur Data
+
+Struktur data ialah cara tertentu untuk mengatur dan menyimpan data dalam komputer supaya ia boleh
+boleh diakses dan diubah suai dengan cekap. Lebih tepat lagi, struktur data ialah himpunan data
+nilai, hubungan di antara mereka, dan fungsi atau operasi yang boleh digunakan
+data itu.
+
+`B` - Pemula, `A` - Lanjutan
+
+* `B` [Senarai Terpaut](src/struktur-data/senarai-terpaut)
+* `B` [Senarai Terpaut Berganda](src/struktur-data/senarai-berpaut-dua)
+* `B` [Barisan](src/struktur-data/baris gilir)
+* `B` [Timbunan](src/struktur-data/tindanan)
+* `B` [Jadual Hash](src/struktur-data/jadual cincang)
+* `B` [Timbunan](src/struktur-data/timbunan) - versi timbunan maks dan min
+* `B` [Baris Keutamaan](src/struktur-data/baris gilir keutamaan)
+* `A` [Trie](src/data-structures/trie)
+* `A` [Pokok](src/struktur-data/pokok)
+ * `A` [Pokok Carian Perduaan](src/struktur-data/pokok/pokok-cari-perduaan)
+ * `A` [AVL Tree](src/data-structures/tree/avl-tree)
+ * `A` [Pokok Merah-Hitam](src/struktur-data/pokok/pokok-merah-hitam)
+ * `A` [Pokok Segmen](src/data-structures/tree/segment-tree) - dengan contoh pertanyaan julat min/maks/jumlah
+ * `A` [Pokok Fenwick](src/struktur-data/pokok/pokok-fenwick) (Pokok Berindeks Perduaan)
+* `A` [Graf](src/struktur-data/graf) (kedua-dua terarah dan tidak terarah)
+* `A` [Set Terpisah](src/struktur-data/set-terpisah)
+* `A` [Bloom Filter](src/data-structures/bloom-filter)
+
+## Algoritma
+
+Algoritma ialah spesifikasi yang tidak jelas tentang cara menyelesaikan kelas masalah. Ia adalah
+satu set peraturan yang mentakrifkan dengan tepat urutan operasi.
+
+`B` - Pemula, `A` - Lanjutan
+
+### Algoritma mengikut Topik
+
+* **Matematik**
+ * `B` [Manipulasi Bit](src/algoritma/matematik/bit) - set/dapatkan/kemas kini/kosongkan bit, darab/bahagi dengan dua, jadikan negatif dsb.
+ * `B` [Titik Terapung Perduaan](src/algoritma/matematik/titik terapung binari) - perwakilan binari nombor titik terapung.
+ * `B` [Factorial](src/algoritma/matematik/faktorial)
+ * `B` [Nombor Fibonacci](src/algoritma/matematik/fibonacci) - versi klasik dan bentuk tertutup
+ * `B` [Faktor Perdana](src/algoritma/matematik/faktor-prima) - mencari faktor perdana dan mengiranya menggunakan teorem Hardy-Ramanujan
+ * `B` [Ujian Primaliti](src/algoritma/matematik/ujian-primaliti) (kaedah pembahagian percubaan)
+ * `B` [Algoritma Euclidean](src/algorithm/math/euclidean-algorithm) - kira Pembahagi Sepunya Terhebat (GCD)
+ * `B` [Garab Sepunya Terkecil](src/algoritma/matematik/bilangan-paling-biasa) (LCM)
+ * `B` [Ayak Eratosthenes](src/algoritma/matematik/ayak-eratosthenes) - mencari semua nombor perdana sehingga mana-mana had tertentu
+ * `B` [Adalah Kuasa Dua](src/algoritma/math/is-power-of-two) - semak sama ada nombor itu kuasa dua (algoritma naif dan bitwise)
+ * `B` [Segitiga Pascal](src/algoritma/matematik/segitiga-pascal)
+ * `B` [Nombor Kompleks](src/algoritma/matematik/nombor-kompleks) - nombor kompleks dan operasi asas dengannya
+ * `B` [Radian & Darjah](src/algoritma/matematik/radian) - penukaran radian kepada darjah dan ke belakang
+ * `B` [Fast Powering](src/algorithm/math/fast-powering)
+ * `B` [Kaedah Horner](src/algoritma/matematik/kaedah-horner) - penilaian polinomial
+ * `B` [Matriks](src/algoritma/matematik/matriks) - matriks dan operasi matriks asas (pendaraban, transposisi, dsb.)
+ * `B` [Jarak Euclidean](src/algoritma/matematik/jarak-euclidean) - jarak antara dua titik/vektor/matriks
+ * `A` [Pembahagian Integer](src/algoritma/matematik/integer-partition)
+ * `A` [Akar Kuasa Dua](src/algoritma/matematik/akar-kuadrat) - Kaedah Newton
+ * `A` [Algoritma Liu Hui π](src/algoritma/math/liu-hui) - anggaran π pengiraan berdasarkan N-gons
+ * `A` [Transformasi Fourier Diskret](src/algoritma/matematik/fourier-transform) - menguraikan fungsi masa (suatu isyarat) kepada frekuensi yang membentuknya
+* **Set**
+ * `B` [Produk Cartesian](src/algoritma/set/produk cartesian) - hasil daripada berbilang set
+ * `B` [Fisher–Yates Shuffle](src/algoritma/sets/fisher-yates) - pilih atur rawak bagi urutan terhingga
+ * `A` [Set Kuasa](src/algoritma/set/set-kuasa) - semua subset set (penyelesaian bitwise dan backtracking)
+ * `A` [Permutasi](src/algoritma/set/permutasi) (dengan dan tanpa ulangan)
+ * `A` [Gabungan](src/algoritma/set/gabungan) (dengan dan tanpa ulangan)
+ * `A` [Turutan Sepunya Terpanjang](src/algoritma/set/susulan-biasa-terpanjang) (LCS)
+ * `A` [Surutan Bertambah Terpanjang](src/algoritma/set/susulan-bertambah-panjang)
+ * `A` [Jurutan Sepunya Terpendek](src/algoritma/set/jujukan-sepunya-terpendek) (SCS)
+ * `A` [Masalah Knapsack](src/algorithms/sets/knapsack-problem) - "0/1" dan "Unbound"
+ * `A` [Maximum Subarray](src/algorithm/sets/maximum-subarray) - versi "Brute Force" dan "Dynamic Programming" (Kadane's)
+ * `A` [Jumlah Gabungan](src/algoritma/set/jumlah-gabungan) - cari semua gabungan yang membentuk jumlah tertentu
+* **Rentetan**
+ * `B` [Jarak Hamming](src/algoritma/rentetan/jarak hamming) - bilangan kedudukan di mana simbol berbeza
+ * `B` [Palindrome](src/algorithm/string/palindrome) - semak sama ada rentetan adalah sama secara terbalik
+ * `A` [Jarak Levenshtein](src/algoritma/rentetan/levenshtein-jarak) - jarak edit minimum antara dua jujukan
+ * `A` [Algoritma Knuth–Morris–Pratt](src/algorithm/string/knuth-morris-pratt) (Algoritma KMP) - carian subrentetan (padanan corak)
+ * `A` [Z Algoritma](src/algorithm/string/z-algorithm) - carian subrentetan (padanan corak)
+ * `A` [Algoritma Rabin Karp](src/algorithm/string/rabin-karp) - carian subrentetan
+ * `A` [Subrentetan Biasa Terpanjang](src/algoritma/rentetan/subrentetan-biasa-terpanjang)
+ * `A` [Padanan Ungkapan Biasa](src/algoritma/rentetan/padanan-ungkapan-biasa)
+ * **Carian**
+ * `B` [Carian Linear](src/algorithm/search/linear-search)
+ * `B` [Cari Lompat](src/algorithm/search/jump-search) (atau Carian Sekat) - cari dalam tatasusunan yang diisih
+ * `B` [Carian Binari](src/algorithm/search/binary-search) - cari dalam tatasusunan yang diisih
+ * `B` [Carian Interpolasi](src/algoritma/search/interpolation-search) - cari dalam tatasusunan tersusun yang diedarkan secara seragam
+* **Menyusun**
+ * `B` [Isih Buih](src/algoritma/isih/isih-buih)
+ * `B` [Isih Pilihan](src/algoritma/isih/isih-pilihan)
+ * `B` [Isih Sisipan](src/algoritma/isih/isihan-sisipan)
+ * `B` [Isih Timbunan](src/algoritma/isih/isih-timbun)
+ * `B` [Isih Gabung](src/algoritma/isih/isih-gabung)
+ * `B` [Quicksort](src/algorithm/sorting/quick-sort) - pelaksanaan di tempat dan bukan di tempat
+ * `B` [Shellsort](src/algoritm/sorting/shell-sort)
+ * `B` [Isih Mengira](src/algoritma/isihan/isihan-kira)
+ * `B` [Isih Radix](src/algoritma/isih/isih-radix)
+* **Senarai Terpaut**
+ * `B` [Straight Traversal](src/algorithm/linked-list/traversal)
+ * `B` [Reverse Traversal](src/algorithm/linked-list/reverse-traversal)
+* **Pokok**
+ * `B` [Depth-First Search](src/algorithm/tree/depth-first-search) (DFS)
+ * `B` [Breadth-First-search](src/algorithm/tree/breadth-first-search) (BFS)
+* **Graf**
+ * `B` [Depth-First Search](src/algorithm/graph/depth-first-search) (DFS)
+ * `B` [Breadth-First Search](src/algorithm/graph/breadth-first-search) (BFS)
+ * `B` [Algoritma Kruskal](src/algoritma/graf/kruskal) - mencari Pokok Spanning Minimum (MST) untuk graf tidak berwajaran
+ * `A` [Algoritma Dijkstra](src/algorithm/graph/dijkstra) - mencari laluan terpendek ke semua bucu graf dari bucu tunggal
+ * `A` [Algoritma Bellman-Ford](src/algoritma/graf/bellman-ford) - mencari laluan terpendek ke semua bucu graf daripada bucu tunggal
+ * `A` [Algoritma Floyd-Warshall](src/algorithm/graph/floyd-warshall) - cari laluan terpendek antara semua pasangan bucu
+ * `A` [Detect Cycle](src/algorithm/graph/detect-cycle) - untuk kedua-dua graf terarah dan tidak terarah (versi berasaskan DFS dan Disjoint Set)
+ * `A` [Algoritma Prim](src/algoritma/graf/prim) - mencari Pokok Spanning Minimum (MST) untuk graf tidak berwajaran
+ * `A` [Isih Topologi](src/algoritma/graf/isihan-topologi) - Kaedah DFS
+ * `A` [Mata Artikulasi](src/algoritma/graf/titik-artikulasi) - Algoritma Tarjan (berasaskan DFS)
+ * `A` [Bridges](src/algorithm/graph/bridges) - algoritma berasaskan DFS
+ * `A` [Eulerian Path and Eulerian Circuit](src/algorithm/graph/eulerian-path) - Algoritma Fleury - Lawati setiap tepi tepat sekali
+ * `A` [Kitaran Hamiltonian](src/algoritma/graf/kitaran-hamilton) - Lawati setiap bucu tepat sekali
+ * `A` [Komponen Bersambung Kuat](src/algoritma/graf/komponen-kuat-bersambung) - Algoritma Kosaraju
+ * `A` [Masalah Jurujual Perjalanan](src/algoritma/graf/jurujual-perjalanan) - laluan terpendek mungkin yang melawati setiap bandar dan kembali ke bandar asal
+* **Kriptografi**
+ * `B` [Cincangan Polinomial](src/algoritma/kriptografi/cincang polinomial) - fungsi cincang bergolek berdasarkan polinomial
+ * `B` [Sifir Pagar Rel](src/algoritma/kriptografi/sifir-pagar-rel) - algoritma sifir transposisi untuk pengekodan mesej
+ * `B` [Caesar Cipher](src/algoritma/kriptografi/caesar-cipher) - sifir penggantian mudah
+ * `B` [Sifir Bukit](src/algoritma/kriptografi/sifir bukit) - sifir penggantian berdasarkan algebra linear
+* **Pembelajaran Mesin**
+ * `B` [NanoNeuron](https://github.com/trekhleb/nano-neuron) - 7 fungsi JS mudah yang menggambarkan bagaimana mesin sebenarnya boleh belajar (perambatan ke hadapan/belakang)
+ * `B` [k-NN](src/algoritma/ml/knn) - algoritma klasifikasi jiran terdekat k
+ * `B` [k-Means](src/algorithm/ml/k-means) - algoritma pengelompokan k-Means
+* **Pemprosesan imej**
+ * `B` [Ukiran Jahitan](src/algoritma/pemprosesan-imej/ukiran-jahitan) - algoritma saiz semula imej sedar kandungan
+* **Statistik**
+ * `B` [Rawak Berwajaran](src/algoritma/statistik/rawak-wajaran) - pilih item rawak daripada senarai berdasarkan berat item
+* **Algoritma evolusi**
+ * `A` [Algoritma genetik](https://github.com/trekhleb/self-parking-car-evolution) - contoh cara algoritma genetik boleh digunakan untuk melatih kereta letak sendiri
+ * **Tidak dikategorikan**
+ * `B` [Menara Hanoi](src/algoritma/tidak dikategorikan/menara-hanoi)
+ * `B` [Putaran Matriks Persegi](src/algoritma/tidak dikategorikan/putaran-matriks-persegi) - algoritma di tempat
+ * `B` [Permainan Lompat](src/algoritma/tidak dikategorikan/permainan lompat) - menjejak ke belakang, pengaturcaraan dinamik (atas ke bawah + bawah ke atas) dan contoh tamak
+ * `B` [Laluan Unik](src/algorithms/uncategorized/unique-paths) - penjejakan ke belakang, pengaturcaraan dinamik dan contoh berasaskan Segitiga Pascal
+ * `B` [Teres Hujan](src/algoritma/tidak dikategorikan/teres hujan) - memerangkap masalah air hujan (versi pengaturcaraan dinamik dan kekerasan)
+ * `B` [Tangga Rekursif](src/algoritma/tidak dikategorikan/tangga rekursif) - kira bilangan cara untuk sampai ke atas (4 penyelesaian)
+ * `B` [Masa Terbaik Untuk Membeli Saham Jual](src/algoritma/tidak dikategorikan/masa-terbaik-untuk-membeli-menjual-saham) - bahagikan dan takluk serta contoh satu laluan
+ * `A` [Masalah N-Queens](src/algoritma/uncategorized/n-queens)
+ * `A` [Lawatan Kesatria](src/algoritma/tidak dikategorikan/jelajah kesatria)
+
+### Algoritma mengikut Paradigma
+
+Paradigma algoritma ialah kaedah atau pendekatan generik yang mendasari reka bentuk kelas
+daripada algoritma. Ia adalah abstraksi yang lebih tinggi daripada tanggapan algoritma, sama seperti an
+algoritma adalah abstraksi yang lebih tinggi daripada program komputer.
+
+* **Brute Force** - lihat semua kemungkinan dan pilih penyelesaian terbaik
+ * `B` [Carian Linear](src/algorithm/search/linear-search)
+ * `B` [Rain Terraces](src/algoritma/uncategorized/rain-teres) - memerangkap masalah air hujan
+ * `B` [Tangga Rekursif](src/algoritma/tak berkategori/tangga rekursif) - kira bilangan cara untuk sampai ke atas
+ * `A` [Subarray Maksimum](src/algoritma/set/subarray maksimum)
+ * `A` [Masalah Jurujual Perjalanan](src/algoritma/graf/jurujual-perjalanan) - laluan terpendek mungkin yang melawati setiap bandar dan kembali ke bandar asal
+ * `A` [Transformasi Fourier Diskret](src/algoritma/matematik/fourier-transform) - menguraikan fungsi masa (suatu isyarat) kepada frekuensi yang membentuknya
+* **Rakus** - pilih pilihan terbaik pada masa semasa, tanpa sebarang pertimbangan untuk masa hadapan
+* `B` [Permainan Lompat](src/algoritma/tidak dikategorikan/permainan lompat)
+ * `A` [Masalah Knapsack Tidak Terikat](src/algoritma/set/masalah-knapsack)
+ * `A` [Algoritma Dijkstra](src/algoritma/graf/dijkstra) - mencari laluan terpendek ke semua bucu graf
+ * `A` [Algoritma Prim](src/algoritma/graf/prim) - mencari Pokok Spanning Minimum (MST) untuk graf tidak berwajaran
+ * `A` [Algoritma Kruskal](src/algoritma/graf/kruskal) - mencari Pokok Spanning Minimum (MST) untuk graf tidak berwajaran
+* **Divide and Conquer** - bahagikan masalah kepada bahagian yang lebih kecil dan kemudian selesaikan bahagian tersebut
+ * `B` [Carian Perduaan](src/algoritma/carian/pencarian-perduaan)
+ * `B` [Menara Hanoi](src/algoritma/tidak dikategorikan/menara-hanoi)
+ * `B` [Segitiga Pascal](src/algoritma/matematik/segitiga-pascal)
+ * `B` [Algoritma Euclidean](src/algorithm/math/euclidean-algorithm) - kira Pembahagi Sepunya Terhebat (GCD)
+ * `B` [Isih Gabung](src/algoritma/isih/isih-gabung)
+ * `B` [Isih Pantas](src/algoritma/isih/isih-pantas)
+ * `B` [Carian Kedalaman-Pertama Pokok](src/algoritma/pokok/carian-pertama-dalam) (DFS)
+ * `B` [Graph Depth-First Search](src/algorithm/graph/depth-first-search) (DFS)
+ * `B` [Matriks](src/algoritma/matematik/matriks) - menjana dan melintasi matriks pelbagai bentuk
+ * `B` [Permainan Lompat](src/algoritma/tidak dikategorikan/permainan lompat)
+ * `B` [Fast Powering](src/algorithm/math/fast-powering)
+ * `B` [Masa Terbaik Untuk Membeli Saham Jual](src/algoritma/tidak dikategorikan/masa-terbaik-untuk-membeli-menjual-saham) - bahagikan dan takluk serta contoh satu laluan
+ * `A` [Permutasi](src/algoritma/set/permutasi) (dengan dan tanpa ulangan)
+ * `A` [Gabungan](src/algoritma/set/gabungan) (dengan dan tanpa ulangan)
+ * `A` [Subarray Maksimum](src/algoritma/set/subarray maksimum)
+* **Pengaturcaraan Dinamik** - bina penyelesaian menggunakan sub-penyelesaian yang ditemui sebelum ini
+ * `B` [Nombor Fibonacci](src/algoritma/matematik/fibonacci)
+ * `B` [Permainan Lompat](src/algoritma/tidak dikategorikan/permainan lompat)
+ * `B` [Laluan Unik](src/algoritma/tidak dikategorikan/laluan-unik)
+ * `B` [Rain Terraces](src/algoritma/uncategorized/rain-teres) - memerangkap masalah air hujan
+
+ * `B` [Tangga Rekursif](src/algoritma/tak berkategori/tangga rekursif) - kira bilangan cara untuk sampai ke atas
+ * `B` [Ukiran Jahitan](src/algoritma/pemprosesan-imej/ukiran-jahitan) - algoritma saiz semula imej sedar kandungan
+ * `A` [Jarak Levenshtein](src/algoritma/rentetan/levenshtein-jarak) - jarak edit minimum antara dua jujukan
+ * `A` [Turutan Sepunya Terpanjang](src/algoritma/set/susulan-biasa-terpanjang) (LCS)
+ * `A` [Subrentetan Biasa Terpanjang](src/algoritma/rentetan/subrentetan-biasa-terpanjang)
+ * `A` [Surutan Bertambah Terpanjang](src/algoritma/set/susulan-bertambah-panjang)
+ * `A` [Jujukan Sepunya Terpendek](src/algoritma/set/jujukan-sepunya-terpendek)
+ * `A` [0/1 Masalah Knapsack](src/algoritma/set/knapsack-problem)
+ * `A` [Pembahagian Integer](src/algoritma/matematik/integer-partition)
+ * `A` [Subarray Maksimum](src/algoritma/set/subarray maksimum)
+ * `A` [Algoritma Bellman-Ford](src/algorithm/graph/bellman-ford) - mencari laluan terpendek ke semua bucu graf
+ * `A` [Algoritma Floyd-Warshall](src/algorithm/graph/floyd-warshall) - cari laluan terpendek antara semua pasangan bucu
+ * `A` [Padanan Ungkapan Biasa](src/algoritma/rentetan/padanan-ungkapan-biasa)
+* **Penjejakan Belakang** - sama seperti kekerasan, cuba jana semua penyelesaian yang mungkin, tetapi setiap kali anda menjana penyelesaian seterusnya anda menguji
+jika ia memenuhi semua syarat, dan hanya kemudian terus menjana penyelesaian seterusnya. Jika tidak, mundur, dan teruskan a
+jalan yang berbeza untuk mencari penyelesaian. Biasanya traversal DFS bagi ruang keadaan sedang digunakan.
+ * `B` [Permainan Lompat](src/algoritma/tidak dikategorikan/permainan lompat)
+ * `B` [Laluan Unik](src/algoritma/tidak dikategorikan/laluan-unik)
+ * `B` [Set Kuasa](src/algoritma/set/set-kuasa) - semua subset set
+ * `A` [Kitaran Hamiltonian](src/algoritma/graf/kitaran-hamilton) - Lawati setiap bucu tepat sekali
+ * `A` [Masalah N-Queens](src/algoritma/uncategorized/n-queens)
+ * `A` [Lawatan Kesatria](src/algoritma/tidak dikategorikan/jelajah kesatria)
+ * `A` [Jumlah Gabungan](src/algoritma/set/jumlah-gabungan) - cari semua gabungan yang membentuk jumlah tertentu
+
+ * **Branch & Bound** - ingat penyelesaian kos terendah yang terdapat pada setiap peringkat penjejakan ke belakang
+cari, dan gunakan kos penyelesaian kos terendah yang ditemui setakat ini sebagai had yang lebih rendah pada kos
+penyelesaian kos termurah untuk masalah, untuk membuang penyelesaian separa dengan kos lebih besar daripada
+penyelesaian kos terendah ditemui setakat ini. Biasanya traversal BFS digabungkan dengan traversal DFS of state-space
+pokok sedang digunakan.
+
+## Cara menggunakan repositori ini
+
+**Pasang semua kebergantungan**
+
+```
+pemasangan npm
+```
+
+**Jalankan ESLint**
+
+Anda mungkin mahu menjalankannya untuk menyemak kualiti kod.
+
+```
+npm run lint
+```
+
+**Jalankan semua ujian**
+
+```
+ujian npm
+```
+
+**Jalankan ujian mengikut nama**
+
+```
+ujian npm -- 'LinkedList'
+```
+
+**Penyelesaian masalah**
+
+Jika linting atau ujian gagal, cuba padamkan folder `node_modules` dan pasang semula pakej npm:
+
+```
+rm -rf ./node_modules
+npm i
+```
+
+Juga pastikan anda menggunakan versi Nod yang betul (`>=14.16.0`). Jika anda menggunakan [nvm](https://github.com/nvm-sh/nvm) untuk pengurusan versi Nod, anda boleh menjalankan `nvm use` daripada folder akar projek dan versi yang betul akan diambil.
+
+**Taman permainan**
+
+Anda boleh bermain dengan struktur data dan algoritma dalam fail `./src/playground/playground.js` dan tulis
+mengujinya dalam `./src/playground/__test__/playground.test.js`.
+
+Kemudian hanya jalankan arahan berikut untuk menguji sama ada kod taman permainan anda berfungsi seperti yang diharapkan:
+
+```
+ujian npm -- 'taman permainan'
+```
+
+## Informasi berguna
+
+### Rujukan
+
+[▶ Struktur Data dan Algoritma di YouTube](https://www.youtube.com/playlist?list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+
+### Notasi O Besar
+
+*Notasi O Besar* digunakan untuk mengklasifikasikan algoritma mengikut cara masa berjalan atau keperluan ruang mereka berkembang apabila saiz input bertambah.
+Pada carta di bawah anda mungkin menemui susunan pertumbuhan algoritma yang paling biasa yang dinyatakan dalam tatatanda Big O.
+
+
+
+Sumber: [Big O Cheat Sheet](http://bigocheatsheet.com/).
+
+Di bawah ialah senarai beberapa tatatanda Big O yang paling banyak digunakan dan perbandingan prestasinya terhadap saiz data input yang berbeza.
+
+| Notasi O Besar | Taip | Pengiraan untuk 10 elemen | Pengiraan untuk 100 elemen | Pengiraan untuk 1000 elemen |
+| -------------- | ----------- | ---------------------------- | ---------------------------- | ------------------------------- |
+| **O(1)** | Malar | 1 | 1 | 1 |
+| **O(log N)** | Logaritma | 3 | 6 | 9 |
+| **O(N)** | Linear | 10 | 100 | 1000 |
+| **O(N log N)** | n log(n) | 30 | 600 | 9000 |
+| **O(N^2)** | Kuadratik | 100 | 10000 | 1000000 |
+| **O(2^N)** | Eksponen | 1024 | 1.26e+29 | 1.07e+301 |
+| **O(N!)** | Faktorial | 3628800 | 9.3e+157 | 4.02e+2567
+
+### Kerumitan Operasi Struktur Data
+
+| Struktur Data | Akses | Cari | Sisipan | Pemadaman | Komen |
+| ------------------------ | :-------: | :-------: | :-------: | :-------: | :-------- |
+| **Array** | 1 | n | n | n | |
+| **Timbunan** | n | n | 1 | 1 | |
+| **Beratur** | n | n | 1 | 1 | |
+| **Senarai Terpaut** | n | n | 1 | n | |
+| **Jadual Hash** | - | n | n | n | Dalam kes kos fungsi cincang yang sempurna ialah O(1) |
+| **Pokok Carian Binari** | n | n | n | n | Dalam kes kos pokok seimbang ialah O(log(n)) |
+| **B-Tree** | log(n) | log(n) | log(n) | log(n) | |
+| **Pokok Merah-Hitam** | log(n) | log(n) | log(n) | log(n) | |
+| **Pokok AVL** | log(n) | log(n) | log(n) | log(n) | |
+| **Penapis Bloom** | - | 1 | 1 | - | Positif palsu mungkin semasa mencari |
+
+### Kerumitan Algoritma Pengisihan Tatasusunan
+
+| Nama | Terbaik | Purata | Paling teruk | Memori | Stabil | Komen |
+| ---------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **Isih gelembung** | n | n<sup>2</sup> | n<sup>2</sup> | 1 | Ya | |
+| **Isihan sisipan** | n | n<sup>2</sup> | n<sup>2</sup> | 1 | Ya | |
+| **Isih pilihan** | n<sup>2</sup> | n<sup>2</sup> | n<sup>2</sup> | 1 | Tidak | |
+| **Isihan timbunan** | n log(n) | n log(n) | n log(n) | 1 | Tidak | |
+| **Isih gabung** | n log(n) | n log(n) | n log(n) | n | Ya | |
+| **Isih cepat** | n log(n) | n log(n) | n<sup>2</sup> | log(n) | Tidak | Quicksort biasanya dilakukan di tempat dengan ruang tindanan O(log(n)) |
+| **Isih cangkerang** | n log(n) | bergantung pada jujukan jurang | n (log(n))<sup>2</sup> | 1 | Tidak | |
+| **Isih mengira** | n + r | n + r | n + r | n + r | Ya | r - nombor terbesar dalam tatasusunan |
+| **Isih Radix** | n * k | n * k | n * k | n + k | Ya | k - panjang kunci terpanjang |
+
+## Penyokong Projek
+
+> Anda boleh menyokong projek ini melalui ❤️️ [GitHub](https://github.com/sponsors/trekhleb) atau ❤️️ [Patreon](https://www.patreon.com/trekhleb).
+
+[Orang yang menyokong projek ini](https://github.com/trekhleb/javascript-algorithms/blob/master/BACKERS.md) `∑ = 0`
+
+> ℹ️ Beberapa lagi [projek](https://trekhleb.dev/projects/) dan [artikel](https://trekhleb.dev/blog/) tentang JavaScript dan algoritma pada [trekhleb.dev](https:/ /trekhleb.dev)
\ No newline at end of file
From ef3b05afa3705ce48a30ebaf2bd9e363bc7ee425 Mon Sep 17 00:00:00 2001
From: name <your mail>
Date: Fri, 26 Aug 2022 16:26:37 -0700
Subject: [PATCH 4/6] deploy
---
README.pe-PE.md | 371 ++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 371 insertions(+)
create mode 100644 README.pe-PE.md
diff --git a/README.pe-PE.md b/README.pe-PE.md
new file mode 100644
index 0000000000..6ec8b2469b
--- /dev/null
+++ b/README.pe-PE.md
@@ -0,0 +1,371 @@
+الگوریتم های جاوا اسکریپت و ساختارهای داده
+
+> 🇺🇦 اوکراین [در حال حمله است] (https://twitter.com/MFA_Ukraine) توسط ارتش روسیه. غیرنظامیان در حال کشته شدن هستند. مناطق مسکونی در حال بمباران هستند.
+> - از طریق [بانک ملی اوکراین] به اوکراین کمک کنید (https://bank.gov.ua/en/news/all/natsionalniy-bank-vidkriv-spetsrahunok-dlya-zboru-koshtiv-na-potrebi-armiyi)
+> - از طریق صندوق [SaveLife](https://savelife.in.ua/en/donate-en/) به اوکراین کمک کنید
+> - اطلاعات بیشتر در [war.ukraine.ua](https://war.ukraine.ua/)
+
+[](https://github.com/trekhleb/javascript-algorithms/actions?query=workflow% 3ACI+شاخه%3Amaster)
+[](https://codecov.io/gh/trekhleb/javascript-algorithms)
+
+این مخزن شامل نمونه های بسیاری بر اساس جاوا اسکریپت است
+الگوریتم ها و ساختارهای داده محبوب
+
+هر الگوریتم و ساختار داده README جداگانه خود را دارد
+همراه با توضیحات مرتبط و لینک برای مطالعه بیشتر (از جمله
+به ویدیوهای یوتیوب).
+
+_این را به زبان های دیگر بخوانید:_
+[_简体中文_](README.zh-CN.md)،
+[_繁體中文_](README.zh-TW.md)،
+[_한국어_](README.ko-KR.md)،
+[_日本語_](README.ja-JP.md)،
+[_Polski_](README.pl-PL.md)،
+[_Français_](README.fr-FR.md)،
+[_Español_](README.es-ES.md)،
+[_Português_](README.pt-BR.md)،
+[_Русский_](README.ru-RU.md)،
+[_Türk_](README.tr-TR.md)،
+[_Italiana_](README.it-IT.md)،
+[_Bahasa Indonesia_](README.id-ID.md)،
+[_Українська_](README.uk-UA.md)،
+[_عربی_](README.ar-AR.md)،
+[_Tiếng Việt_](README.vi-VN.md)،
+[_Deutsch_](README.de-DE.md)
+
+*☝ توجه داشته باشید که این پروژه برای اهداف یادگیری و تحقیق استفاده می شود
+فقط، و **نیست** برای تولید استفاده شود.*
+
+## ساختارهای داده
+
+ساختار داده روشی خاص برای سازماندهی و ذخیره سازی داده ها در رایانه است تا بتواند
+به طور موثر قابل دسترسی و اصلاح باشد. به طور دقیق تر، ساختار داده مجموعه ای از داده ها است
+مقادیر، روابط بین آنها و توابع یا عملیاتی که می توان روی آنها اعمال کرد
+داده.
+
+"B" - مبتدی، "A" - پیشرفته
+
+* `B` [فهرست پیوند شده] (src/data-structures/linked-list)
+* `B` [فهرست پیوند شده دوگانه] (src/data-structures/doubly-linked-list)
+* 'B' [صف] (src/data-structures/queue)
+* «B» [پشته] (src/data-structures/stack)
+* `B` [Hash Table] (src/data-structures/hash-table)
+* `B` [Heap] (src/data-structures/heap) - نسخههای حداکثر و حداقل پشته
+* `B` [صف اولویت] (src/data-structures/priority-queue)
+* `A` [Trie] (src/data-structures/trie)
+* «A» [درخت] (src/data-structures/tree)
+ * `A` [درخت جستجوی باینری] (src/data-structures/tree/binary-search-tree)
+ * `A` [AVL Tree] (src/data-structures/tree/avl-tree)
+ * `A` [درخت قرمز-سیاه] (src/data-structures/tree/red-black-tree)
+ * `A` [Segment Tree] (src/data-structures/tree/segment-tree) - با نمونه جستجوهای محدوده حداقل/حداکثر/جمع
+ * `A` [درخت Fenwick](src/data-structures/tree/fenwick-tree) (درخت نمایه شده باینری)
+* `A` [گراف] (src/data-structures/graph) (هم جهت دار و هم بدون جهت)
+* «A» [مجموعه جدا] (src/data-structures/disjoint-set)
+* «A» [فیلتر بلوم] (src/data-structures/bloom-filter)
+
+## الگوریتم ها
+
+یک الگوریتم یک مشخصات روشن از نحوه حل یک کلاس از مسائل است. این است
+مجموعه ای از قوانین که دقیقاً دنباله ای از عملیات را تعریف می کند.
+
+"B" - مبتدی، "A" - پیشرفته
+
+### الگوریتم ها بر اساس موضوع
+
+* **ریاضی**
+ * 'B' [دستکاری بیت] (src/الگوریتم ها/ریاضی/بیت ها) - تنظیم/دریافت/به روز رسانی/پاک کردن بیت ها، ضرب/تقسیم بر دو، ایجاد منفی و غیره.
+ * `B` [نقطه شناور دودویی] (src/الگوریتم ها/ریاضی/نقطه شناور باینری) - نمایش دودویی اعداد ممیز شناور.
+ * `B` [فاکتوری] (src/algorithms/math/factorial)
+ * 'B' [شماره فیبوناچی] (src/الگوریتم ها/ریاضی/فیبوناچی) - نسخه های کلاسیک و بسته
+ * 'B' [عوامل اول] (src/الگوریتم ها/ریاضی/عوامل اول) - یافتن عوامل اول و شمارش آنها با استفاده از قضیه هاردی رامانوجان
+ * `B` [آزمون اولیه] (src/algorithms/math/primality-test) (روش تقسیم آزمایشی)
+ * 'B' [الگوریتم اقلیدسی] (src/algorithms/math/euclidean-algorithm) - محاسبه بزرگترین مقسوم علیه مشترک (GCD)
+ * `B` [کمترین ضرب رایج] (src/algorithms/math/least-common-multiple) (LCM)
+ * `B` [الک اراتوستن] (src/الگوریتم ها/ریاضی/الک-اراتوستن) - یافتن تمام اعداد اول تا هر حد معین
+ * `B` [قدرت دو است] (src/algorithms/math/is-power-of-two) - بررسی کنید که آیا عدد توان دو است (الگوریتمهای ساده و بیتفاوت)
+ * 'B' [مثلث پاسکال] (src/algorithms/math/pascal-triangle)
+ * 'B' [شماره مختلط] (src/algorithms/math/complex-number) - اعداد مختلط و عملیات اساسی با آنها
+ * 'B' [رادیان و درجه] (src/الگوریتم ها/ریاضی/رادیان) - تبدیل رادیان به درجه و معکوس
+ * `B` [تقویت سریع] (src/الگوریتمها/ریاضی/تغذیه سریع)
+ * `B` [روش هورنر] (src/الگوریتمها/ریاضی/روش هورنر) - ارزیابی چند جملهای
+ * 'B' [ماتریس] (src/الگوریتم ها/ریاضی/ماتریس) - ماتریس ها و عملیات اصلی ماتریس (ضرب، جابجایی و غیره)
+ * `B` [فاصله اقلیدسی](src/algorithms/
+
+ ریاضی/اقلیدسی-فاصله) - فاصله بین دو نقطه/بردار/ماتریس
+ * 'A' [پارتیشن عدد صحیح] (src/algorithms/math/integer-partition)
+ * `A` [ریشه مربع] (src/الگوریتم ها/ریاضی/ریشه مربع) - روش نیوتن
+ * `A` [الگوریتم Liu Hui π](src/algorithms/math/liu-hui) - محاسبات π تقریبی بر اساس N-gon
+ * 'A' [تبدیل فوریه گسسته] (src/algorithms/math/fourier-transform) - یک تابع زمان (یک سیگنال) را به فرکانسهایی که آن را تشکیل میدهند تجزیه میکند.
+* **مجموعه**
+ * `B` [محصول دکارتی] (src/الگوریتمها/مجموعهها/محصولات دکارتی) - محصول مجموعههای متعدد
+ * 'B' [Fisher-Yates Shuffle] (src/algorithms/sets/fisher-yates) - جایگشت تصادفی یک دنباله محدود
+ * «A» [مجموعه توان] (src/الگوریتمها/مجموعهها/مجموعه قدرت) - همه زیرمجموعههای یک مجموعه (راهحلهای بیتی و پسگرد)
+ * «A» [جایگشتها] (src/الگوریتمها/مجموعهها/جایگشتها) (با و بدون تکرار)
+ * `A` [ترکیب ها] (src/الگوریتم ها/مجموعه ها/ترکیبات) (با و بدون تکرار)
+ * `A` [طولانی ترین دنباله متداول] (src/الگوریتم ها/مجموعه ها/طولانی ترین-متداول-زیر دنباله) (LCS)
+ * `A` [طولانیترین دنباله افزایشدهنده] (src/الگوریتمها/مجموعهها/طولانیترین-افزاینده-زیر دنباله)
+ * `A` [کوتاهترین سوپرست متداول] (src/الگوریتمها/مجموعهها/کوتاهترین ابرتوالی مشترک) (SCS)
+ * `A` [مسئله کوله پشتی] (src/algorithms/sets/knapsack-problem) - موارد "0/1" و "Unbound"
+ * `A` [Maximum Subarray] (src/algorithms/sets/maximum-subray) - نسخه های "Brute Force" و "Dynamic Programming" (Kadane's)
+ * `A` [ترکیب جمع] (src/الگوریتمها/مجموعهها/ترکیب-جمع) - همه ترکیبهایی را پیدا کنید که مجموع خاصی را تشکیل میدهند.
+* **رشته های**
+ * 'B' [فاصله همینگ] (src/الگوریتم ها/رشته/همینگ-فاصله) - تعداد موقعیت هایی که نمادها در آنها متفاوت هستند
+ * `B` [Palindrome] (src/algorithms/string/palindrome) - بررسی کنید که آیا رشته به صورت معکوس یکسان است یا خیر
+ * `A` [فاصله Levenshtein] (src/algorithms/string/levenshtein-distance) - حداقل فاصله ویرایش بین دو دنباله
+ * `A` [الگوریتم Knuth–Morris–Pratt](src/algorithms/string/knuth-morris-pratt) (الگوریتم KMP) - جستجوی زیر رشته (تطبیق الگو)
+ * `A` [الگوریتم Z] (src/algorithms/string/z-algorithm) - جستجوی زیر رشته (تطبیق الگو)
+ * `A` [الگوریتم Rabin Karp] (src/algorithms/string/rabin-karp) - جستجوی زیر رشته
+ * `A` [طولانی ترین زیر رشته مشترک] (src/algorithms/string/longest-common-substring)
+ * «A» [تطبیق عبارت منظم] (src/algorithms/string/regular-expression-matching)
+* **جستجو**
+ * `B` [جستجوی خطی] (src/algorithms/search/linear-search)
+ * `B` [Jump Search] (src/algorithms/search/jump-search) (یا Block Search) - جستجو در آرایه مرتب شده
+ * `B` [جستجوی باینری] (src/algorithms/search/binary-search) - جستجو در آرایه مرتب شده
+ * `B` [جستجوی درون یابی] (src/algorithms/search/interpolation-search) - جستجو در آرایه مرتب شده به طور یکنواخت توزیع شده
+* **مرتب سازی**
+ * «B» [مرتبسازی حبابها] (src/الگوریتمها/مرتبسازی/مرتبسازی حبابها)
+ * «B» [مرتبسازی انتخابی] (src/الگوریتمها/مرتبسازی/مرتبسازی انتخابی)
+ * «B» [مرتبسازی درج] (src/الگوریتمها/مرتبسازی/مرتبسازی درج)
+ * «B» [مرتبسازی پشته] (src/الگوریتمها/مرتبسازی/مرتبسازی پشته)
+ * `B` [Merge Sort] (src/algorithms/sorting/merge-sort)
+ * «B» [مرتبسازی سریع] (src/الگوریتمها/مرتبسازی/مرتبسازی سریع) - پیادهسازی در محل و غیردرجا
+ * `B` [Sellsort] (src/algorithms/sorting/shell-sort)
+ * «B» [مرتبسازی شمارش] (src/الگوریتمها/مرتبسازی/شمارش مرتبسازی)
+ * `B` [Radix Sort] (src/algorithms/sorting/radix-sort)
+* **لیست های پیوندی**
+ * `B` [پیمایش مستقیم] (src/algorithms/linked-list/traversal)
+ * `B` [پیمایش معکوس] (src/algorithms/linked-list/reverse-traversal)
+* **درختان**
+ * `B` [Depth-First Search] (src/algorithms/tree/depth-first-search) (DFS)
+ * `B` [Breadth-First Search] (src/algorithms/tree/breadth-first-search) (BFS)
+* **نمودارها**
+ * `B` [جستجوی عمق-اول](src/الگوریتم ها/گراف/عمق-اول-جستجو) (DFS)
+ * `B` [جستجوی عرض-اول](src/الگوریتم ها/گراف/عرض-اول-جستجو) (BFS)
+ * `B` [الگوریتم کروسکال] (src/algorithms/graph/kruskal) - یافتن حداقل درخت پوشا (MST) برای نمودار وزنی بدون جهت
+ * `A` [الگوریتم Dijkstra] (src/algorithms/graph/dijkstra) - یافتن کوتاهترین مسیرها به تمام رئوس نمودار از یک راس
+ * `A` [الگوریتم بلمن-فورد](src/algorithms/graph/bellman-ford) - یافتن کوتاه ترین مسیرها برای همه رئوس نمودار از یک راس
+ * `A` [الگوریتم فلوید-وارشال] (src/algorithms/graph/floyd-warshall) - کوتاه ترین مسیرها را بین همه جفت رئوس پیدا کنید
+ * `A` [Detect Cycle] (src/algorithms/graph/ detect-cycle) - هم برای نمودارهای جهت دار و هم بدون جهت (نسخه های مبتنی بر DFS و Disjoint Set)
+ * `A` [الگوریتم Prim] (src/algorithms/graph/prim) - یافتن حداقل درخت پوشا (MST) برای نمودار وزنی بدون جهت
+ * `A` [مرتبسازی توپولوژیکی] (src/algorithms/graph/topological-sorting) - روش DFS
+ * `A` [نقاط بیانی] (src/algorithms/graph/articulation-points) - الگوریتم ترجان (بر اساس DFS)
+ * `A` [پلها] (src/algorithms/graph/bridges) - الگوریتم مبتنی بر DFS
+ * 'A' [مسیر اویلر و مدار اویلر] (src/algorithms/graph/eule
+
+ rian-path) - الگوریتم فلوری - دقیقاً یک بار از هر لبه بازدید کنید
+ * `A` [چرخه همیلتونی] (src/algorithms/graph/Hamiltonian-cycle) - از هر رأس دقیقاً یک بار بازدید کنید
+ * `A` [کامپوننت های به شدت متصل] (src/algorithms/graph/strongly-connected-components) - الگوریتم کوساراجو
+ * `A` [مسئله فروشنده مسافر] (src/algorithms/graph/travelling-salesman) - کوتاه ترین مسیر ممکن که از هر شهر بازدید می کند و به شهر مبدأ باز می گردد.
+* **رمزنگاری**
+ * `B` [هش چند جملهای] (src/الگوریتمها/رمزنگاری/هش چند جملهای) - تابع هش رول بر اساس چند جملهای
+ * `B` [رمز حصار ریلی] (src/algorithms/cryptography/rail-fence-cipher) - یک الگوریتم رمز جابجایی برای رمزگذاری پیام ها
+ * `B` [Caesar Cipher] (src/algorithms/cryptography/caesar-cipher) - رمز جایگزین ساده
+ * `B` [رمز تپه] (src/الگوریتمها/رمز نگاری/تپه-رمز) - رمز جایگزینی بر اساس جبر خطی
+* **فراگیری ماشین**
+ * `B` [NanoNeuron] (https://github.com/trekhleb/nano-neuron) - 7 تابع JS ساده که نشان میدهد ماشینها چگونه واقعاً میتوانند یاد بگیرند (انتشار به جلو/عقب)
+ * `B` [k-NN](src/الگوریتمها/ml/knn) - الگوریتم طبقهبندی k-نزدیکترین همسایگان
+ * `B` [k-Means](src/algorithms/ml/k-means) - الگوریتم خوشه بندی k-Means
+* **پردازش تصویر**
+ * `B` [Seam Carving] (src/algorithms/image-processing/seam-carving) - الگوریتم تغییر اندازه تصویر آگاه از محتوا
+* **آمار**
+ * 'B' [تصادفی وزنی] (src/الگوریتم ها/آمار/وزنی-تصادفی) - آیتم تصادفی را از لیست بر اساس وزن آیتم ها انتخاب کنید
+* **الگوریتم های تکاملی**
+ * `A` [الگوریتم ژنتیک] (https://github.com/trekhleb/self-parking-car-evolution) - نمونه ای از نحوه استفاده از الگوریتم ژنتیک برای آموزش خودروهای خود پارکینگ
+* **دستهبندی نشده**
+ * `B` [برج هانوی] (src/الگوریتمها/دستهبندی نشده/هانوی-برج)
+ * `B` [چرخش ماتریس مربع] (src/الگوریتمها/ دستهبندی نشده/چرخش ماتریس مربع) - الگوریتم در محل
+ * `B` [بازی پرش] (src/الگوریتم ها/ دسته بندی نشده/بازی پرش) - عقب نشینی، برنامه نویسی پویا (از بالا به پایین + پایین به بالا) و مثال های حریصانه
+ * `B` [مسیرهای منحصربهفرد] (src/الگوریتمها/ دستهبندینشده/مسیرهای منحصربهفرد) - بکتراکینگ، برنامهنویسی پویا و مثالهای مبتنی بر مثلث پاسکال
+ * `B` [تراس های بارانی] (src/الگوریتم ها/ دسته بندی نشده/تراس های بارانی) - به دام انداختن مشکل آب باران (برنامه نویسی پویا و نسخه های brute force)
+ * `B` [پلکان بازگشتی] (src/الگوریتمها/ دستهبندی نشده/پلههای بازگشتی) - تعداد راههای رسیدن به بالا را بشمارید (4 راهحل)
+ * `B` [بهترین زمان برای خرید سهام] (src/الگوریتمها/دستهبندی نشده/بهترین زمان برای خرید-فروش- سهام) - تقسیم و غلبه و نمونههایی با یک پاس
+ * `A` [مسئله N-Queens] (src/algorithms/uncategorized/n-queens)
+ * «A» [تور شوالیه] (src/الگوریتمها/دستهبندی نشده/شوالیه-تور)
+
+### الگوریتم های پارادایم
+
+پارادایم الگوریتمی یک روش یا رویکرد عمومی است که زیربنای طراحی یک کلاس است
+از الگوریتم ها این یک انتزاع بالاتر از مفهوم یک الگوریتم است، درست به عنوان یک
+الگوریتم یک انتزاع بالاتر از یک برنامه کامپیوتری است.
+
+* **Brute Force** - به همه احتمالات نگاه کنید و بهترین راه حل را انتخاب کنید
+ * `B` [جستجوی خطی] (src/algorithms/search/linear-search)
+ * `B` [تراس های بارانی] (src/الگوریتم ها/ دسته بندی نشده/تراس های بارانی) - به دام انداختن مشکل آب باران
+ * `B` [پلکان بازگشتی] (src/algorithms/uncategorized/recursive-staircase) - تعداد راههای رسیدن به بالا را بشمارید
+ * `A` [حداکثر زیرآرایه] (src/algorithms/sets/maximum-subray)
+ * `A` [مسئله فروشنده مسافر] (src/algorithms/graph/travelling-salesman) - کوتاه ترین مسیر ممکن که از هر شهر بازدید می کند و به شهر مبدأ باز می گردد.
+ * 'A' [تبدیل فوریه گسسته] (src/algorithms/math/fourier-transform) - یک تابع زمان (یک سیگنال) را به فرکانسهایی که آن را تشکیل میدهند تجزیه میکند.
+* ** حریص** - بهترین گزینه را در زمان کنونی انتخاب کنید، بدون هیچ توجهی به آینده
+ * `B` [بازی پرش] (src/الگوریتمها/ دستهبندی نشده/بازی پرش)
+ * `A` [مسئله کوله پشتی بدون محدودیت] (src/algorithms/sets/knapsack-problem)
+ * `A` [الگوریتم Dijkstra] (src/algorithms/graph/dijkstra) - یافتن کوتاهترین مسیر برای همه رئوس نمودار
+ * `A` [الگوریتم Prim] (src/algorithms/graph/prim) - یافتن حداقل درخت پوشا (MST) برای نمودار وزنی بدون جهت
+ * `A` [الگوریتم کروسکال] (src/algorithms/graph/kruskal) - یافتن حداقل درخت پوشا (MST) برای نمودار وزنی بدون جهت
+* **تقسیم و تسخیر** - مسئله را به قسمت های کوچکتر تقسیم کنید و سپس آن قسمت ها را حل کنید
+ * `B` [جستجوی باینری] (src/algorithms/search/binary-search)
+ * `B` [برج هانوی] (src/الگوریتمها/دستهبندی نشده/هانوی-برج)
+ * 'B' [مثلث پاسکال] (src/algorithms/math/pascal-triangle)
+ * 'B' [الگوریتم اقلیدسی] (src/algorithms/math/euclidean-algorithm) - محاسبه بزرگترین مقسوم علیه مشترک (GCD)
+ * `B` [Merge Sort] (src/algorithms/sorting/merge-sort)
+ * «B» [مرتبسازی سریع] (src/الگوریتمها/مرتبسازی/مرتبسازی سریع)
+ * `B` [جستجوی اول عمق درخت] (src/algorithms/tree/depth-first-search) (DFS)
+ * `B` [عمق نمودار-F
+
+ irst Search](src/algorithms/graph/depth-first-search) (DFS)
+ * `B` [ماتریس] (src/الگوریتم ها/ریاضی/ماتریس) - تولید و پیمایش ماتریس های اشکال مختلف
+ * `B` [بازی پرش] (src/الگوریتمها/ دستهبندی نشده/بازی پرش)
+ * `B` [تقویت سریع] (src/الگوریتمها/ریاضی/تغذیه سریع)
+ * `B` [بهترین زمان برای خرید سهام] (src/الگوریتمها/دستهبندی نشده/بهترین زمان برای خرید-فروش- سهام) - تقسیم و غلبه و نمونههایی با یک پاس
+ * «A» [جایگشتها] (src/الگوریتمها/مجموعهها/جایگشتها) (با و بدون تکرار)
+ * `A` [ترکیب ها] (src/الگوریتم ها/مجموعه ها/ترکیبات) (با و بدون تکرار)
+ * `A` [حداکثر زیرآرایه] (src/algorithms/sets/maximum-subray)
+* **برنامه نویسی پویا** - ایجاد راه حل با استفاده از راه حل های فرعی که قبلاً پیدا شده بود
+ * 'B' [شماره فیبوناچی] (src/الگوریتم ها/ریاضی/فیبوناچی)
+ * `B` [بازی پرش] (src/الگوریتمها/ دستهبندی نشده/بازی پرش)
+ * `B` [مسیرهای منحصر به فرد] (src/algorithms/uncategorized/unique-paths)
+ * `B` [تراس های بارانی] (src/الگوریتم ها/ دسته بندی نشده/تراس های بارانی) - به دام انداختن مشکل آب باران
+ * `B` [پلکان بازگشتی] (src/algorithms/uncategorized/recursive-staircase) - تعداد راههای رسیدن به بالا را بشمارید
+ * `B` [Seam Carving] (src/algorithms/image-processing/seam-carving) - الگوریتم تغییر اندازه تصویر آگاه از محتوا
+ * `A` [فاصله Levenshtein] (src/algorithms/string/levenshtein-distance) - حداقل فاصله ویرایش بین دو دنباله
+ * `A` [طولانی ترین دنباله متداول] (src/الگوریتم ها/مجموعه ها/طولانی ترین-متداول-زیر دنباله) (LCS)
+ * `A` [طولانی ترین زیر رشته مشترک] (src/algorithms/string/longest-common-substring)
+ * `A` [طولانیترین دنباله افزایشدهنده] (src/الگوریتمها/مجموعهها/طولانیترین-افزاینده-زیر دنباله)
+ * `A` [کوتاهترین سوپرست متداول] (src/الگوریتمها/مجموعهها/کوتاهترین سوپرتوالی مشترک)
+ * `A` [0/1 مشکل کوله پشتی] (src/algorithms/sets/knapsack-problem)
+ * 'A' [پارتیشن عدد صحیح] (src/algorithms/math/integer-partition)
+ * `A` [حداکثر زیرآرایه] (src/algorithms/sets/maximum-subray)
+ * `A` [الگوریتم بلمن-فورد] (src/algorithms/graph/bellman-ford) - یافتن کوتاه ترین مسیر برای همه رئوس نمودار
+ * `A` [الگوریتم فلوید-وارشال] (src/algorithms/graph/floyd-warshall) - کوتاه ترین مسیرها را بین همه جفت رئوس پیدا کنید
+ * «A» [تطبیق عبارت منظم] (src/algorithms/string/regular-expression-matching)
+* **Backtracking** - مشابه نیروی بی رحم، سعی کنید همه راه حل های ممکن را ایجاد کنید، اما هر بار که راه حل بعدی را ایجاد می کنید، آزمایش می کنید
+اگر همه شرایط را برآورده کند و تنها پس از آن به تولید راه حل های بعدی ادامه دهید. در غیر این صورت، به عقب برگردید، و ادامه دهید
+مسیرهای مختلف برای یافتن راه حل به طور معمول از پیمایش DFS فضای حالت استفاده می شود.
+ * `B` [بازی پرش] (src/الگوریتمها/ دستهبندی نشده/بازی پرش)
+ * `B` [مسیرهای منحصر به فرد] (src/algorithms/uncategorized/unique-paths)
+ * «B» [مجموعه توان] (src/الگوریتمها/ستها/مجموعه قدرت) - همه زیر مجموعههای یک مجموعه
+ * `A` [چرخه همیلتونی] (src/algorithms/graph/Hamiltonian-cycle) - از هر رأس دقیقاً یک بار بازدید کنید
+ * `A` [مسئله N-Queens] (src/algorithms/uncategorized/n-queens)
+ * «A» [تور شوالیه] (src/الگوریتمها/دستهبندی نشده/شوالیه-تور)
+ * `A` [ترکیب جمع] (src/الگوریتمها/مجموعهها/ترکیب-جمع) - همه ترکیبهایی را پیدا کنید که مجموع خاصی را تشکیل میدهند.
+* **شاخه و محدود ** - کم هزینه ترین راه حل یافت شده در هر مرحله از عقب نشینی را به خاطر بسپارید
+جستجو کنید، و از هزینه کمهزینهترین راهحلی که تاکنون پیدا شده است، به عنوان یک کران پایینتر در هزینه استفاده کنید
+یک راه حل کم هزینه برای مشکل، به منظور کنار گذاشتن راه حل های جزئی با هزینه های بیشتر از این
+کم هزینه ترین راه حل پیدا شده تا کنون به طور معمول پیمایش BFS در ترکیب با پیمایش DFS فضای حالت
+درخت استفاده می شود
+
+## نحوه استفاده از این مخزن
+
+**همه وابستگی ها را نصب کنید**
+
+```
+npm نصب کنید
+```
+
+**اجرای ESLint**
+
+ممکن است بخواهید آن را اجرا کنید تا کیفیت کد را بررسی کنید.
+
+```
+npm اجرا lint
+```
+
+**اجرای تمام تست ها**
+
+```
+تست npm
+```
+
+**آزمون ها را با نام اجرا کنید**
+
+```
+تست npm -- 'LinkedList'
+```
+
+**عیب یابی**
+
+اگر پرده زدن یا آزمایش ناموفق بود، سعی کنید پوشه «node_modules» را حذف کنید و بستههای npm را دوباره نصب کنید:
+
+```
+rm -rf ./node_modules
+npm من
+```
+
+همچنین مطمئن شوید که از نسخه صحیح Node (`>=14.16.0`) استفاده می کنید. اگر از [nvm](https://github.com/nvm-sh/nvm) برای مدیریت نسخه Node استفاده میکنید، میتوانید «nvm use» را از پوشه اصلی پروژه اجرا کنید و نسخه صحیح انتخاب خواهد شد.
+
+**زمین بازی**
+
+میتوانید با ساختارهای داده و الگوریتمها در فایل «./src/playground/playground.js» بازی کنید و بنویسید
+آن را در «./src/playground/__test__/playground.test.js» آزمایش می کند.
+
+سپس به سادگی دستور زیر را اجرا کنید تا بررسی کنید که آیا کد زمین بازی شما مطابق انتظار کار می کند یا خیر:
+
+```
+تست npm -- "زمین بازی"
+```
+
+## اطلاعات مفید
+
+### منابع
+
+[▶ ساختارها و الگوریتمهای داده در YouTube](https://www.youtube.com/playlist?list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+
+### نماد بزرگ O
+
+*نشانگذاری Big O* برای طبقه بندی الگوریتم ها بر اساس چگونگی رشد زمان یا فضای مورد نیاز آنها با افزایش اندازه ورودی استفاده می شود.
+در نمودار زیر می توانید رایج ترین ترتیبات رشد الگوریتم های مشخص شده را بیابید
+
+
+در نماد O بزرگ.
+
+
+
+منبع: [Big O Cheat Sheet](http://bigocheatsheet.com/).
+
+در زیر لیستی از برخی از پرکاربردترین نمادهای Big O و مقایسه عملکرد آنها در برابر اندازه های مختلف داده های ورودی آورده شده است.
+
+| Big O Notation | نوع | محاسبات برای 10 عنصر | محاسبات برای 100 عنصر | محاسبات برای 1000 عنصر |
+| -------------- | ----------- | ---------------------------- | ----------------------------- | ------------------------------- |
+| **O(1)** | ثابت | 1 | 1 | 1 |
+| **O(log N)** | لگاریتمی | 3 | 6 | 9 |
+| **O(N)** | خطی | 10 | 100 | 1000 |
+| **O(N log N)** | n log(n) | 30 | 600 | 9000 |
+| **O(N^2)** | درجه دوم | 100 | 10000 | 1000000 |
+| **O(2^N)** | نمایی | 1024 | 1.26e+29 | 1.07e+301 |
+| **O(N!)** | فاکتوریل | 3628800 | 9.3e+157 | 4.02e+2567 |
+
+### پیچیدگی عملیات ساختار داده
+
+| ساختار داده | دسترسی | جستجو | درج | حذف | نظرات |
+| ----------------------- | :-------: | :-------: | :-------: | :-------: | :-------- |
+| **آرایه** | 1 | n | n | n | |
+| **پشته** | n | n | 1 | 1 | |
+| **صف ** | n | n | 1 | 1 | |
+| **فهرست پیوند شده** | n | n | 1 | n | |
+| **جدول هش** | - | n | n | n | در صورت عملکرد هش کامل هزینه ها O(1) |
+| **درخت جستجوی باینری** | n | n | n | n | در صورت متعادل بودن هزینه های درخت O(log(n)) |
+| **B-Tree** | log(n) | log(n) | log(n) | log(n) | |
+| **درخت قرمز-سیاه** | log(n) | log(n) | log(n) | log(n) | |
+| **AVL Tree** | log(n) | log(n) | log(n) | log(n) | |
+| **فیلتر بلوم** | - | 1 | 1 | - | در حین جستجو، نتایج مثبت کاذب امکان پذیر است |
+
+### پیچیدگی الگوریتم های مرتب سازی آرایه
+
+| نام | بهترین | میانگین | بدترین | حافظه | پایدار | نظرات |
+| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **مرتب سازی حبابی** | n | n<sup>2</sup> | n<sup>2</sup> | 1 | بله | |
+| **مرتب سازی درج ** | n | n<sup>2</sup> | n<sup>2</sup> | 1 | بله | |
+| **مرتب سازی انتخابی** | n<sup>2</sup> | n<sup>2</sup> | n<sup>2</sup> | 1 | نه | |
+| **مرتب سازی پشته** | n log(n) | n log(n) | n log(n) | 1 | نه | |
+| **مرتب سازی ادغام ** | n log(n) | n log(n) | n log(n) | n | بله | |
+| **مرتب سازی سریع** | n log(n) | n log(n) | n<sup>2</sup> | log(n) | نه | مرتب سازی سریع معمولاً در محل با فضای پشته O(log(n)) انجام می شود
+| **مرتب سازی پوسته** | n log(n) | به دنباله شکاف بستگی دارد | n (log(n))<sup>2</sup> | 1 | نه | |
+| **شمارش مرتب سازی** | n + r | n + r | n + r | n + r | بله | r - بزرگترین عدد در آرایه |
+| **مرتب سازی ریشه** | n * k | n * k | n * k | n + k | بله | k - طول طولانی ترین کلید |
+
+## حامیان پروژه
+
+> می توانید از طریق ❤️️ [GitHub](https://github.com/sponsors/trekhleb) یا ❤️️ [Patreon] (https://www.patreon.com/trekhleb) از این پروژه حمایت کنید.
+
+[کسانی که از این پروژه حمایت می کنند](https://github.com/trekhleb/javascript-algorithms/blob/master/BACKERS.md) `∑ = 0`
+
+> ℹ️ چند [پروژه](https://trekhleb.dev/projects/) و [مقاله](https://trekhleb.dev/blog/) دیگر درباره جاوا اسکریپت و الگوریتم ها در [trekhleb.dev](https:/ /trekhleb.dev)
\ No newline at end of file
From a2226c17730050c79ff6610d0f096eaec81de9fa Mon Sep 17 00:00:00 2001
From: name <your mail>
Date: Fri, 2 Sep 2022 17:15:46 -0700
Subject: [PATCH 5/6] deploy
---
README.md | 2 +-
README.pe-PE.md | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/README.md b/README.md
index f261b86e30..2453bd752c 100644
--- a/README.md
+++ b/README.md
@@ -277,7 +277,7 @@ npm test -- 'LinkedList'
**Troubleshooting**
-If linting or testing is failing, try to delete the `node_modules` folder and re-install npm packages:
+In case if linting or testing are failing, try to delete the `node_modules` folder and re-install npm packages:
```
rm -rf ./node_modules
diff --git a/README.pe-PE.md b/README.pe-PE.md
index 6ec8b2469b..436d6cb37f 100644
--- a/README.pe-PE.md
+++ b/README.pe-PE.md
@@ -368,4 +368,4 @@ npm من
[کسانی که از این پروژه حمایت می کنند](https://github.com/trekhleb/javascript-algorithms/blob/master/BACKERS.md) `∑ = 0`
-> ℹ️ چند [پروژه](https://trekhleb.dev/projects/) و [مقاله](https://trekhleb.dev/blog/) دیگر درباره جاوا اسکریپت و الگوریتم ها در [trekhleb.dev](https:/ /trekhleb.dev)
\ No newline at end of file
+> ℹ️ چند [پروژه](https://trekhleb.dev/projects/) و [مقاله](https://trekhleb.dev/blog/) دیگر درباره جاوا اسکریپت و الگوریتم ها در [trekhleb.dev](https:/ /trekhleb.dev)
From a4dc32782e040d13db0bc70754f5ed93c546e19b Mon Sep 17 00:00:00 2001
From: name <your mail>
Date: Wed, 5 Oct 2022 06:17:41 -0700
Subject: [PATCH 6/6] skip-list-implementation
---
src/data-structures/skip-list/README.md | 1 +
src/data-structures/skip-list/SkipList.js | 371 ++++++++++++++++++++++
2 files changed, 372 insertions(+)
create mode 100644 src/data-structures/skip-list/README.md
create mode 100644 src/data-structures/skip-list/SkipList.js
diff --git a/src/data-structures/skip-list/README.md b/src/data-structures/skip-list/README.md
new file mode 100644
index 0000000000..f553caa6ec
--- /dev/null
+++ b/src/data-structures/skip-list/README.md
@@ -0,0 +1 @@
+In computer science, a skip list is a probabilistic data structure that allows {\mathcal {O}} search complexity as well as {\mathcal {O}} insertion complexity within an ordered sequence of n elements.
diff --git a/src/data-structures/skip-list/SkipList.js b/src/data-structures/skip-list/SkipList.js
new file mode 100644
index 0000000000..9557276838
--- /dev/null
+++ b/src/data-structures/skip-list/SkipList.js
@@ -0,0 +1,371 @@
+const DEFAULT_STACK_UP_PROBABILITY = 0.25;
+
+class ProperSkipList {
+ constructor(options) {
+ options = options || {};
+ this.stackUpProbability = options.stackUpProbability || DEFAULT_STACK_UP_PROBABILITY;
+ this.updateLength = options.updateLength !== false;
+ this.typePriorityMap = {
+ 'undefined': 0,
+ 'object': 1,
+ 'number': 2,
+ 'bigint': 2,
+ 'string': 3
+ };
+ this.clear();
+ }
+
+ clear() {
+ let headNode = {
+ prev: null
+ };
+ let tailNode = {
+ next: null
+ };
+ this.head = {
+ isHead: true,
+ key: undefined,
+ value: undefined,
+ nodes: [headNode]
+ };
+ this.tail = {
+ isTail: true,
+ key: undefined,
+ value: undefined,
+ nodes: [tailNode]
+ };
+ headNode.next = tailNode;
+ tailNode.prev = headNode;
+ headNode.group = this.head;
+ tailNode.group = this.tail;
+ this.length = this.updateLength ? 0 : undefined;
+ }
+
+ upsert(key, value) {
+ let {matchingNode, prevNode, searchPath} = this._searchAndTrack(key);
+ if (matchingNode) {
+ let previousValue = matchingNode.group.value;
+ matchingNode.group.value = value;
+ return previousValue;
+ }
+
+ // Insert the entry.
+ let newNode = {
+ prev: prevNode,
+ next: prevNode.next
+ };
+ let newGroup = {
+ key,
+ value,
+ nodes: [newNode]
+ };
+ newNode.group = newGroup;
+ prevNode.next = newNode;
+ newNode.next.prev = newNode;
+
+ // Stack up the entry for fast search.
+ let layerIndex = 1;
+ while (Math.random() < this.stackUpProbability) {
+ let prevLayerNode = searchPath[layerIndex];
+ if (!prevLayerNode) {
+ let newHeadNode = {
+ prev: null,
+ group: this.head
+ };
+ let newTailNode = {
+ next: null,
+ group: this.tail
+ };
+ newHeadNode.next = newTailNode;
+ this.head.nodes.push(newHeadNode);
+ newTailNode.prev = newHeadNode;
+ this.tail.nodes.push(newTailNode);
+ prevLayerNode = newHeadNode;
+ }
+ let newNode = {
+ prev: prevLayerNode,
+ next: prevLayerNode.next,
+ group: newGroup
+ };
+ prevLayerNode.next = newNode;
+ newNode.next.prev = newNode;
+ newGroup.nodes.push(newNode);
+ layerIndex++;
+ }
+ if (this.updateLength) this.length++;
+
+ return undefined;
+ }
+
+ find(key) {
+ let {matchingNode} = this._search(key);
+ return matchingNode ? matchingNode.group.value : undefined;
+ }
+
+ has(key) {
+ return !!this.find(key);
+ }
+
+ _isAGreaterThanB(a, b) {
+ let typeA = typeof a;
+ let typeB = typeof b;
+ if (typeA === typeB) {
+ return a > b;
+ }
+ let typeAPriority = this.typePriorityMap[typeA];
+ let typeBPriority = this.typePriorityMap[typeB];
+ if (typeAPriority === typeBPriority) {
+ return a > b;
+ }
+ return typeAPriority > typeBPriority;
+ }
+
+ // The two search methods are similar but were separated for performance reasons.
+ _searchAndTrack(key) {
+ let layerCount = this.head.nodes.length;
+ let searchPath = new Array(layerCount);
+ let layerIndex = layerCount - 1;
+ let currentNode = this.head.nodes[layerIndex];
+ let prevNode = currentNode;
+
+ while (true) {
+ let currentNodeGroup = currentNode.group;
+ let currentKey = currentNodeGroup.key;
+ if (!currentNodeGroup.isTail) {
+ if (this._isAGreaterThanB(key, currentKey) || currentNodeGroup.isHead) {
+ prevNode = currentNode;
+ currentNode = currentNode.next;
+ continue;
+ }
+ if (key === currentKey) {
+ let matchingNode = currentNodeGroup.nodes[0];
+ searchPath[layerIndex] = matchingNode;
+ return {matchingNode, prevNode: matchingNode.prev, searchPath};
+ }
+ }
+ searchPath[layerIndex] = prevNode;
+ if (--layerIndex < 0) {
+ return {matchingNode: undefined, prevNode, searchPath};
+ }
+ currentNode = prevNode.group.nodes[layerIndex];
+ }
+ }
+
+ _search(key) {
+ let layerIndex = this.head.nodes.length - 1;
+ let currentNode = this.head.nodes[layerIndex];
+ let prevNode = currentNode;
+ while (true) {
+ let currentNodeGroup = currentNode.group;
+ let currentKey = currentNodeGroup.key;
+ if (!currentNodeGroup.isTail) {
+ if (this._isAGreaterThanB(key, currentKey) || currentNodeGroup.isHead) {
+ prevNode = currentNode;
+ currentNode = currentNode.next;
+ continue;
+ }
+ if (key === currentKey) {
+ let matchingNode = currentNodeGroup.nodes[0];
+ return {matchingNode, prevNode: matchingNode.prev};
+ }
+ }
+ if (--layerIndex < 0) {
+ return {matchingNode: undefined, prevNode};
+ }
+ currentNode = prevNode.group.nodes[layerIndex];
+ }
+ }
+
+ findEntriesFromMin() {
+ return this._createEntriesIteratorAsc(this.head.nodes[0].next);
+ }
+
+ findEntriesFromMax() {
+ return this._createEntriesIteratorDesc(this.tail.nodes[0].prev);
+ }
+
+ minEntry() {
+ let [key, value] = this.findEntriesFromMin().next().value;
+ return [key, value];
+ }
+
+ maxEntry() {
+ let [key, value] = this.findEntriesFromMax().next().value;
+ return [key, value];
+ }
+
+ minKey() {
+ return this.minEntry()[0];
+ }
+
+ maxKey() {
+ return this.maxEntry()[0];
+ }
+
+ minValue() {
+ return this.minEntry()[1];
+ }
+
+ maxValue() {
+ return this.maxEntry()[1];
+ }
+
+ _extractNode(matchingNode) {
+ let nodes = matchingNode.group.nodes;
+ for (let layerNode of nodes) {
+ let prevNode = layerNode.prev;
+ prevNode.next = layerNode.next;
+ prevNode.next.prev = prevNode;
+ }
+ if (this.updateLength) this.length--;
+ return matchingNode.group.value;
+ }
+
+ extract(key) {
+ let {matchingNode} = this._search(key);
+ if (matchingNode) {
+ return this._extractNode(matchingNode);
+ }
+ return undefined;
+ }
+
+ delete(key) {
+ return this.extract(key) !== undefined;
+ }
+
+ findEntries(fromKey) {
+ let {matchingNode, prevNode} = this._search(fromKey);
+ if (matchingNode) {
+ return {
+ matchingValue: matchingNode.group.value,
+ asc: this._createEntriesIteratorAsc(matchingNode),
+ desc: this._createEntriesIteratorDesc(matchingNode)
+ };
+ }
+ return {
+ matchingValue: undefined,
+ asc: this._createEntriesIteratorAsc(prevNode.next),
+ desc: this._createEntriesIteratorDesc(prevNode)
+ };
+ }
+
+ deleteRange(fromKey, toKey, deleteLeft, deleteRight) {
+ if (fromKey == null) {
+ fromKey = this.minKey();
+ deleteLeft = true;
+ }
+ if (toKey == null) {
+ toKey = this.maxKey();
+ deleteRight = true;
+ }
+ if (this._isAGreaterThanB(fromKey, toKey)) {
+ return;
+ }
+ let {prevNode: fromNode, searchPath: leftSearchPath, matchingNode: matchingLeftNode} = this._searchAndTrack(fromKey);
+ let {prevNode: toNode, searchPath: rightSearchPath, matchingNode: matchingRightNode} = this._searchAndTrack(toKey);
+ let leftNode = matchingLeftNode ? matchingLeftNode : fromNode;
+ let rightNode = matchingRightNode ? matchingRightNode : toNode.next;
+
+ if (leftNode === rightNode) {
+ if (deleteLeft) {
+ this._extractNode(leftNode);
+ }
+ return;
+ }
+
+ if (this.updateLength) {
+ let currentNode = leftNode;
+ while (currentNode && currentNode.next !== rightNode) {
+ this.length--;
+ currentNode = currentNode.next;
+ }
+ }
+
+ let leftGroupNodes = leftNode.group.nodes;
+ let rightGroupNodes = rightNode.group.nodes;
+ let layerCount = this.head.nodes.length;
+
+ for (let layerIndex = 0; layerIndex < layerCount; layerIndex++) {
+ let layerLeftNode = leftGroupNodes[layerIndex];
+ let layerRightNode = rightGroupNodes[layerIndex];
+
+ if (layerLeftNode && layerRightNode) {
+ layerLeftNode.next = layerRightNode;
+ layerRightNode.prev = layerLeftNode;
+ continue;
+ }
+ if (layerLeftNode) {
+ let layerRightmostNode = rightSearchPath[layerIndex];
+ if (!layerRightmostNode.group.isTail) {
+ layerRightmostNode = layerRightmostNode.next;
+ }
+ layerLeftNode.next = layerRightmostNode;
+ layerRightmostNode.prev = layerLeftNode;
+ continue;
+ }
+ if (layerRightNode) {
+ let layerLeftmostNode = leftSearchPath[layerIndex];
+ layerLeftmostNode.next = layerRightNode;
+ layerRightNode.prev = layerLeftmostNode;
+ continue;
+ }
+ // If neither left nor right nodes are present on the layer, connect based
+ // on search path to remove in-between entries.
+ let layerRightmostNode = rightSearchPath[layerIndex];
+ if (!layerRightmostNode.group.isTail) {
+ layerRightmostNode = layerRightmostNode.next;
+ }
+ let layerLeftmostNode = leftSearchPath[layerIndex];
+ layerLeftmostNode.next = layerRightmostNode;
+ layerRightmostNode.prev = layerLeftmostNode;
+ }
+ if (deleteLeft && matchingLeftNode) {
+ this._extractNode(matchingLeftNode);
+ }
+ if (deleteRight && matchingRightNode) {
+ this._extractNode(matchingRightNode);
+ }
+ }
+
+ _createEntriesIteratorAsc(currentNode) {
+ let i = 0;
+ return {
+ next: function () {
+ let currentGroup = currentNode.group;
+ if (currentGroup.isTail) {
+ return {
+ value: [currentNode.key, currentNode.value, i],
+ done: true
+ }
+ }
+ currentNode = currentNode.next;
+ return {
+ value: [currentGroup.key, currentGroup.value, i++],
+ done: currentGroup.isTail
+ };
+ },
+ [Symbol.iterator]: function () { return this; }
+ };
+ }
+
+ _createEntriesIteratorDesc(currentNode) {
+ let i = 0;
+ return {
+ next: function () {
+ let currentGroup = currentNode.group;
+ if (currentGroup.isHead) {
+ return {
+ value: [currentNode.key, currentNode.value, i],
+ done: true
+ }
+ }
+ currentNode = currentNode.prev;
+ return {
+ value: [currentGroup.key, currentGroup.value, i++],
+ done: currentGroup.isHead
+ };
+ },
+ [Symbol.iterator]: function () { return this; }
+ };
+ }
+}