diff --git a/.eslintrc b/.eslintrc
index cf3245bf37..88af3ecf32 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -12,6 +12,7 @@
"arrow-body-style": "off",
"no-loop-func": "off"
},
+ "ignorePatterns": ["*.md", "*.png", "*.jpeg", "*.jpg"],
"settings": {
"react": {
"version": "18.2.0"
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
deleted file mode 100644
index deda41e7d6..0000000000
--- a/.github/FUNDING.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-# @see: https://docs.github.com/en/github/administering-a-repository/displaying-a-sponsor-button-in-your-repository
-github: trekhleb
-patreon: trekhleb
diff --git a/README.ar-AR.md b/README.ar-AR.md
index cbcfd02409..72ae41e73c 100644
--- a/README.ar-AR.md
+++ b/README.ar-AR.md
@@ -3,7 +3,7 @@
[](https://travis-ci.org/trekhleb/javascript-algorithms)
[](https://codecov.io/gh/trekhleb/javascript-algorithms)
-تحتوي هذا مقالة على أمثلة عديدة تستند إلى الخوارزميات الشائعة وهياكل البيانات في الجافا سكريبت.
+تحتوي هذه المقالة على أمثلة عديدة تستند إلى الخوارزميات الشائعة وهياكل البيانات في الجافا سكريبت.
كل خوارزمية وهياكل البيانات لها برنامج README منفصل خاص بها
مع التفسيرات والروابط ذات الصلة لمزيد من القراءة (بما في ذلك تلك
@@ -23,10 +23,9 @@ _اقرأ هذا في لغات أخرى:_
[_Türk_](README.tr-TR.md),
[_Italiana_](README.it-IT.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
-
- ☝ ملاحضة هذا المشروع مخصص للاستخدام لأغراض التعلم والبحث
-فقط ، و ** ليست ** معدة للاستخدام في **الإنتاج**
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## هياكل البيانات
diff --git a/README.de-DE.md b/README.de-DE.md
index b34ad3563f..6e5be066aa 100644
--- a/README.de-DE.md
+++ b/README.de-DE.md
@@ -24,9 +24,9 @@ _Lies dies in anderen Sprachen:_
[_Italiana_](README.it-IT.md),
[_Bahasa Indonesia_](README.id-ID.md),
[_Українська_](README.uk-UA.md),
-[_Arabic_](README.ar-AR.md)
-
-_☝ Beachte, dass dieses Projekt nur für Lern- und Forschungszwecke gedacht ist und **nicht** für den produktiven Einsatz verwendet werden soll_
+[_Arabic_](README.ar-AR.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## Datenstrukturen
diff --git a/README.es-ES.md b/README.es-ES.md
index d79baf6022..8443e338b6 100644
--- a/README.es-ES.md
+++ b/README.es-ES.md
@@ -25,10 +25,9 @@ _Léelo en otros idiomas:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
-
-*☝ Nótese que este proyecto está pensado con fines de aprendizaje e investigación,
-y **no** para ser usado en producción.*
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## Estructuras de Datos
@@ -69,7 +68,7 @@ definen con precisión una secuencia de operaciones.
* **Matemáticas**
* `P` [Manipulación de bits](src/algorithms/math/bits) - asignar/obtener/actualizar/limpiar bits, multiplicación/división por dos, hacer negativo, etc.
* `P` [Factorial](src/algorithms/math/factorial)
- * `P` [Número de Fibonacci](src/algorithms/math/fibonacci)
+ * `P` [Sucesión de Fibonacci](src/algorithms/math/fibonacci)
* `P` [Prueba de primalidad](src/algorithms/math/primality-test) (método de división de prueba)
* `P` [Algoritmo de Euclides](src/algorithms/math/euclidean-algorithm) - calcular el Máximo común divisor (MCD)
* `P` [Mínimo común múltiplo](src/algorithms/math/least-common-multiple) (MCM)
diff --git a/README.fr-FR.md b/README.fr-FR.md
index 469a4f52d9..cb30d1833d 100644
--- a/README.fr-FR.md
+++ b/README.fr-FR.md
@@ -26,7 +26,9 @@ _Lisez ceci dans d'autres langues:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## Data Structures
diff --git a/README.he-IL.md b/README.he-IL.md
new file mode 100644
index 0000000000..1d5b0904c2
--- /dev/null
+++ b/README.he-IL.md
@@ -0,0 +1,368 @@
+# אלגוריתמים ומבני נתונים ב-JavaScript
+
+[](https://github.com/trekhleb/javascript-algorithms/actions?query=workflow%3ACI+branch%3Amaster)
+[](https://codecov.io/gh/trekhleb/javascript-algorithms)
+
+
+מאגר זה מכיל דוגמאות מבוססות JavaScript של אלגוריתמים ומבני נתונים פופולריים רבים.
+
+לכל אלגוריתם ומבנה נתונים יש README משלו עם הסברים קשורים וקישורים לקריאה נוספת (כולל קישורים לסרטוני YouTube).
+
+_קרא זאת בשפות אחרות:_
+[_简体中文_](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çe_](README.tr-TR.md),
+[_Italiana_](README.it-IT.md),
+[_Bahasa Indonesia_](README.id-ID.md),
+[_Українська_](README.uk-UA.md),
+[_Arabic_](README.ar-AR.md),
+[_Tiếng Việt_](README.vi-VN.md),
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.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` [טבלת גיבוב](src/data-structures/hash-table)
+* `B` [ערימה](src/data-structures/heap) - גרסאות מקסימום ומינימום
+* `B` [תור עדיפויות](src/data-structures/priority-queue)
+* `A` [עץ תחיליות](src/data-structures/trie)
+* `A` [עץ](src/data-structures/tree)
+ * `A` [עץ חיפוש בינארי](src/data-structures/tree/binary-search-tree)
+ * `A` [עץ AVL](src/data-structures/tree/avl-tree)
+ * `A` [עץ אדום-שחור](src/data-structures/tree/red-black-tree)
+ * `A` [עץ מקטעים](src/data-structures/tree/segment-tree) - עם דוגמאות לשאילתות מינימום/מקסימום/סכום של טווח
+ * `A` [עץ פנוויק](src/data-structures/tree/fenwick-tree) (עץ בינארי מאונדקס)
+* `A` [גרף](src/data-structures/graph) (מכוון ולא מכוון)
+* `A` [קבוצה מופרדת](src/data-structures/disjoint-set) - מבנה נתונים של איחוד-מציאה או מיזוג-מציאה
+* `A` [מסנן בלום](src/data-structures/bloom-filter)
+* `A` [מטמון LRU](src/data-structures/lru-cache/) - מטמון פחות שימוש לאחרונה (LRU)
+
+## אלגוריתמים
+
+אלגוריתם הוא מפרט חד משמעי כיצד לפתור סוג של בעיות. זוהי קבוצה של כללים המגדירים במדויק רצף של פעולות.
+
+`B` - מתחיל, `A` - מתקדם
+
+### אלגוריתמים לפי נושא
+
+* **מתמטיקה**
+ * `B` [מניפולציה על ביטים](src/algorithms/math/bits) - קביעה/עדכון/ניקוי ביטים, הכפלה/חילוק ב-2, הפיכה לשלילי וכו'
+ * `B` [נקודה צפה בינארית](src/algorithms/math/binary-floating-point) - ייצוג בינארי של מספרים בנקודה צפה
+ * `B` [פקטוריאל](src/algorithms/math/factorial)
+ * `B` [מספר פיבונאצ'י](src/algorithms/math/fibonacci) - גרסאות קלאסיות וסגורות
+ * `B` [גורמים ראשוניים](src/algorithms/math/prime-factors) - מציאת גורמים ראשוניים וספירתם באמצעות משפט הארדי-רמנוג'אן
+ * `B` [בדיקת ראשוניות](src/algorithms/math/primality-test) (שיטת החלוקה הניסיונית)
+ * `B` [אלגוריתם אוקלידס](src/algorithms/math/euclidean-algorithm) - חישוב המחלק המשותף הגדול ביותר (GCD)
+ * `B` [המכפיל המשותף הקטן ביותר](src/algorithms/math/least-common-multiple) (LCM)
+ * `B` [נפה של ארטוסתנס](src/algorithms/math/sieve-of-eratosthenes) - מציאת כל המספרים הראשוניים עד לגבול כלשהו
+ * `B` [האם חזקה של שתיים](src/algorithms/math/is-power-of-two) - בדיקה אם מספר הוא חזקה של שתיים (אלגוריתמים נאיביים וביטיים)
+ * `B` [משולש פסקל](src/algorithms/math/pascal-triangle)
+ * `B` [מספר מרוכב](src/algorithms/math/complex-number) - מספרים מרוכבים ופעולות בסיסיות עליהם
+ * `B` [רדיאן ומעלות](src/algorithms/math/radian) - המרה מרדיאנים למעלות ובחזרה
+ * `B` [חזקה מהירה](src/algorithms/math/fast-powering)
+ * `B` [שיטת הורנר](src/algorithms/math/horner-method) - הערכת פולינום
+ * `B` [מטריצות](src/algorithms/math/matrix) - מטריצות ופעולות בסיסיות על מטריצות (כפל, טרנספוזיציה וכו')
+ * `B` [מרחק אוקלידי](src/algorithms/math/euclidean-distance) - מרחק בין שתי נקודות/וקטורים/מטריצות
+ * `A` [חלוקת מספר שלם](src/algorithms/math/integer-partition)
+ * `A` [שורש ריבועי](src/algorithms/math/square-root) - שיטת ניוטון
+ * `A` [אלגוריתם π של ליו הוי](src/algorithms/math/liu-hui) - חישובי π מקורבים על בסיס N-גונים
+ * `A` [התמרת פורייה הבדידה](src/algorithms/math/fourier-transform) - פירוק פונקציה של זמן (אות) לתדרים המרכיבים אותה
+
+* **קבוצות**
+ * `B` [מכפלה קרטזית](src/algorithms/sets/cartesian-product) - מכפלה של מספר קבוצות
+ * `B` [ערבוב פישר-ייטס](src/algorithms/sets/fisher-yates) - תמורה אקראית של רצף סופי
+ * `A` [קבוצת חזקה](src/algorithms/sets/power-set) - כל תתי הקבוצות של קבוצה (פתרונות ביטיים, מעקב לאחור וקסקדה)
+ * `A` [תמורות](src/algorithms/sets/permutations) (עם ובלי חזרות)
+ * `A` [צירופים](src/algorithms/sets/combinations) (עם ובלי חזרות)
+ * `A` [תת-רצף משותף ארוך ביותר](src/algorithms/sets/longest-common-subsequence) (LCS)
+ * `A` [תת-רצף עולה ארוך ביותר](src/algorithms/sets/longest-increasing-subsequence)
+ * `A` [על-רצף משותף קצר ביותר](src/algorithms/sets/shortest-common-supersequence) (SCS)
+ * `A` [בעיית התרמיל](src/algorithms/sets/knapsack-problem) - "0/1" ו"לא מוגבל"
+ * `A` [תת-מערך מקסימלי](src/algorithms/sets/maximum-subarray) - "כוח ברוטלי" ו"תכנות דינמי" (Kadane) גרסאות
+ * `A` [סכום צירוף](src/algorithms/sets/combination-sum) - מציאת כל הצירופים שיוצרים סכום ספציפי
+
+* **מחרוזות**
+ * `B` [מרחק המינג](src/algorithms/string/hamming-distance) - מספר העמדות שבהן הסמלים שונים
+ * `B` [פלינדרום](src/algorithms/string/palindrome) - בדיקה אם המחרוזת זהה בקריאה לאחור
+ * `A` [מרחק לוונשטיין](src/algorithms/string/levenshtein-distance) - מרחק העריכה המינימלי בין שתי רצפים
+ * `A` [אלגוריתם קנות'-מוריס-פראט](src/algorithms/string/knuth-morris-pratt) (אלגוריתם KMP) - חיפוש תת-מחרוזת (התאמת תבנית)
+ * `A` [אלגוריתם Z](src/algorithms/string/z-algorithm) - חיפוש תת-מחרוזת (התאמת תבנית)
+ * `A` [אלגוריתם רבין קארפ](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` [חיפוש קפיצות](src/algorithms/search/jump-search) (או חיפוש בלוקים) - חיפוש במערך ממוין
+ * `B` [חיפוש בינארי](src/algorithms/search/binary-search) - חיפוש במערך ממוין
+ * `B` [חיפוש אינטרפולציה](src/algorithms/search/interpolation-search) - חיפוש במערך ממוין עם התפלגות אחידה
+
+* **מיון**
+ * `B` [מיון בועות](src/algorithms/sorting/bubble-sort)
+ * `B` [מיון בחירה](src/algorithms/sorting/selection-sort)
+ * `B` [מיון הכנסה](src/algorithms/sorting/insertion-sort)
+ * `B` [מיון ערימה](src/algorithms/sorting/heap-sort)
+ * `B` [מיון מיזוג](src/algorithms/sorting/merge-sort)
+ * `B` [מיון מהיר](src/algorithms/sorting/quick-sort) - יישומים במקום ולא במקום
+ * `B` [מיון צדפות](src/algorithms/sorting/shell-sort)
+ * `B` [מיון ספירה](src/algorithms/sorting/counting-sort)
+ * `B` [מיון בסיס](src/algorithms/sorting/radix-sort)
+ * `B` [מיון דלי](src/algorithms/sorting/bucket-sort)
+
+* **רשימות מקושרות**
+ * `B` [מעבר ישר](src/algorithms/linked-list/traversal)
+ * `B` [מעבר הפוך](src/algorithms/linked-list/reverse-traversal)
+
+* **עצים**
+ * `B` [חיפוש לעומק](src/algorithms/tree/depth-first-search) (DFS)
+ * `B` [חיפוש לרוחב](src/algorithms/tree/breadth-first-search) (BFS)
+
+* **גרפים**
+ * `B` [חיפוש לעומק](src/algorithms/graph/depth-first-search) (DFS)
+ * `B` [חיפוש לרוחב](src/algorithms/graph/breadth-first-search) (BFS)
+ * `B` [אלגוריתם קרוסקל](src/algorithms/graph/kruskal) - מציאת עץ פורש מינימלי (MST) עבור גרף לא מכוון משוקלל
+ * `A` [אלגוריתם דייקסטרה](src/algorithms/graph/dijkstra) - מציאת המסלולים הקצרים ביותר לכל קודקודי הגרף מקודקוד יחיד
+ * `A` [אלגוריתם בלמן-פורד](src/algorithms/graph/bellman-ford) - מציאת המסלולים הקצרים ביותר לכל קודקודי הגרף מקודקוד יחיד
+ * `A` [אלגוריתם פלויד-וורשל](src/algorithms/graph/floyd-warshall) - מציאת המסלולים הקצרים ביותר בין כל זוגות הקודקודים
+ * `A` [זיהוי מעגל](src/algorithms/graph/detect-cycle) - עבור גרפים מכוונים ולא מכוונים (גרסאות מבוססות DFS וקבוצה מופרדת)
+ * `A` [אלגוריתם פרים](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/eulerian-path) - אלגוריתם פלרי - ביקור בכל קשת בדיוק פעם אחת
+ * `A` [מעגל המילטון](src/algorithms/graph/hamiltonian-cycle) - ביקור בכל קודקוד בדיוק פעם אחת
+ * `A` [רכיבים קשירים חזק](src/algorithms/graph/strongly-connected-components) - אלגוריתם קוסרג'ו
+ * `A` [בעיית הסוכן הנוסע](src/algorithms/graph/travelling-salesman) - המסלול הקצר ביותר האפשרי שמבקר בכל עיר וחוזר לעיר המוצא
+
+* **הצפנה**
+ * `B` [גיבוב פולינומי](src/algorithms/cryptography/polynomial-hash) - פונקציית גיבוב מתגלגלת המבוססת על פולינום
+ * `B` [צופן גדר מסילה](src/algorithms/cryptography/rail-fence-cipher) - אלגוריתם הצפנת טרנספוזיציה להצפנת הודעות
+ * `B` [צופן קיסר](src/algorithms/cryptography/caesar-cipher) - צופן החלפה פשוט
+ * `B` [צופן היל](src/algorithms/cryptography/hill-cipher) - צופן החלפה המבוסס על אלגברה לינארית
+
+* **למידת מכונה**
+ * `B` [NanoNeuron](https://github.com/trekhleb/nano-neuron) - 7 פונקציות JS פשוטות שמדגימות כיצד מכונות יכולות ללמוד באמת (תפוצה קדימה/אחורה)
+ * `B` [k-NN](src/algorithms/ml/knn) - אלגוריתם סיווג k-השכנים הקרובים ביותר
+ * `B` [k-Means](src/algorithms/ml/k-means) - אלגוריתם אשכול k-Means
+
+* **עיבוד תמונה**
+ * `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - אלגוריתם שינוי גודל תמונה מודע תוכן
+
+* **סטטיסטיקה**
+ * `B` [משקל אקראי](src/algorithms/statistics/weighted-random) - בחירת פריט אקראי מהרשימה על בסיס משקלי הפריטים
+
+* **אלגוריתמים אבולוציוניים**
+ * `A` [אלגוריתם גנטי](https://github.com/trekhleb/self-parking-car-evolution) - דוגמה לאופן שבו ניתן ליישם אלגוריתם גנטי לאימון מכוניות בחניה עצמית
+
+* **לא מסווג**
+ * `B` [מגדלי האנוי](src/algorithms/uncategorized/hanoi-tower)
+ * `B` [סיבוב מטריצה ריבועית](src/algorithms/uncategorized/square-matrix-rotation) - אלגוריתם במקום
+ * `B` [משחק הקפיצות](src/algorithms/uncategorized/jump-game) - דוגמאות למעקב לאחור, תכנות דינמי (מלמעלה למטה + מלמטה למעלה) וחמדני
+ * `B` [מסלולים ייחודיים](src/algorithms/uncategorized/unique-paths) - דוגמאות למעקב לאחור, תכנות דינמי ומבוססות על משולש פסקל
+ * `B` [מדרגות גשם](src/algorithms/uncategorized/rain-terraces) - בעיית לכידת מי גשם (גרסאות תכנות דינמי וכוח ברוטלי)
+ * `B` [מדרגות רקורסיביות](src/algorithms/uncategorized/recursive-staircase) - ספירת מספר הדרכים להגיע לראש (4 פתרונות)
+ * `B` [הזמן הטוב ביותר לקנות ולמכור מניות](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - דוגמאות לחלוקה וכיבוש ומעבר אחד
+ * `A` [בעיית N-המלכות](src/algorithms/uncategorized/n-queens)
+ * `A` [סיור הפרש](src/algorithms/uncategorized/knight-tour)
+
+### אלגוריתמים לפי פרדיגמה
+
+פרדיגמה אלגוריתמית היא שיטה או גישה כללית המונחת בבסיס התכנון של מחלקת אלגוריתמים. זוהי הפשטה גבוהה יותר מהמושג של אלגוריתם, בדיוק כפי שאלגוריתם הוא הפשטה גבוהה יותר מתוכנית מחשב.
+
+* **כוח ברוטלי** - בודק את כל האפשרויות ובוחר את הפתרון הטוב ביותר
+ * `B` [חיפוש לינארי](src/algorithms/search/linear-search)
+ * `B` [מדרגות גשם](src/algorithms/uncategorized/rain-terraces) - בעיית לכידת מי גשם
+ * `B` [מדרגות רקורסיביות](src/algorithms/uncategorized/recursive-staircase) - ספירת מספר הדרכים להגיע לראש
+ * `A` [תת-מערך מקסימלי](src/algorithms/sets/maximum-subarray)
+ * `A` [בעיית הסוכן הנוסע](src/algorithms/graph/travelling-salesman) - המסלול הקצר ביותר האפשרי שמבקר בכל עיר וחוזר לעיר המוצא
+ * `A` [התמרת פורייה הבדידה](src/algorithms/math/fourier-transform) - פירוק פונקציה של זמן (אות) לתדרים המרכיבים אותה
+
+* **חמדני** - בוחר את האפשרות הטובה ביותר בזמן הנוכחי, ללא כל התחשבות בעתיד
+ * `B` [משחק הקפיצות](src/algorithms/uncategorized/jump-game)
+ * `A` [בעיית התרמיל הלא מוגבל](src/algorithms/sets/knapsack-problem)
+ * `A` [אלגוריתם דייקסטרה](src/algorithms/graph/dijkstra) - מציאת המסלולים הקצרים ביותר לכל קודקודי הגרף
+ * `A` [אלגוריתם פרים](src/algorithms/graph/prim) - מציאת עץ פורש מינימלי (MST) עבור גרף לא מכוון משוקלל
+ * `A` [אלגוריתם קרוסקל](src/algorithms/graph/kruskal) - מציאת עץ פורש מינימלי (MST) עבור גרף לא מכוון משוקלל
+
+* **חלוקה וכיבוש** - מחלק את הבעיה לחלקים קטנים יותר ואז פותר חלקים אלה
+ * `B` [חיפוש בינארי](src/algorithms/search/binary-search)
+ * `B` [מגדלי האנוי](src/algorithms/uncategorized/hanoi-tower)
+ * `B` [משולש פסקל](src/algorithms/math/pascal-triangle)
+ * `B` [אלגוריתם אוקלידס](src/algorithms/math/euclidean-algorithm) - חישוב המחלק המשותף הגדול ביותר (GCD)
+ * `B` [מיון מיזוג](src/algorithms/sorting/merge-sort)
+ * `B` [מיון מהיר](src/algorithms/sorting/quick-sort)
+ * `B` [חיפוש לעומק בעץ](src/algorithms/tree/depth-first-search) (DFS)
+ * `B` [חיפוש לעומק בגרף](src/algorithms/graph/depth-first-search) (DFS)
+ * `B` [מטריצות](src/algorithms/math/matrix) - יצירה ומעבר על מטריצות בצורות שונות
+ * `B` [משחק הקפיצות](src/algorithms/uncategorized/jump-game)
+ * `B` [חזקה מהירה](src/algorithms/math/fast-powering)
+ * `B` [הזמן הטוב ביותר לקנות ולמכור מניות](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - דוגמאות לחלוקה וכיבוש ומעבר אחד
+ * `A` [תמורות](src/algorithms/sets/permutations) (עם ובלי חזרות)
+ * `A` [צירופים](src/algorithms/sets/combinations) (עם ובלי חזרות)
+ * `A` [תת-מערך מקסימלי](src/algorithms/sets/maximum-subarray)
+
+* **תכנות דינמי** - בניית פתרון באמצעות תת-פתרונות שנמצאו קודם לכן
+ * `B` [מספר פיבונאצ'י](src/algorithms/math/fibonacci)
+ * `B` [משחק הקפיצות](src/algorithms/uncategorized/jump-game)
+ * `B` [מסלולים ייחודיים](src/algorithms/uncategorized/unique-paths)
+ * `B` [מדרגות גשם](src/algorithms/uncategorized/rain-terraces) - בעיית לכידת מי גשם
+ * `B` [מדרגות רקורסיביות](src/algorithms/uncategorized/recursive-staircase) - ספירת מספר הדרכים להגיע לראש
+ * `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - אלגוריתם שינוי גודל תמונה מודע תוכן
+ * `A` [מרחק לוונשטיין](src/algorithms/string/levenshtein-distance) - מרחק העריכה המינימלי בין שתי רצפים
+ * `A` [תת-רצף משותף ארוך ביותר](src/algorithms/sets/longest-common-subsequence) (LCS)
+ * `A` [תת-מחרוזת משותפת ארוכה ביותר](src/algorithms/string/longest-common-substring)
+ * `A` [תת-רצף עולה ארוך ביותר](src/algorithms/sets/longest-increasing-subsequence)
+ * `A` [על-רצף משותף קצר ביותר](src/algorithms/sets/shortest-common-supersequence)
+ * `A` [בעיית התרמיל 0/1](src/algorithms/sets/knapsack-problem)
+ * `A` [חלוקת מספר שלם](src/algorithms/math/integer-partition)
+ * `A` [תת-מערך מקסימלי](src/algorithms/sets/maximum-subarray)
+ * `A` [אלגוריתם בלמן-פורד](src/algorithms/graph/bellman-ford) - מציאת המסלולים הקצרים ביותר לכל קודקודי הגרף
+ * `A` [אלגוריתם פלויד-וורשל](src/algorithms/graph/floyd-warshall) - מציאת המסלולים הקצרים ביותר בין כל זוגות הקודקודים
+ * `A` [התאמת ביטוי רגולרי](src/algorithms/string/regular-expression-matching)
+
+* **מעקב לאחור** - בדומה לכוח ברוטלי, מנסה לייצר את כל הפתרונות האפשריים, אך בכל פעם שאתה מייצר פתרון הבא אתה בודק אם הוא עומד בכל התנאים, ורק אז ממשיך לייצר פתרונות הבאים. אחרת, חוזר אחורה, והולך בנתיב אחר של מציאת פתרון. בדרך כלל מעבר DFS של מרחב המצבים משמש.
+ * `B` [משחק הקפיצות](src/algorithms/uncategorized/jump-game)
+ * `B` [מסלולים ייחודיים](src/algorithms/uncategorized/unique-paths)
+ * `B` [קבוצת חזקה](src/algorithms/sets/power-set) - כל תתי הקבוצות של קבוצה
+ * `A` [מעגל המילטון](src/algorithms/graph/hamiltonian-cycle) - ביקור בכל קודקוד בדיוק פעם אחת
+ * `A` [בעיית N-המלכות](src/algorithms/uncategorized/n-queens)
+ * `A` [סיור הפרש](src/algorithms/uncategorized/knight-tour)
+ * `A` [סכום צירוף](src/algorithms/sets/combination-sum) - מציאת כל הצירופים שיוצרים סכום ספציפי
+
+* **סניף וחסום** - זוכר את הפתרון בעלות הנמוכה ביותר שנמצא בכל שלב של החיפוש המעקב לאחור, ומשתמש בעלות של הפתרון בעלות הנמוכה ביותר שנמצא עד כה כגבול תחתון על העלות של פתרון בעלות מינימלית לבעיה, על מנת לפסול פתרונות חלקיים עם עלויות גדולות יותר מהפתרון בעלות הנמוכה ביותר שנמצא עד כה. בדרך כלל מעבר BFS בשילוב עם מעבר DFS של עץ מרחב המצבים משמש.
+
+## כיצד להשתמש במאגר זה
+
+**התקנת כל התלויות**
+
+```
+npm install
+```
+
+**הרצת ESLint**
+
+ייתכן שתרצה להריץ אותו כדי לבדוק את איכות הקוד.
+
+```
+npm run lint
+```
+
+**הרצת כל הבדיקות**
+
+```
+npm test
+```
+
+**הרצת בדיקות לפי שם**
+
+```
+npm test -- 'LinkedList'
+```
+
+**פתרון בעיות**
+
+אם הלינטינג או הבדיקות נכשלים, נסה למחוק את התיקייה `node_modules` ולהתקין מחדש את חבילות npm:
+
+```
+rm -rf ./node_modules
+npm i
+```
+
+בנוסף, ודא שאתה משתמש בגרסת Node נכונה (`>=16`). אם אתה משתמש ב-[nvm](https://github.com/nvm-sh/nvm) לניהול גרסאות Node, תוכל להריץ `nvm use` מתיקיית השורש של הפרויקט והגרסה הנכונה תיבחר.
+
+**שטח משחקים**
+
+אתה יכול לשחק עם מבני נתונים ואלגוריתמים בקובץ `./src/playground/playground.js` ולכתוב
+בדיקות עבורו ב-`./src/playground/__test__/playground.test.js`.
+
+לאחר מכן פשוט הרץ את הפקודה הבאה כדי לבדוק אם קוד שטח המשחקים שלך עובד כמצופה:
+
+```
+npm test -- 'playground'
+```
+
+## מידע שימושי
+
+### הפניות
+
+- [▶ מבני נתונים ואלגוריתמים ב-YouTube](https://www.youtube.com/playlist?list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [✍🏻 סקיצות של מבני נתונים](https://okso.app/showcase/data-structures)
+
+### סימון ה-O הגדול
+
+סימון *ה-O הגדול* משמש לסיווג אלגוריתמים לפי כיצד זמן הריצה או דרישות המרחב שלהם גדלים ככל שגודל הקלט גדל.
+בתרשים שלהלן תוכל למצוא את הסדרים הנפוצים ביותר של צמיחת אלגוריתמים המצוינים בסימון ה-O הגדול.
+
+
+
+מקור: [Big O Cheat Sheet](http://bigocheatsheet.com/).
+
+להלן רשימה של כמה מסימוני ה-O הגדול הנפוצים ביותר והשוואות הביצועים שלהם מול גדלים שונים של נתוני קלט.
+
+| סימון ה-O הגדול | חישובים ל-10 אלמנטים | חישובים ל-100 אלמנטים | חישובים ל-1000 אלמנטים |
+| ---------------- | --------------------- | ---------------------- | ----------------------- |
+| **O(1)** | 1 | 1 | 1 |
+| **O(log N)** | 3 | 6 | 9 |
+| **O(N)** | 10 | 100 | 1000 |
+| **O(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** | log(n) | log(n) | log(n) | log(n) | |
+| **עץ אדום-שחור** | log(n) | log(n) | log(n) | log(n) | |
+| **עץ AVL** | log(n) | log(n) | log(n) | log(n) | |
+| **מסנן בלום** | - | 1 | 1 | - | תוצאות חיוביות שגויות אפשריות בעת חיפוש |
+
+### מורכבות אלגוריתמי מיון מערכים
+
+| שם | הטוב ביותר | ממוצע | הגרוע ביותר | זיכרון | יציב | הערות |
+| ------------------- | :----------------: | :-----------------: | :------------------: | :-----: | :-----: | :------ |
+| **מיון בועות** | n | n2 | n2 | 1 | כן | |
+| **מיון הכנסה** | n | n2 | n2 | 1 | כן | |
+| **מיון בחירה** | n2 | n2 | n2 | 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) | n2 | log(n) | לא | מיון מהיר בדרך כלל מבוצע במקום עם O(log(n)) שטח מחסנית |
+| **מיון צדפות** | n log(n) | תלוי ברצף הפער | n (log(n))2 | 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) `∑ = 1`
+
+## מחבר
+
+[@trekhleb](https://trekhleb.dev)
+
+כמה [פרויקטים](https://trekhleb.dev/projects/) ו[מאמרים](https://trekhleb.dev/blog/) נוספים על JavaScript ואלגוריתמים ב-[trekhleb.dev](https://trekhleb.dev)* `B` [משחק הקפיצות](src/algorithms/uncategor * `B` [חיפוש בינארי](src/algorithms
diff --git a/README.id-ID.md b/README.id-ID.md
index b204f2a8f8..ffc093d3ba 100644
--- a/README.id-ID.md
+++ b/README.id-ID.md
@@ -23,9 +23,9 @@ _Baca ini dalam bahasa yang lain:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
-
-_☝ Perhatikan bahwa proyek ini hanya dimaksudkan untuk tujuan pembelajaran dan riset, dan **tidak** dimaksudkan untuk digunakan sebagai produksi._
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## Struktur Data
diff --git a/README.it-IT.md b/README.it-IT.md
index 6ac47fa5bc..127e9adba1 100644
--- a/README.it-IT.md
+++ b/README.it-IT.md
@@ -22,9 +22,9 @@ _Leggilo in altre lingue:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
-
-*☝ Si noti che questo progetto è destinato ad essere utilizzato solo per l'apprendimento e la ricerca e non è destinato ad essere utilizzato per il commercio.*
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## Strutture Dati
diff --git a/README.ja-JP.md b/README.ja-JP.md
index e10bb94083..acf9dee8f0 100644
--- a/README.ja-JP.md
+++ b/README.ja-JP.md
@@ -25,7 +25,9 @@ _Read this in other languages:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## データ構造
diff --git a/README.ko-KR.md b/README.ko-KR.md
index b48c43aa56..d4b0d4ef14 100644
--- a/README.ko-KR.md
+++ b/README.ko-KR.md
@@ -24,7 +24,9 @@ _Read this in other languages:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## 자료 구조
diff --git a/README.md b/README.md
index e06cfb9075..560b396045 100644
--- a/README.md
+++ b/README.md
@@ -31,15 +31,14 @@ _Read this in other languages:_
[_Português_](README.pt-BR.md),
[_Русский_](README.ru-RU.md),
[_Türkçe_](README.tr-TR.md),
-[_Italiana_](README.it-IT.md),
+[_Italiano_](README.it-IT.md),
[_Bahasa Indonesia_](README.id-ID.md),
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
-
-*☝ Note that this project is meant to be used for learning and researching purposes
-only, and it is **not** meant to be used for production.*
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md),
+[_עברית_](README.he-IL.md)
## Data Structures
@@ -48,6 +47,8 @@ be accessed and modified efficiently. More precisely, a data structure is a coll
values, the relationships among them, and the functions or operations that can be applied to
the data.
+Remember that each data has its own trade-offs. And you need to pay attention more to why you're choosing a certain data structure than to how to implement it.
+
`B` - Beginner, `A` - Advanced
* `B` [Linked List](src/data-structures/linked-list)
@@ -182,6 +183,7 @@ a set of rules that precisely define a sequence of operations.
* `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem (dynamic programming and brute force versions)
* `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach to the top (4 solutions)
* `B` [Best Time To Buy Sell Stocks](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - divide and conquer and one-pass examples
+ * `B` [Valid Parentheses](src/algorithms/stack/valid-parentheses) - check if a string has valid parentheses (using stack)
* `A` [N-Queens Problem](src/algorithms/uncategorized/n-queens)
* `A` [Knight's Tour](src/algorithms/uncategorized/knight-tour)
@@ -194,7 +196,7 @@ algorithm is an abstraction higher than a computer program.
* **Brute Force** - look at all the possibilities and selects the best solution
* `B` [Linear Search](src/algorithms/search/linear-search)
* `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem
- * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach to the top
+ * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach the top
* `A` [Maximum Subarray](src/algorithms/sets/maximum-subarray)
* `A` [Travelling Salesman Problem](src/algorithms/graph/travelling-salesman) - shortest possible route that visits each city and returns to the origin city
* `A` [Discrete Fourier Transform](src/algorithms/math/fourier-transform) - decompose a function of time (a signal) into the frequencies that make it up
@@ -225,7 +227,7 @@ algorithm is an abstraction higher than a computer program.
* `B` [Jump Game](src/algorithms/uncategorized/jump-game)
* `B` [Unique Paths](src/algorithms/uncategorized/unique-paths)
* `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem
- * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach to the top
+ * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach the top
* `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - content-aware image resizing algorithm
* `A` [Levenshtein Distance](src/algorithms/string/levenshtein-distance) - minimum edit distance between two sequences
* `A` [Longest Common Subsequence](src/algorithms/sets/longest-common-subsequence) (LCS)
@@ -238,9 +240,9 @@ algorithm is an abstraction higher than a computer program.
* `A` [Bellman-Ford Algorithm](src/algorithms/graph/bellman-ford) - finding the shortest path to all graph vertices
* `A` [Floyd-Warshall Algorithm](src/algorithms/graph/floyd-warshall) - find the shortest paths between all pairs of vertices
* `A` [Regular Expression Matching](src/algorithms/string/regular-expression-matching)
-* **Backtracking** - similarly to brute force, try to generate all possible solutions, but each time you generate next solution you test
-if it satisfies all conditions, and only then continue generating subsequent solutions. Otherwise, backtrack, and go on a
-different path of finding a solution. Normally the DFS traversal of state-space is being used.
+* **Backtracking** - similarly to brute force, try to generate all possible solutions, but each time you generate the next solution, you test
+if it satisfies all conditions and only then continue generating subsequent solutions. Otherwise, backtrack and go on a
+different path to finding a solution. Normally the DFS traversal of state-space is being used.
* `B` [Jump Game](src/algorithms/uncategorized/jump-game)
* `B` [Unique Paths](src/algorithms/uncategorized/unique-paths)
* `B` [Power Set](src/algorithms/sets/power-set) - all subsets of a set
@@ -250,8 +252,8 @@ different path of finding a solution. Normally the DFS traversal of state-space
* `A` [Combination Sum](src/algorithms/sets/combination-sum) - find all combinations that form specific sum
* **Branch & Bound** - remember the lowest-cost solution found at each stage of the backtracking
search, and use the cost of the lowest-cost solution found so far as a lower bound on the cost of
-a least-cost solution to the problem, in order to discard partial solutions with costs larger than the
-lowest-cost solution found so far. Normally BFS traversal in combination with DFS traversal of state-space
+a least-cost solution to the problem in order to discard partial solutions with costs larger than the
+lowest-cost solution found so far. Normally, BFS traversal in combination with DFS traversal of state-space
tree is being used.
## How to use this repository
@@ -291,14 +293,14 @@ rm -rf ./node_modules
npm i
```
-Also make sure that you're using a correct Node version (`>=16`). If you're using [nvm](https://github.com/nvm-sh/nvm) for Node version management you may run `nvm use` from the root folder of the project and the correct version will be picked up.
+Also, make sure that you're using the correct Node version (`>=16`). If you're using [nvm](https://github.com/nvm-sh/nvm) for Node version management you may run `nvm use` from the root folder of the project and the correct version will be picked up.
**Playground**
You may play with data-structures and algorithms in `./src/playground/playground.js` file and write
tests for it in `./src/playground/__test__/playground.test.js`.
-Then just simply run the following command to test if your playground code works as expected:
+Then just, simply run the following command to test if your playground code works as expected:
```
npm test -- 'playground'
@@ -314,7 +316,7 @@ npm test -- 'playground'
### Big O Notation
*Big O notation* is used to classify algorithms according to how their running time or space requirements grow as the input size grows.
-On the chart below you may find most common orders of growth of algorithms specified in Big O notation.
+On the chart below, you may find the most common orders of growth of algorithms specified in Big O notation.
diff --git a/README.pl-PL.md b/README.pl-PL.md
index 52ba75a5e4..56617030ab 100644
--- a/README.pl-PL.md
+++ b/README.pl-PL.md
@@ -26,7 +26,9 @@ _Read this in other languages:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## Struktury Danych
diff --git a/README.pt-BR.md b/README.pt-BR.md
index a937e8c0bf..5b16798bc9 100644
--- a/README.pt-BR.md
+++ b/README.pt-BR.md
@@ -26,7 +26,9 @@ _Leia isto em outros idiomas:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## Estrutura de Dados
diff --git a/README.ru-RU.md b/README.ru-RU.md
index 541e1d2703..bdad2da9ec 100644
--- a/README.ru-RU.md
+++ b/README.ru-RU.md
@@ -23,9 +23,9 @@ _Читать на других языках:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
-
-*☝ Замечание: этот репозиторий предназначен для учебно-исследовательских целей (**не** для использования в продакшн-системах).*
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## Структуры данных
diff --git a/README.tr-TR.md b/README.tr-TR.md
index 805bf7b431..368baeea91 100644
--- a/README.tr-TR.md
+++ b/README.tr-TR.md
@@ -23,10 +23,9 @@ _Read this in other languages:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
-
-*☝ Not, bu proje araştırma ve öğrenme amacı ile yapılmış
-olup üretim için **yapılmamıştır**.*
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## Veri Yapıları
diff --git a/README.uk-UA.md b/README.uk-UA.md
index dd129b2c3c..a32e2390da 100644
--- a/README.uk-UA.md
+++ b/README.uk-UA.md
@@ -23,9 +23,9 @@ _Вивчення матеріалу на інших мовах:_
[_Bahasa Indonesia_](README.id-ID.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
-
-*☝ Зверніть увагу! Даний проект призначений лише для навчальних та дослідницьких цілей, і він **не** призначений для виробництва (продакшн).*
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## Структури даних
diff --git a/README.uz-UZ.md b/README.uz-UZ.md
new file mode 100644
index 0000000000..f951f1e494
--- /dev/null
+++ b/README.uz-UZ.md
@@ -0,0 +1,356 @@
+# JavaScript algoritmlari va ma'lumotlar tuzilmalari
+
+[](https://github.com/trekhleb/javascript-algorithms/actions?query=workflow%3ACI+branch%3Amaster)
+[](https://codecov.io/gh/trekhleb/javascript-algorithms)
+
+
+Bu repozitoriyada JavaScript-ga asoslangan ko'plab mashhur algoritmlar
+va ma'lumotlar tuzilmalarining namunalari mavjud.
+
+Har bir algoritm va ma'lumotlar tuzilmasining alohida README fayli
+bo'lib, unda tegishli tushuntirishlar va qo'shimcha o'qish uchun
+havolalar (shu jumladan YouTube videolariga ham havolalar) mavjud.
+
+_Read this in other languages:_
+[_简体中文_](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çe_](README.tr-TR.md),
+[_Italiana_](README.it-IT.md),
+[_Bahasa Indonesia_](README.id-ID.md),
+[_Українська_](README.uk-UA.md),
+[_Arabic_](README.ar-AR.md),
+[_Tiếng Việt_](README.vi-VN.md),
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
+
+## Ma'lumotlar tuzilmalari
+
+Ma'lumotlar tuzilmasi - bu kompyuterda ma'lumotlarni samarali tarzda
+olish va o'zgartirish uchun ularni tashkil etish va saqlashning ma'lum
+bir usuli. Ayniqsa, ma'lumotlar tuzilmasi ma'lumot qiymatlarining
+to'plami, ular orasidagi munosabatlar va ma'lumotlarga qo'llanilishi
+mumkin bo'lgan funksiyalar yoki operatsiyalardir.
+
+`B` - Boshlang'ich, `A` - Ilg'or
+
+- `B` [Bog'langan ro'yxat](src/data-structures/linked-list)
+- `B` [Ikki marta bog'langan ro'yxat](src/data-structures/doubly-linked-list)
+- `B` [Navbat](src/data-structures/queue)
+- `B` [Stek](src/data-structures/stack)
+- `B` [Hash jadvali](src/data-structures/hash-table)
+- `B` [Heap](src/data-structures/heap) - maksimal va minimal heap versiyalari
+- `B` [Ustuvor navbat](src/data-structures/priority-queue)
+- `A` [Trie](src/data-structures/trie)
+- `A` [Daraxt](src/data-structures/tree)
+ - `A` [Ikkilik qidiruv daraxt](src/data-structures/tree/binary-search-tree)
+ - `A` [AVL daraxt](src/data-structures/tree/avl-tree)
+ - `A` [Qizil-qora daraxt](src/data-structures/tree/red-black-tree)
+ - `A` [Segment daraxt](src/data-structures/tree/segment-tree) - min/max/sum diapazon so'rovlari bilan misollar
+ - `A` [Fenwick daraxt](src/data-structures/tree/fenwick-tree) (ikkilik indeksli daraxt)
+- `A` [Graf](src/data-structures/graph) (yo'naltirilgan hamda yo'naltirilmagan)
+- `A` [Ajratilgan to'plam](src/data-structures/disjoint-set) - union-find ma'lumotlar strukturasi yoki merge-find to'plami
+- `A` [Bloom filtri](src/data-structures/bloom-filter)
+- `A` [LRU keshi](src/data-structures/lru-cache/) - Eng kam ishlatilgan (LRU) keshi
+
+## Algoritmlar
+
+Algoritm muammolar sinfini qanday hal qilishning aniq spetsifikatsiyasi. Bu operatsiyalar ketma-ketligini aniqlaydigan qoidalar to'plami.
+
+`B` - Boshlang'ich, `A` - Ilg'or
+
+### Mavzu bo'yicha algoritmlar
+
+- **Matematika**
+ - `B` [Bit manipulatsiyasi](src/algorithms/math/bits) - bitlarni qo'yish/olish/yangilash/tozalash, ikkilikka ko'paytirish/bo'lish, manfiy qilish va hokazo.
+ - `B` [Ikkilik suzuvchi nuqta](src/algorithms/math/binary-floating-point) - suzuvchi nuqtali sonlarning ikkilik tasviri.
+ - `B` [Faktorial](src/algorithms/math/factorial)
+ - `B` [Fibonachchi raqam](src/algorithms/math/fibonacci) - klassik va yopiq shakldagi versiyalar
+ - `B` [Asosiy omillar](src/algorithms/math/prime-factors) - tub omillarni topish va ularni Xardi-Ramanujan teoremasi yordamida sanash
+ - `B` [Birlamchilik testi](src/algorithms/math/primality-test) (sinov bo'linish usuli)
+ - `B` [Evklid algoritmi](src/algorithms/math/euclidean-algorithm) - eng katta umumiy bo'luvchini (EKUB) hisoblash
+ - `B` [Eng kichik umumiy karrali](src/algorithms/math/least-common-multiple) (EKUK)
+ - `B` [Eratosfen elagi](src/algorithms/math/sieve-of-eratosthenes) - berilgan chegaragacha barcha tub sonlarni topish
+ - `B` [Ikkining darajasimi](src/algorithms/math/is-power-of-two) - raqamning ikkining darajasi ekanligini tekshirish (sodda va bitli algoritmlar)
+ - `B` [Paskal uchburchagi](src/algorithms/math/pascal-triangle)
+ - `B` [Kompleks sonlar](src/algorithms/math/complex-number) - kompleks sonlar va ular bilan asosiy amallar
+ - `B` [Radian & Daraja](src/algorithms/math/radian) - radianlarni darajaga va orqaga aylantirish
+ - `B` [Tez ko'tarish](src/algorithms/math/fast-powering)
+ - `B` [Horner metodi](src/algorithms/math/horner-method) - polinomlarni baholash
+ - `B` [Matritsalar](src/algorithms/math/matrix) - matritsalar va asosiy matritsa operatsiyalari (ko'paytirish, transpozitsiya va boshqalar).
+ - `B` [Evklid masofasi](src/algorithms/math/euclidean-distance) - ikki nuqta/vektor/matritsa orasidagi masofa
+ - `A` [Butun sonlarni bo'lish](src/algorithms/math/integer-partition)
+ - `A` [Kvadrat ildiz](src/algorithms/math/square-root) - Nyuton metodi
+ - `A` [Liu Hui π algoritmi](src/algorithms/math/liu-hui) - N-gonlarga asoslangan π ning taxminiy hisoblari
+ - `A` [Diskret Furye transformatsiyasi](src/algorithms/math/fourier-transform) - vaqt funksiyasini (signalni) uni tashkil etuvchi chastotalarga ajratish
+- **Sets**
+ - `B` [Karteziya maxsuloti](src/algorithms/sets/cartesian-product) - bir nechta to'plamlarning ko'paytmasi
+ - `B` [Fisher–Yates Shuffle](src/algorithms/sets/fisher-yates) - chekli ketma-ketlikni tasodifiy almashtirish
+ - `A` [Power Set](src/algorithms/sets/power-set) - to'plamning barcha kichik to'plamlari (bitwise, backtracking va kaskadli echimlar)
+ - `A` [Permutatsiyalar](src/algorithms/sets/permutations) (takroriyalash bilan va takroriyalashsiz)
+ - `A` [Kombinatsiyalar](src/algorithms/sets/combinations) (takroriyalash bilan va takroriyalashsiz)
+ - `A` [Eng uzun umumiy ketma-ketlik](src/algorithms/sets/longest-common-subsequence) (LCS)
+ - `A` [Eng uzun ortib boruvchi ketma-ketlik](src/algorithms/sets/longest-increasing-subsequence)
+ - `A` [Eng qisqa umumiy ketma-ketlik](src/algorithms/sets/shortest-common-supersequence) (SCS)
+ - `A` [Knapsack muammosi](src/algorithms/sets/knapsack-problem) - "0/1" va "Bir-biriga bog'lanmagan"
+ - `A` [Maksimal kichik massiv](src/algorithms/sets/maximum-subarray) - Toʻliq kuch va dinamik dasturlash (Kadane usuli) versiyalari
+ - `A` [Kombinatsiya yig'indisi](src/algorithms/sets/combination-sum) - ma'lum summani tashkil etuvchi barcha kombinatsiyalarni topish
+- **Stringlar**
+ - `B` [Hamming masofasi](src/algorithms/string/hamming-distance) - belgilarning bir-biridan farq qiladigan pozitsiyalar soni
+ - `B` [Palindrom](src/algorithms/string/palindrome) - satrning teskari tomoni ham bir xil ekanligini tekshirish
+ - `A` [Levenshtein masofasi](src/algorithms/string/levenshtein-distance) - ikki ketma-ketlik o'rtasidagi minimal tahrirlash masofasi
+ - `A` [Knuth–Morris–Pratt Algoritmi](src/algorithms/string/knuth-morris-pratt) (KMP Algoritmi) - kichik qatorlarni qidirish (mosh keluvchi naqshni qidirish)
+ - `A` [Z Algoritmi](src/algorithms/string/z-algorithm) - kichik qatorlarni qidirish (mosh keluvchi naqshni qidirish)
+ - `A` [Rabin Karp Algoritmi](src/algorithms/string/rabin-karp) - kichik qatorlarni qidirish
+ - `A` [Eng uzun umumiy kichik matn](src/algorithms/string/longest-common-substring)
+ - `A` [Regulyar ifoda moslashuvi](src/algorithms/string/regular-expression-matching) (RegEx)
+- **Qidiruvlar**
+ - `B` [Linear qidirish](src/algorithms/search/linear-search)
+ - `B` [Jump qidirish](src/algorithms/search/jump-search) (yoki Blok qidirish) - saralangan qatorda qidirish
+ - `B` [Ikkilik qidirish](src/algorithms/search/binary-search) - saralangan qatorda qidirish
+ - `B` [Interpolatsiya qidirish](src/algorithms/search/interpolation-search) - bir tekis taqsimlangan saralangan qatorda qidirish
+- **Tartiblash**
+ - `B` [Pufakcha tartiblash](src/algorithms/sorting/bubble-sort)
+ - `B` [Tanlash tartibi](src/algorithms/sorting/selection-sort)
+ - `B` [Kiritish tartibi](src/algorithms/sorting/insertion-sort)
+ - `B` [Heap tartibi](src/algorithms/sorting/heap-sort)
+ - `B` [Birlashtirish tartibi](src/algorithms/sorting/merge-sort)
+ - `B` [Tezkor saralash](src/algorithms/sorting/quick-sort) - joyida va joyida bo'lmagan amalga oshirish
+ - `B` [Shell tartiblash](src/algorithms/sorting/shell-sort)
+ - `B` [Sanash tartibi](src/algorithms/sorting/counting-sort)
+ - `B` [Radiksli tartiblash](src/algorithms/sorting/radix-sort)
+ - `B` [Bucket tartiblash](src/algorithms/sorting/bucket-sort)
+- **Bog'langan ro'yhatlar**
+ - `B` [To'g'ri traversal](src/algorithms/linked-list/traversal)
+ - `B` [Teskari traversal](src/algorithms/linked-list/reverse-traversal)
+- **Daraxtlar**
+ - `B` [Birinchi-pastga qarab qidirish](src/algorithms/tree/depth-first-search) (Depth-First Search)
+ - `B` [Birinchi-yonga qarab qidirish](src/algorithms/tree/breadth-first-search) (Breadth-First Search)
+- **Grafiklar**
+ - `B` [Birinchi-pastga qarab qidirish](src/algorithms/graph/depth-first-search) (Depth-First Search)
+ - `B` [Birinchi-yonga qarab qidirish](src/algorithms/graph/breadth-first-search) (Breadth-First Search)
+ - `B` [Kruskal Algoritmi](src/algorithms/graph/kruskal) - og'irlikdagi yo'naltirilmagan grafik uchun Minimal kengayuvchi daraxtni (MST) topish
+ - `A` [Dijkstra Algoritmi](src/algorithms/graph/dijkstra) - grafikning bir cho'qqisidan qolgan barcha nuqtalarga eng qisqa yo'llarni topish
+ - `A` [Bellman-Ford Algoritmi](src/algorithms/graph/bellman-ford) - grafikning bir cho'qqisidan qolgan barcha nuqtalarga eng qisqa yo'llarni topish
+ - `A` [Floyd-Warshall Algoritmi](src/algorithms/graph/floyd-warshall) - grafikning barcha uchlari orasidagi eng qisqa masofalarni topish
+ - `A` [Siklni aniqlash](src/algorithms/graph/detect-cycle) - yo'naltirilgan va yo'naltirilmagan grafiklar uchun (DFS va Disjoint Set-ga asoslangan versiyalar)
+ - `A` [Prim Algoritmi](src/algorithms/graph/prim) - og'irlikdagi yo'naltirilmagan grafik uchun Minimal kengayuvchi daraxtni (MST) topish
+ - `A` [Topologik saralash](src/algorithms/graph/topological-sorting) - DFS metodi
+ - `A` [Artikulyatsiya nuqtalari](src/algorithms/graph/articulation-points) - Tarjan algoritmi (DFS asosida)
+ - `A` [Ko'priklar](src/algorithms/graph/bridges) - DFS asosidagi algoritm
+ - `A` [Eyler yo'li va Eyler sxemasi](src/algorithms/graph/eulerian-path) - Fleury algoritmi - Har bir chekkaga bir marta tashrif buyurish
+ - `A` [Gamilton sikli](src/algorithms/graph/hamiltonian-cycle) - Har bir cho'qqiga bir marta tashrif buyurish
+ - `A` [Kuchli bog'langan komponentlar](src/algorithms/graph/strongly-connected-components) - Kosaraju algoritmi
+ - `A` [Sayohatchi sotuvchi muammosi](src/algorithms/graph/travelling-salesman) - har bir shaharga tashrif buyuradigan va kelib chiqqan shaharga qaytib keladigan eng qisqa yo'l
+- **Kriptografiya**
+ - `B` [Polynomial Hash](src/algorithms/cryptography/polynomial-hash) - polinomga asoslangan hash funktsiyasi
+ - `B` [Rail Fence Cipher](src/algorithms/cryptography/rail-fence-cipher) - xabarlarni kodlash uchun transpozitsiya shifrlash algoritmi
+ - `B` [Caesar Cipher](src/algorithms/cryptography/caesar-cipher) - oddiy almashtirish shifridir
+ - `B` [Hill Cipher](src/algorithms/cryptography/hill-cipher) - chiziqli algebraga asoslangan almashtirish shifri
+- **Machine Learning**
+ - `B` [NanoNeuron](https://github.com/trekhleb/nano-neuron) - Mashinalar aslida qanday o'rganishi mumkinligini ko'rsatadigan 7 ta oddiy JS funksiyasi (forward/backward tarqalish)
+ - `B` [k-NN](src/algorithms/ml/knn) - eng yaqin qo'shnilarni tasniflash algoritmi
+ - `B` [k-Means](src/algorithms/ml/k-means) - k-Means kalsterlash algoritmi
+- **Tasvirga ishlov berish**
+ - `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - kontentga moslashuvchan rasm o'lchamini o'zgartirish algoritmi
+- **Statistikalar**
+ - `B` [Weighted Random](src/algorithms/statistics/weighted-random) - elementlarning og'irligi asosida ro'yxatdan tasodifiy elementni tanlash
+- **Evolyutsion algoritmlar**
+ - `A` [Genetik algoritm](https://github.com/trekhleb/self-parking-car-evolution) - avtoturargohni o'rgatish uchun genetik algoritm qanday qo'llanilishiga misol.
+- **Kategoriyasiz**
+ - `B` [Xanoy minorasi](src/algorithms/uncategorized/hanoi-tower)
+ - `B` [Kvadrat matritsaning aylanishi](src/algorithms/uncategorized/square-matrix-rotation) - joyidagi algoritm
+ - `B` [Sakrash o'yini](src/algorithms/uncategorized/jump-game) - orqaga qaytish, dinamik dasturlash (yuqoridan pastga + pastdan yuqoriga) va ochko'z misollar
+ - `B` [Noyob yo'llar](src/algorithms/uncategorized/unique-paths) - orqaga qaytish, dinamik dasturlash va Paskal uchburchagiga asoslangan misolla
+ - `B` [Yomg'ir teraslari](src/algorithms/uncategorized/rain-terraces) - yomg'ir suvini ushlab turish muammosi (dinamik dasturlash va qo'pol kuch versiyalari)
+ - `B` [Rekursiv zinapoya](src/algorithms/uncategorized/recursive-staircase) - yuqoriga chiqish yo'llari sonini hisoblash (4 ta echim)
+ - `B` [Aksiyalarni sotib olish va sotish uchun eng yaxshi vaqt](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - bo'linib-zabt etish va bir marta o'tish misollari
+ - `A` [N-Queens Muommosi](src/algorithms/uncategorized/n-queens)
+ - `A` [Ritsar sayohati](src/algorithms/uncategorized/knight-tour)
+
+### Paradigma bo'yicha algoritmlar
+
+Algorithmic paradigm - bu algoritmlar sinfini loyihalashtirishga asos bo'lib xizmat qiladigan umumiy usul yoki yondashuv. Bu algoritm tushunchasidan yuqori darajadagi abstraktsiya bo'lib, algoritm kompyuter dasturi tushunchasidan yuqori darajadagi abstraktsiya bo'lgani kabi.
+
+- **Brute Force** - barcha imkoniyatlarni ko'rib chiqib va eng yaxshi echimni tanlash
+ - `B` [Chiziqli qidirish](src/algorithms/search/linear-search)
+ - `B` [Yomg'irli teraslar](src/algorithms/uncategorized/rain-terraces) - yomg'ir suvini to'plash muammosi
+ - `B` [Rekursiv zinapoya](src/algorithms/uncategorized/recursive-staircase) - cho'qqiga chiqish yo'llari sonini hisoblash
+ - `A` [Maksimal kichik massiv](src/algorithms/sets/maximum-subarray)
+ - `A` [Sayohatchi sotuvchi muammosi](src/algorithms/graph/travelling-salesman) - har bir shaharga tashrif buyuradigan va kelib chiqqan shaharga qaytib keladigan eng qisqa yo'l
+ - `A` [Diskret Furye transformatsiyasi](src/algorithms/math/fourier-transform) - vaqt funksiyasini (signalni) uni tashkil etuvchi chastotalarga ajratish
+- **Greedy** - kelajakni o'ylamasdan, hozirgi vaqtda eng yaxshi variantni tanlash
+ - `B` [Sakrash o'yini](src/algorithms/uncategorized/jump-game)
+ - `A` [Bog'lanmagan yukxalta muammosi](src/algorithms/sets/knapsack-problem)
+ - `A` [Dijkstra Algoritmi](src/algorithms/graph/dijkstra) - grafikning bir cho'qqisidan qolgan barcha nuqtalarga eng qisqa yo'llarni topish
+ - `A` [Prim Algoritmi](src/algorithms/graph/prim) - og'irlikdagi yo'naltirilmagan grafik uchun Minimal kengayuvchi daraxtni (MST) topish
+ - `A` [Kruskal Algoritmi](src/algorithms/graph/kruskal) - og'irlikdagi yo'naltirilmagan grafik uchun Minimal kengayuvchi daraxtni (MST) topish
+- **Divide and Conquer** - muammoni kichikroq qismlarga bo'lib va keyin bu qismlarni hal qilish
+
+ - `B` [Ikkilik qidiruv](src/algorithms/search/binary-search)
+ - `B` [Xanoy minorasi](src/algorithms/uncategorized/hanoi-tower)
+ - `B` [Paskal uchburchagi](src/algorithms/math/pascal-triangle)
+ - `B` [Evklid Algoritmi](src/algorithms/math/euclidean-algorithm) - eng katta umumiy bo'luvchini (EKUB) hisoblash
+ - `B` [Birlashtirish tartibi](src/algorithms/sorting/merge-sort)
+ - `B` [Tezkor saralash](src/algorithms/sorting/quick-sort)
+ - `B` [Birinchi-pastga qarab qidirish daraxti](src/algorithms/tree/depth-first-search) (DFS)
+ - `B` [Birinchi-pastga qarab qidirish grafigi](src/algorithms/graph/depth-first-search) (DFS)
+ - `B` [Matritsalar](src/algorithms/math/matrix) - turli shakldagi matritsalarni hosil qilish va kesib o'tish
+ - `B` [Sakrash o'yini](src/algorithms/uncategorized/jump-game)
+ - `B` [Tez ko'tarish](src/algorithms/math/fast-powering)
+ - `B` [Aksiyalarni sotib olish va sotish uchun eng yaxshi vaqt](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - bo'linib-zabt etish va bir marta o'tish misollari
+ - `A` [Permutatsiyalar](src/algorithms/sets/permutations) (takroriyalash bilan va takroriyalashsiz)
+ - `A` [Kombinatsiyalar](src/algorithms/sets/combinations) (takroriyalash bilan va takroriyalashsiz)
+ - `A` [Maksimal kichik massiv](src/algorithms/sets/maximum-subarray)
+
+- **Dinamik dasturlash** - ilgari topilgan kichik yechimlar yordamida yechim yaratish
+ - `B` [Fibonachchi raqam](src/algorithms/math/fibonacci)
+ - `B` [Sakrash o'yini](src/algorithms/uncategorized/jump-game)
+ - `B` [Noyob yo'llar](src/algorithms/uncategorized/unique-paths)
+ - `B` [Yomg'ir teraslari](src/algorithms/uncategorized/rain-terraces) - yomg'ir suvini to'plash muammosi
+ - `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach to the top
+ - `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - kontentga moslashuvchan rasm o'lchamini o'zgartirish algoritmi
+ - `A` [Levenshtein masofasi](src/algorithms/string/levenshtein-distance) - ikki ketma-ketlik o'rtasidagi minimal tahrirlash masofasi
+ - `A` [Eng uzun umumiy ketma-ketlik](src/algorithms/sets/longest-common-subsequence) (LCS)
+ - `A` [Eng uzun umumiy kichik matn](src/algorithms/string/longest-common-substring)
+ - `A` [Eng uzun ortib boruvchi ketma-ketlik](src/algorithms/sets/longest-increasing-subsequence)
+ - `A` [Eng qisqa umumiy ketma-ketlik](src/algorithms/sets/shortest-common-supersequence)
+ - `A` [0/1 Knapsak muommosi](src/algorithms/sets/knapsack-problem)
+ - `A` [Butun sonlarni bo'lish](src/algorithms/math/integer-partition)
+ - `A` [Maksimal kichik massiv](src/algorithms/sets/maximum-subarray)
+ - `A` [Bellman-Ford Algoritmi](src/algorithms/graph/bellman-ford) - grafikning bir cho'qqisidan qolgan barcha nuqtalarga eng qisqa yo'llarni topish
+ - `A` [Floyd-Warshall Algoritmi](src/algorithms/graph/floyd-warshall) -grafikning barcha uchlari orasidagi eng qisqa masofalarni topish
+ - `A` [Regulyar ifoda moslashuvi](src/algorithms/string/regular-expression-matching)
+- **Backtracking** - brute forcega o'xshab, barcha mumkin bo'lgan yechimlarni generatsiya qilishga harakat qiladi, lekin har safar keyingi yechimni yaratganingizda, yechim barcha shartlarga javob beradimi yoki yo'qligini tekshirasiz va shundan keyingina keyingi yechimlarni ishlab chiqarishni davom ettirasiz. Aks holda, orqaga qaytib, yechim topishning boshqa yo'liga o'tasiz. Odatda state-space ning DFS-qidiruvi ishlatiladi.
+ - `B` [Sakrash o'yini](src/algorithms/uncategorized/jump-game)
+ - `B` [Noyob yo'llar](src/algorithms/uncategorized/unique-paths)
+ - `B` [Power Set](src/algorithms/sets/power-set) - to'plamning barcha kichik to'plamlari
+ - `A` [Gamilton sikli](src/algorithms/graph/hamiltonian-cycle) - Har bir cho'qqiga bir marta tashrif buyurish
+ - `A` [N-Queens muommosi](src/algorithms/uncategorized/n-queens)
+ - `A` [Ritsar sayohati](src/algorithms/uncategorized/knight-tour)
+ - `A` [Kombinatsiya yig'indisi](src/algorithms/sets/combination-sum) - ma'lum summani tashkil etuvchi barcha kombinatsiyalarni topish
+- **Branch & Bound** - shu paytgacha topilgan eng arzon echimdan kattaroq xarajatlarga ega qisman echimlarni bekor qilish uchun, backtracking qidiruvining har bir bosqichida topilgan eng arzon echimni eslab qoling va shu paytgacha topilgan eng arzon yechim narxidan muammoni eng kam xarajatli yechim narxining past chegarasi sifatida foydalaning. Odatda state-space daraxtining DFS o'tishi bilan birgalikda BFS traversal qo'llaniladi.
+
+## Ushbu repozitoriyadan qanday foydalanish kerak
+
+**Barcha dependensiylarni o'rnating**
+
+```
+npm install
+```
+
+**ESLint ni ishga tushiring**
+
+Kod sifatini tekshirish uchun ESLint ni ishga tushirishingiz mumkin.
+
+```
+npm run lint
+```
+
+**Barcha testlarni ishga tushuring**
+
+```
+npm test
+```
+
+**Testlarni nom bo'yicha ishga tushirish**
+
+```
+npm test -- 'LinkedList'
+```
+
+**Muammolarni bartaraf qilish (Troubleshooting)**
+
+Agar linting yoki sinov muvaffaqiyatsiz bo'lsa, `node_modules` papkasini o'chirib, npm paketlarini qayta o'rnatishga harakat qiling:
+
+```
+rm -rf ./node_modules
+npm i
+```
+
+Shuningdek, to'g'ri Node versiyasidan foydalanayotganingizga ishonch hosil qiling (`>=16`). Agar Node versiyasini boshqarish uchun [nvm](https://github.com/nvm-sh/nvm) dan foydalanayotgan bo'lsangiz, loyihaning ildiz papkasidan `nvm use` ni ishga tushiring va to'g'ri versiya tanlanadi.
+
+**O'yin maydoni (Playground)**
+
+`./src/playground/playground.js` faylida ma'lumotlar strukturalari va algoritmlar bilan o'ynashingiz, `./src/playground/test/playground.test.js` faylida esa ular uchun testlar yozishingiz mumkin.
+
+Shundan so'ng, playground kodingiz kutilgandek ishlashini tekshirish uchun quyidagi buyruqni ishga tushirishingiz kifoya:
+
+```
+npm test -- 'playground'
+```
+
+## Foydali ma'lumotlar
+
+### Manbalar
+
+- [▶ Data Structures and Algorithms on YouTube](https://www.youtube.com/playlist?list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [✍🏻 Data Structure Sketches](https://okso.app/showcase/data-structures)
+
+### Big O Notation
+
+_Big O notation_ algoritmlarni kirish hajmi oshgani sayin ularning ishlash vaqti yoki bo'sh joy talablari qanday o'sishiga qarab tasniflash uchun ishlatiladi. Quyidagi jadvalda siz Big O notatsiyasida ko'rsatilgan algoritmlarning o'sishining eng keng tarqalgan tartiblarini topishingiz mumkin.
+
+
+
+Manba: [Big O Cheat Sheet](http://bigocheatsheet.com/).
+
+Quyida eng ko'p qo'llaniladigan Big O notatsiyalarining ro'yxati va ularning kirish ma'lumotlarining turli o'lchamlariga nisbatan ishlashini taqqoslash keltirilgan.
+
+| Big O Notatsiya | Turi | 10 ta element uchun hisob-kitoblar | 100 ta element uchun hisob-kitoblar | 1000 ta element uchun hisob-kitoblar |
+| --------------- | ------------ | ---------------------------------- | ----------------------------------- | ------------------------------------ |
+| **O(1)** | O'zgarmas | 1 | 1 | 1 |
+| **O(log N)** | Logarifmik | 3 | 6 | 9 |
+| **O(N)** | Chiziqli | 10 | 100 | 1000 |
+| **O(N log N)** | n log(n) | 30 | 600 | 9000 |
+| **O(N^2)** | Kvadrat | 100 | 10000 | 1000000 |
+| **O(2^N)** | Eksponensial | 1024 | 1.26e+29 | 1.07e+301 |
+| **O(N!)** | Faktorial | 3628800 | 9.3e+157 | 4.02e+2567 |
+
+### Ma'lumotlar tuzilmalarining operatsiyalari murakkabligi
+
+| Ma'lumotlar tuzilmalari | Kirish | Qidirish | Kiritish | O'chirish | Izohlar |
+| --------------------------- | :----: | :------: | :------: | :-------: | :--------------------------------------------------------- |
+| **Massiv** | 1 | n | n | n | |
+| **Stak** | n | n | 1 | 1 | |
+| **Navbat** | n | n | 1 | 1 | |
+| **Bog'langan ro'yhat** | n | n | 1 | n | |
+| **Hash jadval** | - | n | n | n | Mukammal xash funksiyasi bo'lsa, xarajatlar O (1) bo'ladi. |
+| **Ikkilik qidiruv daraxti** | n | n | n | n | Balanslangan daraxt narxida O(log(n)) bo'ladi. |
+| **B-daraxti** | log(n) | log(n) | log(n) | log(n) | |
+| **Qizil-qora daraxt** | log(n) | log(n) | log(n) | log(n) | |
+| **AVL Daraxt** | log(n) | log(n) | log(n) | log(n) | |
+| **Bloom filtri** | - | 1 | 1 | - | Qidiruv paytida noto'g'ri pozitivlar bo'lishi mumkin |
+
+### Massivlarni saralash algoritmlarining murakkabligi
+
+| Nomi | Eng yaxshi | O'rta | Eng yomon | Xotira | Barqaror | Izohlar |
+| ------------------------- | :-----------: | :---------------------: | :-------------------------: | :----: | :------: | :--------------------------------------------------------------------------- |
+| **Pufakcha tartiblash** | n | n2 | n2 | 1 | Ha | |
+| **Kiritish tartibi** | n | n2 | n2 | 1 | Ha | |
+| **Tanlash tartibi** | n2 | n2 | n2 | 1 | Yo'q | |
+| **Heap tartibi** | n log(n) | n log(n) | n log(n) | 1 | Yo'q | |
+| **Birlashtirish tartibi** | n log(n) | n log(n) | n log(n) | n | Ha | |
+| **Tezkor saralash** | n log(n) | n log(n) | n2 | log(n) | Yo'q | Tezkor saralash odatda O(log(n)) stek maydoni bilan joyida amalga oshiriladi |
+| **Shell tartiblash** | n log(n) | depends on gap sequence | n (log(n))2 | 1 | Yo'q | |
+| **Sanash tartibi** | n + r | n + r | n + r | n + r | Ha | r - massivdagi eng katta raqam |
+| **Radiksli tartiblash** | n \* k | n \* k | n \* k | n + k | Ha | k - eng uzun kalitning uzunligi |
+
+## Loyihani qo'llab-quvvatlovchilar
+
+> Siz ushbu loyihani ❤️️ [GitHub](https://github.com/sponsors/trekhleb) yoki ❤️️ [Patreon](https://www.patreon.com/trekhleb) orqali qo'llab-quvvatlashingiz mumkin.
+
+[Ushbu loyihani qo'llab-quvvatlagan odamlar](https://github.com/trekhleb/javascript-algorithms/blob/master/BACKERS.md) `∑ = 1`
+
+## Muallif
+
+[@trekhleb](https://trekhleb.dev)
+
+A few more [projects](https://trekhleb.dev/projects/) and [articles](https://trekhleb.dev/blog/) about JavaScript and algorithms on [trekhleb.dev](https://trekhleb.dev)
diff --git a/README.vi-VN.md b/README.vi-VN.md
index a5cbb72e07..b879955866 100644
--- a/README.vi-VN.md
+++ b/README.vi-VN.md
@@ -25,9 +25,7 @@ _Đọc bằng ngôn ngữ khác:_
[_Bahasa Indonesia_](README.id-ID.md),
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md)
-
-*☝ Dự án này chỉ được sử dụng cho mục đích học tập và nghiên cứu, **không** được dùng
-cho mục đích thương mại.*
+[_עברית_](README.he-IL.md)
## Cấu Trúc Dữ Liệu
@@ -97,19 +95,19 @@ quy tắc xác định chính xác một chuỗi phép toán.
* `A` [Dãy con chung ngắn nhất](src/algorithms/sets/shortest-common-supersequence) (SCS)
* `A` [Bài toán xếp ba lô](src/algorithms/sets/knapsack-problem) - dạng 0-1 và không bị chặn
* `A` [Mảng con lớn nhất](src/algorithms/sets/maximum-subarray) - phiên bản vét cạn và quy hoạch động (Kadane)
- * `A` [Tổ hợp của tổng](src/algorithms/sets/combination-sum) - tìm tất cả các tổ hợp tạo thành tổng cụ thể
+ * `A` [Tổ hợp của tổng](src/algorithms/sets/combination-sum) - tìm tất cả các tổ hợp tạo thành tổng cụ thể
* **Chuỗi**
- * `B` [Khoảng cách Hamming](src/algorithms/string/hamming-distance) - số các vị trí các ký hiệu khác nhau
+ * `B` [Khoảng cách Hamming](src/algorithms/string/hamming-distance) - số các vị trí các ký hiệu khác nhau
* `A` [Khoảng cách Levenshtein](src/algorithms/string/levenshtein-distance) - khoảng cách thay đổi nhỏ nhất giữa hai chuỗi ký tự
- * `A` [Thuật toán Knuth–Morris–Pratt](src/algorithms/string/knuth-morris-pratt) (thuật toán KMP) - tìm chuỗi con (đối sánh mẫu)
+ * `A` [Thuật toán Knuth–Morris–Pratt](src/algorithms/string/knuth-morris-pratt) (thuật toán KMP) - tìm chuỗi con (đối sánh mẫu)
* `A` [Thuật toán Z](src/algorithms/string/z-algorithm) - tìm chuỗi con (đối sánh mẫu)
* `A` [Thuật toán Rabin Karp](src/algorithms/string/rabin-karp) - tìm chuỗi con
* `A` [Xâu con chung dài nhất](src/algorithms/string/longest-common-substring)
* `A` [Phối biểu thức chính quy](src/algorithms/string/regular-expression-matching)
* **Tìm kiếm**
* `B` [Tìm kiếm tuyến tính](src/algorithms/search/linear-search)
- * `B` [Tìm kiếm nhảy](src/algorithms/search/jump-search) (tìm khối) - tìm kiếm trong mảng đã sắp xếp
- * `B` [Tìm kiếm nhị phân](src/algorithms/search/binary-search) - tìm kiếm trong mảng đã sắp xếp
+ * `B` [Tìm kiếm nhảy](src/algorithms/search/jump-search) (tìm khối) - tìm kiếm trong mảng đã sắp xếp
+ * `B` [Tìm kiếm nhị phân](src/algorithms/search/binary-search) - tìm kiếm trong mảng đã sắp xếp
* `B` [Tìm kiếm nội suy ](src/algorithms/search/interpolation-search) - Tìm kiếm strong mảng có thứ tự được phân phối đồng nhất
* **Sắp xếp**
* `B` [Sắp xếp nổi bọt](src/algorithms/sorting/bubble-sort)
@@ -144,12 +142,12 @@ quy tắc xác định chính xác một chuỗi phép toán.
* `A` [Các thành phần kết nối chặt](src/algorithms/graph/strongly-connected-components) - Thuật toán Kosaraju
* `A` [Bài toán người bán hàng](src/algorithms/graph/travelling-salesman) - tuyến đường ngắn nhất có thể đến thăm từng thành phố và trở về thành phố gốc
* **Mật mã học**
- * `B` [Băm đa thức](src/algorithms/cryptography/polynomial-hash) - lăn hàm băm dựa trên đa thức
- * `B` [Mật mã hàng rào đường sắt](src/algorithms/cryptography/rail-fence-cipher) - một thuật toán mật mã chuyển vị để mã hóa thông điệp
+ * `B` [Băm đa thức](src/algorithms/cryptography/polynomial-hash) - lăn hàm băm dựa trên đa thức
+ * `B` [Mật mã hàng rào đường sắt](src/algorithms/cryptography/rail-fence-cipher) - một thuật toán mật mã chuyển vị để mã hóa thông điệp
* `B` [Mật mã Caesar](src/algorithms/cryptography/caesar-cipher) - mật mã chuyển vị đơn giản
* `B` [Mật mã Hill](src/algorithms/cryptography/hill-cipher) - mật mã chuyển vị đơn giản dựa trên đại số tuyến tính
* **Học máy**
- * `B` [NanoNeuron](https://github.com/trekhleb/nano-neuron) - 7 hàm JS đơn giản minh họa cách máy tính thực sự có thể học (truyền thuận / truyền ngược)
+ * `B` [NanoNeuron](https://github.com/trekhleb/nano-neuron) - 7 hàm JS đơn giản minh họa cách máy tính thực sự có thể học (truyền thuận / truyền ngược)
* `B` [k-NN](src/algorithms/ml/knn) - thuật toán phân loại k láng giềng gần nhất
* `B` [k-Means](src/algorithms/ml/k-means) - thuật toán phân cụm k-Means
* **Khác**
@@ -167,22 +165,22 @@ quy tắc xác định chính xác một chuỗi phép toán.
Mẫu hình thuật toán là một phương pháp hoặc cách tiếp cận chung làm cơ sở cho việc thiết kế một
lớp thuật toán. Nó là một sự trừu tượng cao hơn khái niệm về một thuật toán, cũng giống như
-một thuật toán là một sự trừu tượng cao hơn một chương trình máy tính.
+một thuật toán là một sự trừu tượng cao hơn một chương trình máy tính.
-* **Vét cạn** - xem xét tất cả các khả năng và chọn giải pháp tốt nhất
+* **Vét cạn** - xem xét tất cả các khả năng và chọn giải pháp tốt nhất
* `B` [Tìm kiếm tuyến tính](src/algorithms/search/linear-search)
* `B` [Thu thập nước mưa](src/algorithms/uncategorized/rain-terraces) - bài toán bẫy nước mưa
* `B` [Cầu thang đệ quy](src/algorithms/uncategorized/recursive-staircase) - đếm số cách lên đến đỉnh
* `A` [Mảng con lớn nhất](src/algorithms/sets/maximum-subarray)
* `A` [Bài toán người bán hàng](src/algorithms/graph/travelling-salesman) - tuyến đường ngắn nhất có thể đến thăm từng thành phố và trở về thành phố gốc
* `A` [Biến đổi Fourier rời rạc](src/algorithms/math/fourier-transform) - phân giải tín hiệu thời gian thành các tần số tạo nên tín hiệu đó
-* **Tham lam** - chọn phương án tốt nhất vào thời điểm hiện tại mà không cần cân nhắc đến tương lai
+* **Tham lam** - chọn phương án tốt nhất vào thời điểm hiện tại mà không cần cân nhắc đến tương lai
* `B` [Trò chơi nhảy](src/algorithms/uncategorized/jump-game)
* `A` [Bài xếp ba lô không bị chặn](src/algorithms/sets/knapsack-problem)
* `A` [Thuật toán Dijkstra](src/algorithms/graph/dijkstra) - tìm những đường ngắn nhất từ một định tới tất cả các đỉnh
* `A` [Thuật toán Prim](src/algorithms/graph/prim) - tìm cây bao trùm nhỏ nhất (MST) cho đồ thị vô hướng có trọng số
* `A` [Thuật toán Kruskal](src/algorithms/graph/kruskal) - tìm cây bao trùm nhỏ nhất (MST) cho đồ thị vô hướng có trọng số
-* **Chia để trị** - chia vấn đề thành các phần nhỏ hơn rồi giải quyết các phần đó
+* **Chia để trị** - chia vấn đề thành các phần nhỏ hơn rồi giải quyết các phần đó
* `B` [Tìm kiếm nhị phân](src/algorithms/search/binary-search)
* `B` [Tháp Hà Nội](src/algorithms/uncategorized/hanoi-tower)
* `B` [Tam giác Pascal](src/algorithms/math/pascal-triangle)
@@ -191,7 +189,7 @@ một thuật toán là một sự trừu tượng cao hơn một chương trìn
* `B` [Sắp xếp nhanh](src/algorithms/sorting/quick-sort)
* `B` [Cây tìm kiếm theo chiều sâu](src/algorithms/tree/depth-first-search) (DFS)
* `B` [Đồ thị tìm kiếm theo chiều sâu](src/algorithms/graph/depth-first-search) (DFS)
- * `B` [Ma trận](src/algorithms/math/matrix) - tạo và duyệt các ma trận có kích thước khác nhau
+ * `B` [Ma trận](src/algorithms/math/matrix) - tạo và duyệt các ma trận có kích thước khác nhau
* `B` [Trò chơi nhảy](src/algorithms/uncategorized/jump-game)
* `B` [Tính nhanh lũy thừa](src/algorithms/math/fast-powering)
* `B` [Thời điểm tốt nhất để mua bán cổ phiếu](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - ví dụ chia để trị và một đường chuyền
@@ -216,18 +214,18 @@ một thuật toán là một sự trừu tượng cao hơn một chương trìn
* `A` [Phối biểu thức chính quy](src/algorithms/string/regular-expression-matching)
* **Quay lui** - tương tự như vét cạn, cố tạo ra tất cả các giải pháp có thể, nhưng mỗi lần bạn tạo ra giải pháp tiếp theo,
bạn sẽ kiểm tra xem nó có thỏa mãn tất cả các điều kiện hay không và chỉ khi thỏa mãn mới tiếp tục tạo ra các giải pháp tiếp theo.
-Nếu không, hãy quay lại và đi trên một con đường khác để tìm ra giải pháp. Thông thường, truyền DFS của không gian trạng thái được sử dụng.
+Nếu không, hãy quay lại và đi trên một con đường khác để tìm ra giải pháp. Thông thường, truyền DFS của không gian trạng thái được sử dụng.
* `B` [Trò chơi nhảy](src/algorithms/uncategorized/jump-game)
* `B` [Đường đi độc nhất](src/algorithms/uncategorized/unique-paths)
* `B` [Tập lũy thừa](src/algorithms/sets/power-set) - tập hợp chứa tất cả các tập con
* `A` [Chu trình Hamilton](src/algorithms/graph/hamiltonian-cycle) - đi qua các đỉnh một lần duy nhất
* `A` [Bài toán n quân hậu](src/algorithms/uncategorized/n-queens)
* `A` [Mã đi tuần](src/algorithms/uncategorized/knight-tour)
- * `A` [Tổ hợp của tổng](src/algorithms/sets/combination-sum) - tìm tất cả các tổ hợp tạo thành tổng cụ thể
+ * `A` [Tổ hợp của tổng](src/algorithms/sets/combination-sum) - tìm tất cả các tổ hợp tạo thành tổng cụ thể
* **Branch & Bound** - ghi nhớ giải pháp chi với phí thấp nhất được tìm thấy ở mỗi giai đoạn của quá trình tìm kiếm quay lui,
sử dụng chi phí của giải pháp có chi phí thấp nhất được tìm thấy cho đến nay như một giới hạn dưới về chi phí của
-một giải pháp ít chi phí nhân cho bài toán, để loại bỏ các giải pháp từng phần với chi phí lớn hơn giải pháp chi phí thấp nhất được tìm thấy cho đến nay.
-Thông thường BFS duyệt kết hợp với duyệt DFS của cây không gian trạng thái đang được sử dụng.
+một giải pháp ít chi phí nhân cho bài toán, để loại bỏ các giải pháp từng phần với chi phí lớn hơn giải pháp chi phí thấp nhất được tìm thấy cho đến nay.
+Thông thường BFS duyệt kết hợp với duyệt DFS của cây không gian trạng thái đang được sử dụng.
## Hướng dẫn sử dụng repository
@@ -238,7 +236,7 @@ npm install
**Chạy ESLint**
-Bạn có thể muốn chạy nó để kiểm tra chất lượng code.
+Bạn có thể muốn chạy nó để kiểm tra chất lượng code.
```
npm run lint
@@ -259,7 +257,7 @@ npm test -- 'LinkedList'
Bạn có thể chơi với các cấu trúc dữ liệu và thuật toán trong tệp `./src/playground/playground.js`
và viết các bài kiểm thử cho nó ở `./src/playground/__test__/playground.test.js`.
-Sau đó, chỉ cần chạy lệnh sau để kiểm tra xem sân chơi của bạn có hoạt động như mong đợi hay không:
+Sau đó, chỉ cần chạy lệnh sau để kiểm tra xem sân chơi của bạn có hoạt động như mong đợi hay không:
```
npm test -- 'playground'
@@ -274,7 +272,7 @@ npm test -- 'playground'
### Kí hiệu O lớn
*Kí hiệu O lớn* được dùng để phân loại thuật toán theo thời gian chạy hoặc yêu cầu không gian gia tăng khi kích thước đầu vào gia tăng.
-Trên biểu đồ bên dưới, bạn có thể tìm thấy hầu hết các thứ tự tăng trưởng phổ biến của các thuật toán được chỉ định trong ký hiệu O lớn.
+Trên biểu đồ bên dưới, bạn có thể tìm thấy hầu hết các thứ tự tăng trưởng phổ biến của các thuật toán được chỉ định trong ký hiệu O lớn.
diff --git a/README.zh-CN.md b/README.zh-CN.md
index cdef9cabea..f31359eccb 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -23,9 +23,9 @@ _Read this in other languages:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
-
-*注意：这个项目仅用于学习和研究，**不是**用于生产环境。*
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## 数据结构
diff --git a/README.zh-TW.md b/README.zh-TW.md
index 20d4381a2a..aa48b40bd8 100644
--- a/README.zh-TW.md
+++ b/README.zh-TW.md
@@ -22,7 +22,9 @@ _Read this in other languages:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-IL.md)
## 資料結構
diff --git a/src/algorithms/graph/dijkstra/README.de-DE.md b/src/algorithms/graph/dijkstra/README.de-DE.md
new file mode 100644
index 0000000000..59c80546e5
--- /dev/null
+++ b/src/algorithms/graph/dijkstra/README.de-DE.md
@@ -0,0 +1,161 @@
+# Dijkstra-Algorithmus
+
+_Lies dies in anderen Sprachen:_
+[_English_](README.md),
+[_한국어_](README.ko-KR.md),
+[_日本語_](README.ja-JP.md),
+[_简体中文_](README.zh-CN.md),
+[_繁體中文_](README.zh-TW.md),
+[_Українська_](README.uk-UA.md),
+[_Español_](README.es-ES.md),
+[_Français_](README.fr-FR.md),
+[_Deutsch_](README.de-DE.md),
+[_עברית_](README.he-IL.md)
+
+Der Dijkstra-Algorithmus ist ein Algorithmus zur Bestimmung der kürzesten Wege zwischen Knoten in einem Graphen, der beispielsweise Straßennetze darstellen kann.
+
+Der Algorithmus existiert in vielen Varianten; die ursprüngliche Version von Dijkstra fand den kürzesten Weg zwischen zwei Knoten, aber eine gebräuchlichere Variante fixiert einen einzelnen Knoten als „Quellknoten“ und findet die kürzesten Wege von dieser Quelle zu allen anderen Knoten im Graphen. Das Ergebnis ist ein sogenannter „kürzester-Wege-Baum“ (Shortest-Path Tree).
+
+
+
+Der Dijkstra-Algorithmus findet den kürzesten Weg zwischen `a` und `b`.
+Er wählt den unbesuchten Knoten mit der kleinsten aktuellen Entfernung,
+berechnet die Distanzen zu jedem unbesuchten Nachbarn über diesen Knoten
+und aktualisiert die Entfernung des Nachbarn, wenn sie kleiner ist.
+Nachdem alle Nachbarn überprüft wurden, wird der Knoten als besucht markiert (rot dargestellt).
+
+## Praktische Anwendungen des Dijkstra-Algorithmus
+
+- GPS- und Navigationssysteme
+- Optimierung von Routen im öffentlichen Verkehr und im Flugverkehr
+- Internet-Routing (OSPF-, IS-IS-Protokolle)
+- Optimierung von Netzwerkverkehr und Latenzzeiten
+- Pfadsuche in Computerspielen (kürzester Weg auf Karten)
+- Routenoptimierung in Logistik und Lieferketten
+- Planung von Transport- und Versorgungsnetzen
+
+## Schritt-für-Schritt-Beispiel des Dijkstra-Algorithmus
+
+Nehmen wir an, wir haben einen gewichteten Graphen, bei dem jede Kante eine Distanz zwischen Knoten hat.
+Zum Beispiel beträgt die Entfernung zwischen Knoten `A` und `B` `7 Meter` (oder kurz `7m`).
+
+Der Algorithmus verwendet eine [Prioritätswarteschlange](../../../data-structures/priority-queue/),
+um immer den nächsten unbesuchten Knoten mit der kleinsten Entfernung vom Startknoten zu entnehmen.
+
+Der Startknoten hat per Definition eine Entfernung von `0m` zu sich selbst.
+Wir beginnen also mit diesem Knoten – er ist der einzige in der Prioritätswarteschlange zu Beginn.
+
+Die restlichen Knoten werden während der Graphdurchquerung (beim Besuchen der Nachbarn) später hinzugefügt.
+
+
+
+Jeder Nachbar des aus der Warteschlange entnommenen Knotens wird überprüft, um die Entfernung vom Startpunkt zu berechnen.
+Zum Beispiel: Die Entfernung von `A` nach `B` beträgt `0m + 7m = 7m`.
+
+Jedes Mal, wenn wir einen neuen, noch nicht gesehenen Nachbarn besuchen, fügen wir ihn der Prioritätswarteschlange hinzu, wobei die Priorität die Distanz zum Startknoten ist.
+
+Der Knoten `B` wird mit der Priorität 7m in die Warteschlange eingefügt, um später besucht zu werden.
+
+
+
+Als Nächstes besuchen wir den Nachbarn `C` von `A`.
+Die Entfernung vom Startknoten `A` zu `C` beträgt `0m + 9m = 9m`.
+
+Der Knoten `C` wird ebenfalls in die Prioritätswarteschlange eingefügt.
+
+
+
+Dasselbe gilt für den Knoten `F`.
+Die aktuelle Entfernung von `A` zu `F` ist `0m + 14m = 14m`.
+
+`F` wird in die Warteschlange eingefügt, um später besucht zu werden.
+
+
+
+Nachdem alle Nachbarn des aktuellen Knotens überprüft wurden, wird dieser Knoten zur `visited`-Menge hinzugefügt.
+Solche Knoten werden in den nächsten Schritten nicht erneut besucht.
+
+Nun entnehmen wir aus der Prioritätswarteschlange den nächsten Knoten mit der kürzesten Distanz zur Quelle und beginnen, seine Nachbarn zu besuchen.
+
+
+
+Wenn der Knoten, den wir besuchen (in diesem Fall `C`), bereits in der Warteschlange ist,
+bedeutet das, dass die Distanz zu ihm bereits von einem anderen Pfad (`A → C`) berechnet wurde.
+Wenn die aktuelle Distanz (über `A → B → C`) kürzer ist, aktualisieren wir den Wert in der Warteschlange.
+Ist sie länger, bleibt sie unverändert.
+
+Beim Besuch von `C` über `B` (`A → B → C`) beträgt die Distanz `7m + 10m = 17m`.
+Dies ist länger als die bereits gespeicherte Distanz `9m` für `A → C`.
+Daher ignorieren wir diesen längeren Pfad.
+
+
+
+Wir besuchen einen weiteren Nachbarn von `B`, nämlich `D`.
+Die Entfernung zu `D` beträgt `7m + 15m = 22m`.
+Da `D` noch nicht besucht wurde und nicht in der Warteschlange ist, fügen wir ihn mit der Priorität `22m` hinzu.
+
+
+
+An diesem Punkt wurden alle Nachbarn von `B` besucht, daher wird `B` zur `visited`-Menge hinzugefügt.
+Als Nächstes entnehmen wir aus der Warteschlange den Knoten, der dem Ursprung am nächsten ist.
+
+
+
+Wir besuchen die unbesuchten Nachbarn von `C`.
+Die Distanz zu `F` über `C` (`A → C → F`) beträgt `9m + 2m = 11m`.
+Dies ist kürzer als der bisher gespeicherte Weg `A → F` von `14m`.
+In diesem Fall aktualisieren wir die Distanz zu `F` auf `11m` und passen ihre Priorität in der Warteschlange an.
+Wir haben einen kürzeren Weg zu `F` gefunden.
+
+
+
+Dasselbe gilt für `D`.
+Wir haben einen kürzeren Pfad zu `D` gefunden – der Weg `A → C → D` ist kürzer als `A → B → D`.
+Die Distanz wird von `22m` auf `20m` aktualisiert.
+
+
+
+Alle Nachbarn von `C` wurden besucht, daher fügen wir `C` zur `visited`-Menge hinzu.
+Wir entnehmen den nächsten Knoten aus der Warteschlange, der `F` ist.
+
+
+
+Wir notieren die Distanz zu `E` als `11m + 9m = 20m`.
+
+
+
+Wir fügen `F` zur `visited`-Menge hinzu und entnehmen den nächsten Knoten `D`.
+
+
+
+Die Distanz zu `E` über `D` ist `20m + 6m = 26m`.
+Das ist länger als die bereits berechnete Distanz von `20m` über `F`.
+Daher verwerfen wir diesen längeren Weg.
+
+
+
+Der Knoten `D` ist jetzt besucht.
+
+
+
+Auch der Knoten `E` wurde besucht.
+Die Durchquerung des Graphen ist abgeschlossen.
+
+
+
+Nun kennen wir die kürzesten Distanzen von jedem Knoten ausgehend vom Startknoten `A`.
+
+In der Praxis speichert man während der Berechnungen zusätzlich die `previousVertices` (vorherige Knoten),
+um die genaue Reihenfolge der Knoten im kürzesten Pfad rekonstruieren zu können.
+
+Zum Beispiel ist der kürzeste Pfad von `A` nach `E`: `A → C → F → E`.
+
+## Beispielimplementierung
+
+- [dijkstra.js](./dijkstra.js)
+
+## Quellen
+
+- [Wikipedia](https://de.wikipedia.org/wiki/Dijkstra-Algorithmus)
+- [YouTube – Nathaniel Fan](https://www.youtube.com/watch?v=gdmfOwyQlcI&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [YouTube – Tushar Roy](https://www.youtube.com/watch?v=lAXZGERcDf4&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
diff --git a/src/algorithms/graph/dijkstra/README.es-ES.md b/src/algorithms/graph/dijkstra/README.es-ES.md
new file mode 100644
index 0000000000..06261ca280
--- /dev/null
+++ b/src/algorithms/graph/dijkstra/README.es-ES.md
@@ -0,0 +1,150 @@
+# Algoritmo de Dijkstra
+
+_Lee esto en otros idiomas:_
+[_English_](README.md),
+[_한국어_](README.ko-KR.md),
+[_日本語_](README.ja-JP.md),
+[_简体中文_](README.zh-CN.md),
+[_繁體中文_](README.zh-TW.md),
+[_Українська_](README.uk-UA.md),
+[_Español_](README.es-ES.md),
+[_Français_](README.fr-FR.md),
+[_Deutsch_](README.de-DE.md),
+[_עברית_](README.he-IL.md)
+
+El algoritmo de Dijkstra es un algoritmo para encontrar los caminos más cortos entre nodos en un grafo, que puede representar, por ejemplo, redes de carreteras.
+
+El algoritmo existe en muchas variantes; la versión original de Dijkstra encontraba el camino más corto entre dos nodos, pero una variante más común fija un solo nodo como el "nodo fuente" y encuentra los caminos más cortos desde la fuente hacia todos los demás nodos del grafo, produciendo un árbol de caminos más cortos.
+
+
+
+El algoritmo de Dijkstra busca el camino más corto entre `a` y `b`.
+Selecciona el vértice no visitado con la menor distancia, calcula la distancia a través de él hacia cada vecino no visitado, y actualiza la distancia del vecino si es menor. Marca el vértice como visitado (en rojo) cuando se han procesado todos sus vecinos.
+
+## Aplicaciones prácticas del algoritmo de Dijkstra
+
+- Sistemas GPS / navegación
+- Optimización de rutas de transporte público y aerolíneas
+- Enrutamiento de Internet (protocolos OSPF, IS-IS)
+- Optimización del tráfico y la latencia en redes
+- Búsqueda de caminos en videojuegos (camino más corto en mapas)
+- Optimización de rutas de logística y entrega
+- Diseño de redes de transporte y cadenas de suministro
+
+## Ejemplo paso a paso del algoritmo de Dijkstra
+
+Supongamos que tenemos un grafo ponderado de nodos, donde cada arista tiene un valor de distancia entre los nodos. Por ejemplo, la distancia entre el nodo `A` y el nodo `B` es de `7 metros` (o simplemente `7m` para abreviar).
+
+El algoritmo utiliza una [cola de prioridad](../../../data-structures/priority-queue/) para obtener siempre el siguiente vértice no visitado con la menor distancia desde el nodo de origen.
+
+El nodo inicial, por definición, tiene una distancia de `0m` desde sí mismo. Así que comenzamos con él — el único nodo en la cola de prioridad al inicio.
+
+El resto de los nodos se agregará a la cola de prioridad más tarde, durante la exploración del grafo (al visitar los vecinos).
+
+
+
+Cada vecino del nodo extraído de la cola se recorre para calcular la distancia desde el origen.
+Por ejemplo, la distancia de `A` a `B` es `0m + 7m = 7m`.
+
+Cada vez que visitamos un vecino aún no visto, lo agregamos a la cola de prioridad, donde la prioridad es la distancia al nodo vecino desde el origen.
+
+El nodo `B` se agrega a la cola de prioridad mínima para ser recorrido más adelante.
+
+
+
+Visitamos el siguiente vecino `C` del nodo `A`.
+La distancia desde el nodo de origen `A` hasta `C` es `0m + 9m = 9m`.
+
+El nodo `C` se agrega a la cola de prioridad mínima para recorrerlo más tarde.
+
+
+
+Lo mismo ocurre con el nodo `F`.
+La distancia actual de `A` a `F` es `0m + 14m = 14m`.
+
+El nodo `F` se agrega a la cola de prioridad mínima para ser recorrido más adelante.
+
+
+
+Una vez que se han revisado todos los vecinos del nodo actual, este se agrega al conjunto `visited`. No queremos volver a visitar estos nodos más adelante.
+
+Ahora extraemos de la cola el siguiente nodo más cercano al origen (el de menor distancia) y comenzamos a visitar sus vecinos.
+
+
+
+Si el nodo que estamos visitando (en este caso, `C`) ya está en la cola, significa que ya habíamos calculado la distancia hacia él, pero desde otro camino (`A → C`).
+Si la distancia actual (desde el camino `A → B → C`) es menor que la calculada antes, actualizamos la distancia (en la cola de prioridad) con la más corta, ya que buscamos los caminos más cortos.
+Si la distancia es mayor, la dejamos como está.
+
+Al visitar el nodo `C` a través de `B` (camino `A → B → C`), vemos que la distancia sería `7m + 10m = 17m`.
+Esto es más largo que la distancia ya registrada de `9m` para el camino `A → C`. En estos casos, simplemente ignoramos la distancia más larga.
+
+
+
+Visitamos otro vecino de `B`, que es `D`.
+La distancia hacia `D` es `7m + 15m = 22m`.
+Como aún no hemos visitado `D` y no está en la cola de prioridad, la agregamos con una prioridad (distancia) de `22m`.
+
+
+
+En este punto, todos los vecinos de `B` han sido recorridos, así que agregamos `B` al conjunto `visited`.
+Luego extraemos el nodo más cercano al origen desde la cola de prioridad.
+
+
+
+Recorremos los vecinos no visitados del nodo `C`.
+La distancia hacia `F` a través de `C` (camino `A → C → F`) es `9m + 2m = 11m`.
+Esto es más corto que el camino anterior `A → F` de `14m`.
+En este caso, actualizamos la distancia de `F` a `11m` y su prioridad en la cola. Hemos encontrado un camino más corto hacia `F`.
+
+
+
+Lo mismo ocurre con `D`.
+Hemos encontrado un camino más corto hacia `D`, donde `A → C → D` es más corto que `A → B → D`.
+Actualizamos la distancia de `22m` a `20m`.
+
+
+
+Todos los vecinos de `C` han sido recorridos, así que podemos agregar `C` al conjunto `visited`.
+Extraemos de la cola el siguiente nodo más cercano, que es `F`.
+
+
+
+Registramos la distancia hacia `E` como `11m + 9m = 20m`.
+
+
+
+Agregamos el nodo `F` al conjunto `visited` y extraemos el siguiente nodo más cercano, `D`.
+
+
+
+La distancia hacia `E` a través de `D` es `20m + 6m = 26m`.
+Esto es más largo que la distancia ya calculada hacia `E` desde `F`, que es `20m`.
+Podemos descartar la distancia más larga.
+
+
+
+El nodo `D` ahora está visitado.
+
+
+
+El nodo `E` también ha sido visitado.
+Hemos terminado de recorrer el grafo.
+
+
+
+Ahora conocemos las distancias más cortas desde el nodo inicial `A` hacia cada nodo.
+
+En la práctica, durante el cálculo de distancias también registramos los `previousVertices` (vértices anteriores) para poder mostrar la secuencia exacta de nodos que forman el camino más corto.
+
+Por ejemplo, el camino más corto de `A` a `E` es `A → C → F → E`.
+
+## Ejemplo de implementación
+
+- [dijkstra.js](./dijkstra.js)
+
+## Referencias
+
+- [Wikipedia](https://es.wikipedia.org/wiki/Algoritmo_de_Dijkstra)
+- [YouTube - Nathaniel Fan](https://www.youtube.com/watch?v=gdmfOwyQlcI&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [YouTube - Tushar Roy](https://www.youtube.com/watch?v=lAXZGERcDf4&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
diff --git a/src/algorithms/graph/dijkstra/README.fr-FR.md b/src/algorithms/graph/dijkstra/README.fr-FR.md
new file mode 100644
index 0000000000..45808e3afb
--- /dev/null
+++ b/src/algorithms/graph/dijkstra/README.fr-FR.md
@@ -0,0 +1,156 @@
+# Algorithme de Dijkstra
+
+_Lire ceci dans d’autres langues :_
+[_English_](README.md),
+[_한국어_](README.ko-KR.md),
+[_日本語_](README.ja-JP.md),
+[_简体中文_](README.zh-CN.md),
+[_繁體中文_](README.zh-TW.md),
+[_Українська_](README.uk-UA.md),
+[_Español_](README.es-ES.md),
+[_Français_](README.fr-FR.md),
+[_Deutsch_](README.de-DE.md),
+[_עברית_](README.he-IL.md)
+
+L’algorithme de Dijkstra est un algorithme permettant de trouver les plus courts chemins entre des nœuds dans un graphe, pouvant représenter, par exemple, un réseau routier.
+
+Il existe plusieurs variantes de cet algorithme. La version originale de Dijkstra trouvait le plus court chemin entre deux nœuds, mais la version la plus courante fixe un seul nœud comme « nœud source » et calcule les plus courts chemins de cette source vers tous les autres nœuds du graphe, produisant ainsi un arbre des plus courts chemins.
+
+
+
+L’algorithme de Dijkstra trouve le plus court chemin entre `a` et `b`.
+Il sélectionne le sommet non visité avec la plus petite distance, calcule la distance à travers ce sommet vers chacun de ses voisins non visités, et met à jour la distance du voisin si celle-ci est plus courte.
+Le sommet est ensuite marqué comme visité (en rouge) lorsque tous ses voisins ont été traités.
+
+## Applications pratiques de l’algorithme de Dijkstra
+
+- Systèmes GPS / navigation
+- Optimisation des itinéraires de transport public et d’avions
+- Routage Internet (protocoles OSPF, IS-IS)
+- Optimisation du trafic et de la latence réseau
+- Recherche de chemin dans les jeux vidéo (chemin le plus court sur une carte)
+- Optimisation des itinéraires de livraison et de logistique
+- Conception de réseaux de transport et de chaînes d’approvisionnement
+
+## Exemple pas à pas de l’algorithme de Dijkstra
+
+Supposons que nous ayons un graphe pondéré de nœuds, où chaque arête possède une distance entre deux nœuds.
+Par exemple, la distance entre le nœud `A` et le nœud `B` est de `7 mètres` (ou simplement `7m`).
+
+L’algorithme utilise une [file de priorité](../../../data-structures/priority-queue/) pour toujours extraire le prochain sommet non visité ayant la plus petite distance depuis le nœud d’origine.
+
+Le nœud de départ, par définition, a une distance de `0m` depuis lui-même.
+Nous commençons donc avec ce nœud, le seul présent dans la file de priorité au départ.
+
+Les autres nœuds seront ajoutés à la file de priorité plus tard, pendant la traversée du graphe (en visitant les voisins).
+
+
+
+Chaque voisin du nœud extrait de la file est parcouru afin de calculer la distance à partir du nœud d’origine.
+Par exemple, la distance de `A` à `B` est `0m + 7m = 7m`.
+
+Chaque fois qu’un voisin encore non visité est découvert, il est ajouté à la file de priorité, la priorité correspondant à la distance depuis le nœud d’origine.
+
+Le nœud `B` est ajouté à la file de priorité minimale pour être traité plus tard.
+
+
+
+Nous visitons le voisin suivant, `C`, du nœud `A`.
+La distance depuis le nœud d’origine `A` vers `C` est `0m + 9m = 9m`.
+
+Le nœud `C` est ajouté à la file de priorité minimale pour être parcouru ultérieurement.
+
+
+
+Même chose pour le nœud `F`.
+La distance actuelle de `A` à `F` est `0m + 14m = 14m`.
+
+Le nœud `F` est ajouté à la file de priorité minimale pour être visité plus tard.
+
+
+
+Une fois que tous les voisins du nœud actuel ont été examinés, ce nœud est ajouté à l’ensemble `visited`.
+Nous ne souhaitons plus revisiter ces nœuds lors des prochaines itérations.
+
+Nous extrayons maintenant de la file le nœud le plus proche de la source (celui ayant la plus courte distance) et commençons à visiter ses voisins.
+
+
+
+Si le nœud que nous visitons (dans ce cas, `C`) est déjà présent dans la file, cela signifie que sa distance a déjà été calculée via un autre chemin (`A → C`).
+Si la nouvelle distance (depuis le chemin `A → B → C`) est plus courte, nous mettons à jour la distance dans la file de priorité.
+Si elle est plus longue, nous la laissons telle quelle.
+
+En visitant le nœud `C` via `B` (chemin `A → B → C`), nous trouvons que la distance est `7m + 10m = 17m`.
+Ceci est plus long que la distance enregistrée de `9m` pour le chemin `A → C`.
+Dans ce cas, nous ignorons simplement cette distance plus longue.
+
+
+
+Nous visitons un autre voisin de `B`, à savoir `D`.
+La distance vers `D` est `7m + 15m = 22m`.
+Comme `D` n’a pas encore été visité et n’est pas dans la file, nous l’ajoutons avec une priorité (distance) de `22m`.
+
+
+
+À ce stade, tous les voisins de `B` ont été parcourus, donc nous ajoutons `B` à l’ensemble `visited`.
+Ensuite, nous extrayons de la file le nœud le plus proche du nœud d’origine.
+
+
+
+Nous parcourons les voisins non visités du nœud `C`.
+La distance vers `F` via `C` (chemin `A → C → F`) est `9m + 2m = 11m`.
+C’est plus court que la distance précédemment enregistrée de `14m` pour le chemin `A → F`.
+Nous mettons donc à jour la distance de `F` à `11m` et ajustons sa priorité dans la file.
+Nous venons de trouver un chemin plus court vers `F`.
+
+
+
+Même chose pour `D`.
+Nous avons trouvé un chemin plus court vers `D` : `A → C → D` est plus court que `A → B → D`.
+Nous mettons à jour la distance de `22m` à `20m`.
+
+
+
+Tous les voisins de `C` ont été parcourus, donc nous pouvons ajouter `C` à l’ensemble `visited`.
+Nous extrayons maintenant de la file le prochain nœud le plus proche, `F`.
+
+
+
+Nous enregistrons la distance vers `E` comme `11m + 9m = 20m`.
+
+
+
+Nous ajoutons `F` à l’ensemble `visited` et extrayons ensuite `D`, le prochain nœud le plus proche.
+
+
+
+La distance vers `E` via `D` est `20m + 6m = 26m`.
+C’est plus long que la distance déjà calculée depuis `F` (`20m`).
+Nous pouvons donc ignorer cette distance plus longue.
+
+
+
+Le nœud `D` est maintenant visité.
+
+
+
+Le nœud `E` est maintenant visité également.
+La traversée du graphe est terminée.
+
+
+
+Nous connaissons maintenant les distances les plus courtes vers chaque nœud depuis le nœud de départ `A`.
+
+En pratique, pendant le calcul des distances, on enregistre également les `previousVertices` (nœuds précédents) pour pouvoir reconstruire la séquence exacte des nœuds qui forment le chemin le plus court.
+
+Par exemple, le chemin le plus court de `A` à `E` est `A → C → F → E`.
+
+## Exemple d’implémentation
+
+- [dijkstra.js](./dijkstra.js)
+
+## Références
+
+- [Wikipédia](https://fr.wikipedia.org/wiki/Algorithme_de_Dijkstra)
+- [YouTube - Nathaniel Fan](https://www.youtube.com/watch?v=gdmfOwyQlcI&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [YouTube - Tushar Roy](https://www.youtube.com/watch?v=lAXZGERcDf4&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
diff --git a/src/algorithms/graph/dijkstra/README.he-IL.md b/src/algorithms/graph/dijkstra/README.he-IL.md
new file mode 100644
index 0000000000..0ff1942f98
--- /dev/null
+++ b/src/algorithms/graph/dijkstra/README.he-IL.md
@@ -0,0 +1,160 @@
+# אלגוריתם דייקסטרה (Dijkstra's Algorithm)
+
+_קרא בשפות אחרות:_
+[_English_](README.md),
+[_한국어_](README.ko-KR.md),
+[_日本語_](README.ja-JP.md),
+[_简体中文_](README.zh-CN.md),
+[_繁體中文_](README.zh-TW.md),
+[_Українська_](README.uk-UA.md),
+[_Español_](README.es-ES.md),
+[_Français_](README.fr-FR.md),
+[_Deutsch_](README.de-DE.md),
+[_עברית_](README.he-IL.md)
+
+אלגוריתם דייקסטרה הוא אלגוריתם למציאת המסלולים הקצרים ביותר בין צמתים בגרף, שיכול לייצג למשל רשת כבישים.
+
+לאלגוריתם יש מספר גרסאות; הגרסה המקורית של דייקסטרה מצאה את המסלול הקצר ביותר בין שני צמתים, אך גרסה נפוצה יותר קובעת צומת אחד כ"צומת מקור" ומוצאת את המסלולים הקצרים ביותר ממנו לכל שאר הצמתים בגרף, וכך נוצרת עץ מסלולים קצרים (Shortest-Path Tree).
+
+
+
+אלגוריתם דייקסטרה למציאת המסלול הקצר ביותר בין `a` ל־`b`.
+הוא בוחר את הצומת שלא ביקרו בו שעד כה יש לו את המרחק הקטן ביותר,
+מחשב את המרחק דרכו לכל שכן שלא ביקרו בו,
+ומעדכן את המרחק אם נמצא מסלול קצר יותר.
+כאשר מסיימים לבדוק את כל השכנים, מסמנים את הצומת כ"ביקור הושלם" (אדום).
+
+## שימושים מעשיים של אלגוריתם דייקסטרה
+
+- מערכות GPS / ניווט
+- אופטימיזציה של מסלולי תחבורה ציבורית וטיסות
+- ניתוב באינטרנט (פרוטוקולים OSPF, IS-IS)
+- אופטימיזציה של תעבורת רשת וזמני השהיה
+- חיפוש מסלולים במשחקים (המסלול הקצר ביותר במפה)
+- אופטימיזציה של מסלולי משלוחים ולוגיסטיקה
+- תכנון רשתות תחבורה ושרשראות אספקה
+
+## דוגמה שלב-אחר-שלב לאלגוריתם דייקסטרה
+
+נניח שיש לנו גרף משוקלל של צמתים, שבו לכל קשת יש ערך מרחק בין צמתים.
+לדוגמה, המרחק בין הצומת `A` לצומת `B` הוא `7 מטרים` (או בקיצור `7m`).
+
+האלגוריתם משתמש ב[תור עדיפויות](../../../data-structures/priority-queue/) כדי תמיד לבחור את הצומת שלא ביקרו בו עם המרחק הקטן ביותר מהצומת ההתחלתי.
+
+צומת ההתחלה, על פי ההגדרה, נמצא במרחק `0m` מעצמו.
+לכן מתחילים ממנו — הצומת היחיד בתור העדיפויות בתחילת התהליך.
+
+שאר הצמתים יתווספו לתור במהלך המעבר בגרף (בעת ביקור בשכנים).
+
+
+
+כל שכן של הצומת שנשלף מהתור נבדק כדי לחשב את המרחק אליו מהמקור.
+לדוגמה, המרחק מ־`A` ל־`B` הוא `0m + 7m = 7m`.
+
+בכל פעם שמבקרים שכן חדש שטרם נבדק, מוסיפים אותו לתור העדיפויות,
+כאשר העדיפות נקבעת לפי המרחק מהמקור.
+
+הצומת `B` נוסף לתור העדיפויות המינימלי כדי לעבור עליו מאוחר יותר.
+
+
+
+מבקרים את השכן הבא של `A`, שהוא `C`.
+המרחק מ־`A` ל־`C` הוא `0m + 9m = 9m`.
+
+הצומת `C` נוסף גם הוא לתור העדיפויות.
+
+
+
+כנ"ל לגבי הצומת `F`.
+המרחק הנוכחי מ־`A` ל־`F` הוא `0m + 14m = 14m`.
+
+`F` נוסף לתור כדי לעבור עליו בהמשך.
+
+
+
+לאחר שכל השכנים של הצומת הנוכחי נבדקו, מוסיפים אותו לקבוצת `visited`.
+אין צורך לבקר בו שוב.
+
+כעת נשלוף מהתור את הצומת הקרוב ביותר למקור (בעל המרחק הקצר ביותר)
+ונתחיל לבקר את שכניו.
+
+
+
+אם הצומת שבו אנו מבקרים (למשל `C`) כבר נמצא בתור,
+המשמעות היא שכבר חישבנו את המרחק אליו, אבל ממסלול אחר (`A → C`).
+אם המרחק הנוכחי (דרך המסלול `A → B → C`) קצר יותר, נעדכן אותו;
+אם ארוך יותר — נשאיר אותו כפי שהוא.
+
+לדוגמה, בעת ביקור ב־`C` דרך `B` (`A → B → C`), המרחק הוא `7m + 10m = 17m`.
+זה ארוך יותר מהמרחק שכבר נרשם (`9m`), ולכן אין עדכון.
+
+
+
+מבקרים שכן נוסף של `B`, שהוא `D`.
+המרחק ל־`D` הוא `7m + 15m = 22m`.
+מכיוון שטרם ביקרנו ב־`D` והוא אינו בתור, נוסיף אותו עם עדיפות (מרחק) של `22m`.
+
+
+
+בשלב זה כל שכניו של `B` נבדקו, ולכן נוסיף את `B` לקבוצת `visited`.
+לאחר מכן נשלוף את הצומת הקרוב ביותר למקור מהתור.
+
+
+
+מבקרים את השכנים הלא-מבוקרים של `C`.
+המרחק ל־`F` דרך `C` (המסלול `A → C → F`) הוא `9m + 2m = 11m`.
+זה קצר יותר מהמרחק שנרשם קודם (`14m` ל־`A → F`).
+לכן נעדכן את המרחק של `F` ל־`11m` ואת העדיפות שלו בתור.
+מצאנו מסלול קצר יותר ל־`F`.
+
+
+
+אותו הדבר עבור `D`.
+מצאנו מסלול קצר יותר — `A → C → D` קצר מ־`A → B → D`.
+נעדכן את המרחק מ־`22m` ל־`20m`.
+
+
+
+כל שכניו של `C` נבדקו, ולכן נוסיף את `C` ל־`visited`.
+נשלוף מהתור את הצומת הקרוב ביותר הבא — `F`.
+
+
+
+נרשום את המרחק ל־`E` כ־`11m + 9m = 20m`.
+
+
+
+נוסיף את `F` לקבוצת `visited`, ונשלוף את הצומת הקרוב הבא — `D`.
+
+
+
+המרחק ל־`E` דרך `D` הוא `20m + 6m = 26m`.
+זה ארוך יותר מהמרחק שכבר חושב (`20m` דרך `F`), ולכן נתעלם ממנו.
+
+
+
+הצומת `D` כעת סומן כ"ביקור הושלם".
+
+
+
+הצומת `E` גם סומן כ"ביקור הושלם".
+סיימנו את המעבר בגרף.
+
+
+
+כעת אנו יודעים את המרחקים הקצרים ביותר מכל צומת לנקודת ההתחלה `A`.
+
+בפועל, במהלך חישוב המרחקים שומרים גם את ה־`previousVertices` (הצמתים הקודמים)
+כדי שנוכל לשחזר את הרצף המדויק של הצמתים שמרכיבים את המסלול הקצר ביותר.
+
+לדוגמה, המסלול הקצר מ־`A` ל־`E` הוא `A → C → F → E`.
+
+## דוגמת מימוש
+
+- [dijkstra.js](./dijkstra.js)
+
+## מקורות
+
+- [ויקיפדיה](https://he.wikipedia.org/wiki/אלגוריתם_דייקסטרה)
+- [YouTube – Nathaniel Fan](https://www.youtube.com/watch?v=gdmfOwyQlcI&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [YouTube – Tushar Roy](https://www.youtube.com/watch?v=lAXZGERcDf4&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
diff --git a/src/algorithms/graph/dijkstra/README.ja-JP.md b/src/algorithms/graph/dijkstra/README.ja-JP.md
new file mode 100644
index 0000000000..648460c906
--- /dev/null
+++ b/src/algorithms/graph/dijkstra/README.ja-JP.md
@@ -0,0 +1,165 @@
+# ダイクストラ法 (Dijkstra's Algorithm)
+
+_他の言語で読む:_
+[_English_](README.md),
+[_한국어_](README.ko-KR.md),
+[_日本語_](README.ja-JP.md),
+[_简体中文_](README.zh-CN.md),
+[_繁體中文_](README.zh-TW.md),
+[_Українська_](README.uk-UA.md),
+[_Español_](README.es-ES.md),
+[_Français_](README.fr-FR.md),
+[_Deutsch_](README.de-DE.md),
+[_עברית_](README.he-IL.md)
+
+ダイクストラ法は、グラフ内のノード間の最短経路を見つけるためのアルゴリズムです。
+例えば道路網などを表すことができます。
+
+このアルゴリズムにはいくつかのバリエーションがあります。
+ダイクストラの元々の手法は、2つのノード間の最短経路を求めるものでしたが、
+より一般的なバージョンでは、1つのノードを「始点（ソース）」として固定し、
+その始点から他のすべてのノードまでの最短経路を求め、最短経路木（shortest-path tree）を生成します。
+
+
+
+`a` から `b` への最短経路を見つけるダイクストラ法。
+訪問していないノードの中で最も距離の短いノードを選び、
+そのノードを経由して未訪問の隣接ノードへの距離を計算し、
+もし短ければその距離を更新します。
+すべての隣接ノードを処理したら、そのノードを訪問済み（赤色）としてマークします。
+
+## ダイクストラ法の実用例
+
+- GPS / ナビゲーションシステム
+- 公共交通機関や航空路線の最適化
+- インターネットルーティング（OSPF、IS-IS プロトコル）
+- ネットワークトラフィックとレイテンシーの最適化
+- ゲームにおける経路探索（マップ上の最短経路）
+- 物流および配送ルートの最適化
+- サプライチェーンや交通ネットワーク設計
+
+## ダイクストラ法のステップごとの例
+
+重み付きグラフがあり、各辺にはノード間の距離が設定されています。
+たとえば、ノード `A` とノード `B` の距離が `7m` であるとします。
+
+このアルゴリズムは、[優先度付きキュー](../../../data-structures/priority-queue/)を使用し、
+常に始点から最も近い未訪問ノードを取り出します。
+
+始点ノードは自分自身からの距離が `0m` なので、
+最初にキューに入っているのはこのノードだけです。
+
+他のノードは、グラフ探索中（隣接ノードを訪問する際）に後でキューに追加されます。
+
+
+
+キューから取り出したノードの各隣接ノードについて、始点からの距離を計算します。
+たとえば、`A` から `B` までの距離は `0m + 7m = 7m` です。
+
+初めて訪れる隣接ノードは、始点からの距離を優先度としてキューに追加されます。
+
+ノード `B` は、後で探索するために最小優先度キューに追加されます。
+
+
+
+次に、ノード `A` のもう一つの隣接ノード `C` を訪問します。
+始点 `A` から `C` までの距離は `0m + 9m = 9m` です。
+
+ノード `C` も最小優先度キューに追加されます。
+
+
+
+同様に、ノード `F` の場合、始点 `A` からの距離は `0m + 14m = 14m` です。
+
+ノード `F` も後で探索するためにキューに追加します。
+
+
+
+現在のノードのすべての隣接ノードを確認した後、
+そのノードを `visited` セットに追加します。
+このノードは今後再訪しません。
+
+次に、始点から最も近いノードをキューから取り出し、
+その隣接ノードを訪問します。
+
+
+
+訪問中のノード（この場合は `C`）がすでにキューに存在する場合、
+それは別の経路（`A → C`）からすでに距離を計算したことを意味します。
+もし今回の経路（`A → B → C`）を通る距離が短ければ更新し、
+長ければそのままにします。
+
+たとえば、`B` 経由で `C` に行くと (`A → B → C`)、距離は `7m + 10m = 17m` です。
+これは既に記録されている距離 `9m` より長いので、更新しません。
+
+
+
+次に、`B` のもう一つの隣接ノード `D` を訪問します。
+距離は `7m + 15m = 22m` です。
+`D` はまだ訪問されておらず、キューにもないため、
+距離 `22m` の優先度でキューに追加します。
+
+
+
+この時点で `B` のすべての隣接ノードを訪問したので、`B` を `visited` に追加します。
+次に、始点に最も近いノードをキューから取り出します。
+
+
+
+ノード `C` の未訪問の隣接ノードを探索します。
+経路 `A → C → F` を通る `F` までの距離は `9m + 2m = 11m` です。
+これは以前の `A → F` の距離 `14m` より短いので、
+`F` の距離を `11m` に更新し、キューの優先度を変更します。
+これでより短い経路が見つかりました。
+
+
+
+`D` についても同様です。
+経路 `A → C → D` は `A → B → D` より短いため、
+距離を `22m` から `20m` に更新します。
+
+
+
+`C` のすべての隣接ノードを訪問したので、`C` を `visited` に追加し、
+次に最も近いノード `F` をキューから取り出します。
+
+
+
+`E` への距離を `11m + 9m = 20m` として記録します。
+
+
+
+`F` を `visited` に追加し、次に最も近い `D` を取り出します。
+
+
+
+`D` 経由で `E` に行く距離は `20m + 6m = 26m` です。
+これはすでに `F` 経由の距離 `20m` より長いため、無視します。
+
+
+
+ノード `D` が訪問されました。
+
+
+
+ノード `E` も訪問されました。
+グラフ探索が完了しました。
+
+
+
+これで、始点ノード `A` から各ノードへの最短距離がわかりました。
+
+実際には、距離計算の際に各ノードの `previousVertices`（直前のノード）も記録し、
+最短経路の正確な経路を再構築できるようにします。
+
+例えば、`A` から `E` への最短経路は `A → C → F → E` です。
+
+## 実装例
+
+- [dijkstra.js](./dijkstra.js)
+
+## 参考文献
+
+- [ウィキペディア](https://ja.wikipedia.org/wiki/ダイクストラ法)
+- [YouTube - Nathaniel Fan](https://www.youtube.com/watch?v=gdmfOwyQlcI&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [YouTube - Tushar Roy](https://www.youtube.com/watch?v=lAXZGERcDf4&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
diff --git a/src/algorithms/graph/dijkstra/README.ko-KR.md b/src/algorithms/graph/dijkstra/README.ko-KR.md
index e2595bbe23..1fca16981a 100644
--- a/src/algorithms/graph/dijkstra/README.ko-KR.md
+++ b/src/algorithms/graph/dijkstra/README.ko-KR.md
@@ -1,16 +1,154 @@
-# 다익스트라 알고리즘(Dijkstra's algorithm)
+# 다익스트라 알고리즘 (Dijkstra's Algorithm)
-다익스트라 알고리즘은 도로 네트워크 등을 나타낼 수 있는 그래프에서 노드 간의 최단 경로를 찾는 알고리즘입니다.
+_다른 언어로 읽기:_
+[_English_](README.md),
+[_한국어_](README.ko-KR.md),
+[_日本語_](README.ja-JP.md),
+[_简体中文_](README.zh-CN.md),
+[_繁體中文_](README.zh-TW.md),
+[_Українська_](README.uk-UA.md),
+[_Español_](README.es-ES.md),
+[_Français_](README.fr-FR.md),
+[_Deutsch_](README.de-DE.md),
+[_עברית_](README.he-IL.md)
-이 알고리즘은 다양한 형태로 존재합니다. 다익스트라의 원래 형태는 두 노드 간의 최단 경로를 찾았지만, 더 일반적인 형태는 단일 노드를 "소스"노드로 수정하고 그래프의 소스에서 다른 모든 노드까지의 최단 경로를 찾아 최단 경로 트리(shortest-path tree)를 생성합니다.
+다익스트라 알고리즘은 그래프의 노드 간 최단 경로를 찾는 알고리즘으로, 예를 들어 도로망을 표현할 수 있습니다.
+
+이 알고리즘에는 여러 변형이 있습니다. 다익스트라의 원래 알고리즘은 두 노드 간의 최단 경로를 찾았지만, 더 일반적인 변형은 하나의 노드를 "출발점(source)"으로 고정하고 그 노드로부터 다른 모든 노드까지의 최단 경로를 찾습니다. 이 과정을 통해 최단 경로 트리(shortest-path tree)가 만들어집니다.
-`a`와 `b` 사이의 최단 경로를 찾는 다익스트라 알고리즘입니다.
-가장 낮은 거리를 가지며 방문하지 않은 정점(vertex)를 선택하고, 이를 통해 방문하지 않은 각 이웃까지의 거리를 계산하며, 더 작은 경우 이웃의 거리를 업데이트합니다. 이웃에 대한 작업을 마치면 방문한 것으로 표시(빨간색으로 변경)합니다.
+다익스트라 알고리즘은 `a`에서 `b`로 가는 최단 경로를 찾습니다.
+아직 방문하지 않은 노드 중 가장 짧은 거리를 가진 노드를 선택하고,
+그 노드를 통해 이웃 노드로 가는 거리를 계산하여
+더 짧은 경로가 있으면 업데이트합니다.
+모든 이웃을 확인하면 해당 노드를 방문 완료(빨간색으로 표시)로 처리합니다.
+
+## 다익스트라 알고리즘의 실제 활용 사례
+
+- GPS / 내비게이션 시스템
+- 대중교통 및 항공 노선 최적화
+- 인터넷 라우팅 (OSPF, IS-IS 프로토콜)
+- 네트워크 트래픽 및 지연 시간 최적화
+- 게임에서의 경로 탐색 (지도상의 최단 경로)
+- 물류 및 배송 경로 최적화
+- 공급망 및 교통 네트워크 설계
+
+## 단계별 다익스트라 알고리즘 예제
+
+가중치가 있는 그래프가 있다고 가정합시다. 각 간선에는 노드 간의 거리 값이 있습니다. 예를 들어, 노드 `A`와 `B` 사이의 거리가 `7m`라고 하겠습니다.
+
+이 알고리즘은 항상 출발 노드로부터 가장 짧은 거리를 가진 방문하지 않은 노드를 꺼내기 위해 [우선순위 큐](../../../data-structures/priority-queue/)를 사용합니다.
+
+출발 노드는 자기 자신으로부터의 거리가 `0m`이므로, 우선순위 큐에는 처음에 이 노드만 포함되어 있습니다.
+
+다른 노드들은 그래프 탐색 중(이웃 노드를 방문할 때) 나중에 우선순위 큐에 추가됩니다.
+
+
+
+큐에서 꺼낸 노드의 각 이웃을 순회하면서 출발 노드로부터의 거리를 계산합니다.
+예를 들어, `A`에서 `B`까지의 거리는 `0m + 7m = 7m`입니다.
+
+아직 방문하지 않은 이웃을 처음 방문하면, 출발 노드로부터의 거리를 우선순위로 하여 우선순위 큐에 추가합니다.
+
+`B` 노드는 나중에 탐색하기 위해 최소 우선순위 큐에 추가됩니다.
+
+
+
+다음으로 `A`의 또 다른 이웃 `C`를 방문합니다.
+출발 노드 `A`에서 `C`까지의 거리는 `0m + 9m = 9m`입니다.
+
+`C` 노드는 이후 탐색을 위해 우선순위 큐에 추가됩니다.
+
+
+
+`F` 노드도 동일합니다.
+`A`에서 `F`까지의 거리는 `0m + 14m = 14m`입니다.
+
+`F` 노드는 나중에 탐색하기 위해 우선순위 큐에 추가됩니다.
+
+
+
+현재 노드의 모든 이웃을 확인한 후에는 이 노드를 `visited` 집합에 추가합니다.
+이후에는 이 노드를 다시 방문하지 않습니다.
+
+이제 큐에서 출발점으로부터 가장 가까운 노드를 꺼내 그 이웃들을 방문합니다.
+
+
+
+방문하려는 노드(`C`)가 이미 큐에 있다면, 이전에 다른 경로(`A → C`)를 통해 계산된 거리 정보가 있다는 뜻입니다.
+만약 현재 경로(`A → B → C`)를 통한 거리가 이전 거리보다 짧으면, 큐의 값을 업데이트합니다.
+그렇지 않으면 변경하지 않습니다.
+
+예를 들어 `B`를 통해 `C`를 방문할 때(`A → B → C`), 거리는 `7m + 10m = 17m`입니다.
+이는 이미 기록된 거리 `9m`보다 길기 때문에 업데이트하지 않습니다.
+
+
+
+`B`의 또 다른 이웃인 `D`를 방문합니다.
+`D`까지의 거리는 `7m + 15m = 22m`입니다.
+아직 방문하지 않았고 큐에도 없으므로, 우선순위 `22m`으로 큐에 추가합니다.
+
+
+
+이 시점에서 `B`의 모든 이웃을 방문했으므로, `B`를 `visited` 집합에 추가합니다.
+이제 큐에서 출발점에 가장 가까운 노드를 꺼냅니다.
+
+
+
+`C`의 방문하지 않은 이웃들을 탐색합니다.
+`C`를 통해 `F`로 가는 경로(`A → C → F`)의 거리는 `9m + 2m = 11m`입니다.
+이는 기존의 `A → F` 거리 `14m`보다 짧습니다.
+따라서 `F`의 거리를 `11m`로 업데이트하고 큐의 우선순위를 갱신합니다.
+더 짧은 경로를 찾았습니다.
+
+
+
+`D`도 마찬가지입니다.
+`A → C → D` 경로가 `A → B → D`보다 짧으므로, `22m`을 `20m`으로 업데이트합니다.
+
+
+
+`C`의 모든 이웃을 방문했으므로 `C`를 `visited`에 추가하고,
+큐에서 다음으로 가까운 노드 `F`를 꺼냅니다.
+
+
+
+`E`까지의 거리를 `11m + 9m = 20m`으로 기록합니다.
+
+
+
+`F`를 `visited`에 추가하고, 다음으로 가까운 `D`를 꺼냅니다.
+
+
+
+`D`를 통해 `E`로 가는 거리는 `20m + 6m = 26m`입니다.
+이는 이미 계산된 `20m`보다 길기 때문에 무시합니다.
+
+
+
+`D` 노드가 방문 완료되었습니다.
+
+
+
+`E` 노드도 방문 완료되었습니다.
+그래프 탐색이 끝났습니다.
+
+
+
+이제 출발 노드 `A`로부터 각 노드까지의 최단 거리를 알 수 있습니다.
+
+실제로는 거리 계산 중 각 노드의 `previousVertices`(이전 노드)를 함께 저장하여
+최단 경로를 복원할 수 있습니다.
+
+예를 들어, `A`에서 `E`로 가는 최단 경로는 `A → C → F → E`입니다.
+
+## 구현 예시
+
+- [dijkstra.js](./dijkstra.js)
-## 참조
+## 참고 자료
-- [Wikipedia](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm)
-- [On YouTube by Nathaniel Fan](https://www.youtube.com/watch?v=gdmfOwyQlcI&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
-- [On YouTube by Tushar Roy](https://www.youtube.com/watch?v=lAXZGERcDf4&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [위키백과](https://ko.wikipedia.org/wiki/다익스트라_알고리즘)
+- [YouTube - Nathaniel Fan](https://www.youtube.com/watch?v=gdmfOwyQlcI&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [YouTube - Tushar Roy](https://www.youtube.com/watch?v=lAXZGERcDf4&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
diff --git a/src/algorithms/graph/dijkstra/README.md b/src/algorithms/graph/dijkstra/README.md
index d94e2a3cdf..c5dd44a46a 100644
--- a/src/algorithms/graph/dijkstra/README.md
+++ b/src/algorithms/graph/dijkstra/README.md
@@ -1,26 +1,138 @@
# Dijkstra's Algorithm
_Read this in other languages:_
-[_한국어_](README.ko-KR.md)
+[_한국어_](README.ko-KR.md),
+[_日本語_](README.ja-JP.md),
+[_简体中文_](README.zh-CN.md),
+[_繁體中文_](README.zh-TW.md),
+[_Українська_](README.uk-UA.md),
+[_Español_](README.es-ES.md),
+[_Français_](README.fr-FR.md),
+[_Deutsch_](README.de-DE.md),
+[_עברית_](README.he-IL.md)
-Dijkstra's algorithm is an algorithm for finding the shortest
-paths between nodes in a graph, which may represent, for example,
-road networks.
+Dijkstra's algorithm is an algorithm for finding the shortest
+paths between nodes in a graph, which may represent, for example,
+road networks.
-The algorithm exists in many variants; Dijkstra's original variant
-found the shortest path between two nodes, but a more common
-variant fixes a single node as the "source" node and finds
-shortest paths from the source to all other nodes in the graph,
+The algorithm exists in many variants; Dijkstra's original variant
+found the shortest path between two nodes, but a more common
+variant fixes a single node as the "source" node and finds
+shortest paths from the source to all other nodes in the graph,
producing a shortest-path tree.
Dijkstra's algorithm to find the shortest path between `a` and `b`.
-It picks the unvisited vertex with the lowest distance,
-calculates the distance through it to each unvisited neighbor,
+It picks the unvisited vertex with the lowest distance,
+calculates the distance through it to each unvisited neighbor,
and updates the neighbor's distance if smaller. Mark visited
(set to red) when done with neighbors.
+## Practical applications of Dijkstra's algorithm
+
+- GPS / navigation systems
+- Public transit and airline route optimization
+- Internet routing (OSPF, IS-IS protocols)
+- Network traffic & latency optimization
+- Game pathfinding (shortest path on maps)
+- Logistics & delivery route optimization
+- Supply chain & transportation network design
+
+## Step-by-step Dijkstra's algorithm example
+
+Let's say we have a weighted graph of nodes, where each edge has a distance parameter between nodes. Let's say the distance from node `A` and node `B` is `7 meters` (or just `7m` for brevity), and so on.
+
+The algorithm uses [Priority Queue](../../../data-structures/priority-queue/) to always pull the next unvisited vertex that has the smallest distance from the origin node.
+
+The start node, by definition, has a distance of `0m` from itself. So we start from it, the only node in the priority queue.
+
+The rest of the nodes will be added to the priority queue later during the graph traversal (while visiting the neighbors).
+
+
+
+Each neighbor of the pulled (from the queue) node is being traversed to calculate the distance to it from the origin. For example, the distance from `A` to `B` is `0m + 7m = 7m`, and so on.
+
+Every time we visit a not-yet-seen neighbor, we add it to the priority queue, where the priority is the distance to the neighbor node from the origin node.
+
+The node `B` is being added to the min priority queue to be traversed later.
+
+
+
+Visiting the next neighbor `C` of the node `A`. The distance from the origin node `A` to `C` is `0m + 9m = 9m`.
+
+The node `C` is being added to the min priority queue to be traversed later.
+
+
+
+Same for the node `F`. The current distance to `F` from the origin node `A` is `0m + 14m = 14m`.
+
+The node `F` is being added to the min priority queue to be traversed later.
+
+
+
+Once all the neighbors of the current node were checked, the current node was added to the `visited` set. We don't want to visit such nodes once again during the upcoming traverses.
+
+Now, let's pull out the next node from the priority queue that is closest to the origin (has a shorter distance). We start visiting its neighbors as well.
+
+
+
+If the node that we're visiting (in this case, the node `C`) is already in the queue, it means we already calculated the distance to it before, but from another node/path (`A → C`). If the current distance to it (from the current neighbor node `A → B → C`) is shorter than the one that was calculated before, we update the distance (in the priority queue) to the shortest one, since we're searching for the shortest paths. If the distance from the current neighbor is actually longer than the one that was already calculated, we leave it like this without updating the `C` node distance in the queue.
+
+While visiting the node `C` via `B` (the path `A → B → C`), we see that the distance to it would be `7m + 10m = 17m`. This is actually longer than the already recorded distance of `9m` for the path `A → C`. In such cases, we just ignore the longest distance and don't update the priority (the minimum found distance at the moment from the origin node).
+
+
+
+Visiting another neighbor of `B`, which is `D`. The distance to `D` equals `7m + 15m = 22m`. Since we didn't visit `D` yet and it is not in the min priority queue, let's just add it to the queue with a priority (distance) of `22m`.
+
+
+
+At this point, all of the neighbors of `B` were traversed, so we add `B` to the `visited` set. Next, we pull the node that is closest to the origin node from the priority queue.
+
+
+
+Traversing the unvisited neighbors of the node `C`. The distance to node `F` via `C` (the path `A → C → F`) is `9m + 2m = 11m`. This is actually shorter than the previously recorded path `A → F` of `14m` length. In such cases, we update the distance to `F` to `11m` and update its priority in the queue from `14m` to `11m`. We've just found a shorter path to `F`.
+
+
+
+The same goes for `D`. We've just found a shorter path to `D`, where `A → C → D` is shorter than `A → B → D`. Updating the distance from `22m` to `20m`.
+
+
+
+All neighbors of `C` were traversed, so we may add `C` to the `visited` set. Pulling the next closest node from the queue, which is `F`.
+
+
+
+Recording the distance to `E` as `11m + 9m = 20m`.
+
+
+
+Adding the node `F` to the `visited` set, and pulling the next closest node `D` from the queue.
+
+
+
+Distance to `E` via `D` is `20m + 6m = 26m`. This is longer than the already calculated distance to `E` from `F`, which is `20m`. We can discard the longer distance.
+
+
+
+Node `D` is visited now.
+
+
+
+Node `E` is visited now as well. We've finished the graph traversal.
+
+
+
+Now we know the shortest distances to each node from the start node `A`.
+
+In practice, during the distance calculations, we also record the `previousVertices` for each node to be able to show the exact sequence of nodes that form the shortest path.
+
+For example, the shorter path from `A` to `E` is `A → C → F → E`.
+
+## Implementation example
+
+- [dijkstra.js](./dijkstra.js)
+
## References
- [Wikipedia](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm)
diff --git a/src/algorithms/graph/dijkstra/README.uk-UA.md b/src/algorithms/graph/dijkstra/README.uk-UA.md
new file mode 100644
index 0000000000..fc2436db08
--- /dev/null
+++ b/src/algorithms/graph/dijkstra/README.uk-UA.md
@@ -0,0 +1,140 @@
+# Алгоритм Дейкстри
+
+_Читайте іншими мовами:_
+[_English_](README.md),
+[_한국어_](README.ko-KR.md),
+[_日本語_](README.ja-JP.md),
+[_简体中文_](README.zh-CN.md),
+[_繁體中文_](README.zh-TW.md),
+[_Українська_](README.uk-UA.md),
+[_Español_](README.es-ES.md),
+[_Français_](README.fr-FR.md),
+[_Deutsch_](README.de-DE.md),
+[_עברית_](README.he-IL.md)
+
+Алгоритм Дейкстри — це алгоритм пошуку найкоротших шляхів між вершинами графа, який може представляти, наприклад, дорожню мережу.
+
+Існує багато варіантів цього алгоритму; оригінальний варіант Дейкстри знаходив найкоротший шлях між двома вершинами, але більш поширений варіант фіксує одну вершину як «джерело» і знаходить найкоротші шляхи від неї до всіх інших вершин графа, утворюючи дерево найкоротших шляхів.
+
+
+
+Алгоритм Дейкстри для пошуку найкоротшого шляху між `a` та `b`.
+Він вибирає непереглянуту вершину з найменшою відстанню, обчислює відстань через неї до кожного непереглянутого сусіда й оновлює відстань до сусіда, якщо вона менша. Коли всі сусіди опрацьовані — вершина позначається як відвідана (червоним кольором).
+
+## Практичні застосування алгоритму Дейкстри
+
+- GPS / навігаційні системи
+- Оптимізація маршрутів громадського транспорту та авіаліній
+- Інтернет-маршрутизація (протоколи OSPF, IS-IS)
+- Оптимізація мережевого трафіку та затримок
+- Пошук шляху в іграх (найкоротший шлях на карті)
+- Оптимізація маршрутів доставки
+- Проєктування логістичних та транспортних мереж
+
+## Покроковий приклад алгоритму Дейкстри
+
+Припустімо, ми маємо зважений граф вершин, де кожне ребро має певну довжину. Наприклад, відстань між вершинами `A` і `B` становить `7 метрів` (або просто `7m`).
+
+Алгоритм використовує [чергу з пріоритетом](../../../data-structures/priority-queue/), щоб завжди вибирати наступну непереглянуту вершину з найменшою відстанню від початкової вершини.
+
+Початкова вершина, за визначенням, має відстань `0m` від самої себе. З неї й починається пошук — вона єдина в черзі на початку.
+
+Решта вершин додаються до черги з пріоритетом пізніше, у процесі обходу графа (під час відвідування сусідів).
+
+
+
+Кожен сусід витягнутої з черги вершини перевіряється для обчислення відстані до нього від початкової вершини. Наприклад, відстань від `A` до `B` — це `0m + 7m = 7m`.
+
+Щоразу, коли ми відвідуємо нового (ще не баченого) сусіда, ми додаємо його в чергу з пріоритетом, де пріоритет — це відстань до цієї вершини від початкової.
+
+Вершину `B` додаємо до мінімальної черги з пріоритетом, щоб відвідати її пізніше.
+
+
+
+Відвідуємо наступного сусіда `C` вершини `A`. Відстань від `A` до `C` становить `0m + 9m = 9m`.
+
+Додаємо вершину `C` до мінімальної черги з пріоритетом.
+
+
+
+Те саме робимо для вершини `F`. Поточна відстань від `A` до `F` — `0m + 14m = 14m`.
+
+Вершину `F` додаємо до черги для подальшого обходу.
+
+
+
+Коли всі сусіди поточної вершини перевірені, ми додаємо її до множини `visited`. Такі вершини більше не відвідуємо.
+
+Тепер вибираємо з черги наступну вершину, найближчу до початкової, і починаємо відвідувати її сусідів.
+
+
+
+Якщо вершина, яку ми відвідуємо (наприклад, `C`), уже є в черзі, це означає, що відстань до неї вже обчислювалася раніше з іншого шляху (`A → C`). Якщо нова відстань (через інший шлях, наприклад `A → B → C`) менша, ми оновлюємо її в черзі. Якщо більша — залишаємо без змін.
+
+Під час відвідування `C` через `B` (`A → B → C`), відстань дорівнює `7m + 10m = 17m`. Це більше, ніж уже відома `9m` для шляху `A → C`. Тож ми ігноруємо довший шлях.
+
+
+
+Відвідуємо іншого сусіда `B` — вершину `D`. Відстань до `D` дорівнює `7m + 15m = 22m`.
+Оскільки `D` ще не відвідано і її немає в черзі, додаємо її з пріоритетом `22m`.
+
+
+
+Тепер усіх сусідів `B` відвідано, тож додаємо `B` до множини `visited`.
+Наступною вибираємо вершину, що найближча до початкової.
+
+
+
+Відвідуємо непереглянутих сусідів вершини `C`.
+Відстань до вершини `F` через `C` (`A → C → F`) дорівнює `9m + 2m = 11m`.
+Це коротше за попередній шлях `A → F` довжиною `14m`.
+Тому оновлюємо відстань до `F` — з `14m` до `11m`. Ми щойно знайшли коротший шлях.
+
+
+
+Так само для `D`: шлях `A → C → D` коротший за `A → B → D`.
+Оновлюємо відстань з `22m` до `20m`.
+
+
+
+Усі сусіди `C` пройдені, додаємо її до `visited`.
+Дістаємо з черги наступну найближчу вершину — `F`.
+
+
+
+Записуємо відстань до `E`: `11m + 9m = 20m`.
+
+
+
+Додаємо `F` до множини `visited`, далі дістаємо `D`.
+
+
+
+Відстань до `E` через `D`: `20m + 6m = 26m`.
+Це більше, ніж уже обчислені `20m` через `F`, тому ігноруємо довший шлях.
+
+
+
+Вершину `D` відвідано.
+
+
+
+Вершину `E` також відвідано. Обхід графа завершено.
+
+
+
+Тепер ми знаємо найкоротші відстані до кожної вершини від початкової `A`.
+
+На практиці під час обчислення відстаней також зберігаються `previousVertices` — попередні вершини, щоб можна було відновити повний шлях.
+
+Наприклад, найкоротший шлях від `A` до `E` — це `A → C → F → E`.
+
+## Приклад реалізації
+
+- [dijkstra.js](./dijkstra.js)
+
+## Джерела
+
+- [Вікіпедія](https://uk.wikipedia.org/wiki/Алгоритм_Дейкстри)
+- [Відео на YouTube від Nathaniel Fan](https://www.youtube.com/watch?v=gdmfOwyQlcI&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [Відео на YouTube від Tushar Roy](https://www.youtube.com/watch?v=lAXZGERcDf4&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
diff --git a/src/algorithms/graph/dijkstra/README.zh-CN.md b/src/algorithms/graph/dijkstra/README.zh-CN.md
new file mode 100644
index 0000000000..382a9dee05
--- /dev/null
+++ b/src/algorithms/graph/dijkstra/README.zh-CN.md
@@ -0,0 +1,155 @@
+# Dijkstra 算法
+
+_阅读其他语言版本：_
+[_English_](README.md),
+[_한국어_](README.ko-KR.md),
+[_日本語_](README.ja-JP.md),
+[_简体中文_](README.zh-CN.md),
+[_繁體中文_](README.zh-TW.md),
+[_Українська_](README.uk-UA.md),
+[_Español_](README.es-ES.md),
+[_Français_](README.fr-FR.md),
+[_Deutsch_](README.de-DE.md),
+[_עברית_](README.he-IL.md)
+
+Dijkstra 算法是一种用于在图中查找节点之间最短路径的算法，例如，它可以用于表示道路网络。
+
+该算法有许多变体；Dijkstra 的原始版本用于查找两个节点之间的最短路径，但更常见的变体是将一个节点固定为“源节点”，并计算从该源节点到图中所有其他节点的最短路径，从而生成最短路径树。
+
+
+
+Dijkstra 算法用于查找从 `a` 到 `b` 的最短路径。
+它选择未访问的距离最小的节点，计算通过它到每个未访问邻居的距离，
+如果更短，则更新邻居的距离。
+当该节点的所有邻居都被处理完后，将其标记为已访问（红色）。
+
+## Dijkstra 算法的实际应用
+
+- GPS / 导航系统
+- 公共交通和航线优化
+- 互联网路由（OSPF、IS-IS 协议）
+- 网络流量与延迟优化
+- 游戏路径寻路（地图上的最短路径）
+- 物流与配送路线优化
+- 供应链与交通网络设计
+
+## Dijkstra 算法逐步示例
+
+假设我们有一个带权图，每条边表示节点之间的距离。
+例如，节点 `A` 和节点 `B` 之间的距离是 `7 米`（简称 `7m`）。
+
+算法使用 [优先队列](../../../data-structures/priority-queue/) 来始终提取离起始节点距离最短的未访问节点。
+
+起始节点与自身的距离定义为 `0m`。因此我们从它开始，这是优先队列中的唯一节点。
+
+在遍历图的过程中（访问邻居节点时），其余节点会逐渐被添加到优先队列中。
+
+
+
+从队列中取出的节点的每个邻居都会被遍历，以计算从起点到该邻居的距离。
+例如，从 `A` 到 `B` 的距离为 `0m + 7m = 7m`。
+
+每次访问尚未访问的邻居时，将其加入优先队列，优先级为从起点到该节点的距离。
+
+节点 `B` 被加入最小优先队列，以便稍后遍历。
+
+
+
+接着访问节点 `A` 的另一个邻居 `C`。
+从起始节点 `A` 到 `C` 的距离为 `0m + 9m = 9m`。
+
+节点 `C` 被加入最小优先队列，等待后续遍历。
+
+
+
+同样地，对于节点 `F`，从起始节点 `A` 的当前距离是 `0m + 14m = 14m`。
+
+节点 `F` 被加入最小优先队列，等待后续遍历。
+
+
+
+当当前节点的所有邻居都被检查完后，将当前节点添加到 `visited` 集合中。
+在后续遍历中不会再次访问这些节点。
+
+现在，从优先队列中取出离起点最近（距离最短）的节点，开始访问它的邻居。
+
+
+
+如果正在访问的节点（此处为 `C`）已经在队列中，
+表示之前通过另一条路径（`A → C`）已计算过其距离。
+如果当前路径（`A → B → C`）的距离更短，则更新距离；
+否则保持原状。
+
+例如，通过 `B` 访问 `C`（路径 `A → B → C`），距离为 `7m + 10m = 17m`。
+这比已记录的 `A → C` 路径的 `9m` 更长，因此忽略。
+
+
+
+访问 `B` 的另一个邻居 `D`。
+到 `D` 的距离为 `7m + 15m = 22m`。
+由于 `D` 尚未访问，也不在队列中，因此将其以距离 `22m` 的优先级加入队列。
+
+
+
+此时，`B` 的所有邻居都已遍历，因此将 `B` 添加到 `visited` 集合中。
+接着，从优先队列中取出离起始节点最近的节点。
+
+
+
+遍历节点 `C` 的未访问邻居。
+通过 `C` 到 `F` 的路径（`A → C → F`）距离为 `9m + 2m = 11m`。
+这比之前记录的路径 `A → F`（`14m`）更短。
+因此，将 `F` 的距离更新为 `11m`，并在队列中调整其优先级。
+我们找到了到 `F` 的更短路径。
+
+
+
+对于 `D` 也是如此。
+路径 `A → C → D` 比 `A → B → D` 更短，
+因此将距离从 `22m` 更新为 `20m`。
+
+
+
+`C` 的所有邻居都已遍历完，将其加入 `visited`。
+然后从队列中取出下一个最近的节点 `F`。
+
+
+
+记录到 `E` 的距离：`11m + 9m = 20m`。
+
+
+
+将节点 `F` 添加到 `visited` 集合中，并从队列中取出下一个最近的节点 `D`。
+
+
+
+通过 `D` 到 `E` 的距离为 `20m + 6m = 26m`。
+这比通过 `F` 的 `20m` 更长，因此忽略。
+
+
+
+节点 `D` 已访问。
+
+
+
+节点 `E` 也已访问。
+图的遍历完成。
+
+
+
+现在，我们已经知道从起始节点 `A` 到每个节点的最短距离。
+
+在实际应用中，在计算距离的同时，还会记录每个节点的 `previousVertices`（前驱节点），
+以便重建形成最短路径的节点序列。
+
+例如，从 `A` 到 `E` 的最短路径为 `A → C → F → E`。
+
+## 实现示例
+
+- [dijkstra.js](./dijkstra.js)
+
+## 参考资料
+
+- [维基百科](https://zh.wikipedia.org/wiki/Dijkstra算法)
+- [YouTube - Nathaniel Fan](https://www.youtube.com/watch?v=gdmfOwyQlcI&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [YouTube - Tushar Roy](https://www.youtube.com/watch?v=lAXZGERcDf4&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
diff --git a/src/algorithms/graph/dijkstra/README.zh-TW.md b/src/algorithms/graph/dijkstra/README.zh-TW.md
new file mode 100644
index 0000000000..e960b41797
--- /dev/null
+++ b/src/algorithms/graph/dijkstra/README.zh-TW.md
@@ -0,0 +1,161 @@
+# Dijkstra 演算法
+
+_以其他語言閱讀：_
+[_English_](README.md),
+[_한국어_](README.ko-KR.md),
+[_日本語_](README.ja-JP.md),
+[_简体中文_](README.zh-CN.md),
+[_繁體中文_](README.zh-TW.md),
+[_Українська_](README.uk-UA.md),
+[_Español_](README.es-ES.md),
+[_Français_](README.fr-FR.md),
+[_Deutsch_](README.de-DE.md),
+[_עברית_](README.he-IL.md)
+
+Dijkstra 演算法是一種用於在圖中尋找節點之間最短路徑的演算法，例如，它可用於表示道路網絡。
+
+該演算法有許多變體；Dijkstra 的原始版本用於尋找兩個節點之間的最短路徑，但更常見的變體是將一個節點固定為「起點（source）」節點，並從該節點計算到圖中所有其他節點的最短路徑，從而生成最短路徑樹（shortest-path tree）。
+
+
+
+Dijkstra 演算法用於尋找從 `a` 到 `b` 的最短路徑。
+它會選擇距離最短且尚未訪問的節點，計算經由該節點到各個未訪問鄰居的距離，
+若該距離更短，則更新鄰居的距離。
+當所有鄰居處理完畢後，將該節點標記為已訪問（紅色）。
+
+## Dijkstra 演算法的實際應用
+
+- GPS / 導航系統
+- 公共交通與航空路線最佳化
+- 網際網路路由（OSPF、IS-IS 協定）
+- 網路流量與延遲最佳化
+- 電玩遊戲中的路徑尋找（地圖上的最短路徑）
+- 物流與配送路線最佳化
+- 供應鏈與交通網路設計
+
+## Dijkstra 演算法逐步範例
+
+假設我們有一個帶權重的圖，每條邊都代表節點之間的距離。
+例如，節點 `A` 與節點 `B` 之間的距離為 `7 公尺`（簡稱 `7m`）。
+
+演算法使用 [優先佇列（Priority Queue）](../../../data-structures/priority-queue/)
+來不斷取出距離起點最近的未訪問節點。
+
+起始節點與自身的距離定義為 `0m`，因此我們從它開始，
+此時它是優先佇列中唯一的節點。
+
+其餘節點會在圖遍歷過程中（訪問鄰居時）逐漸加入佇列。
+
+
+
+從佇列中取出的節點，其每個鄰居都會被檢查，以計算從起點到該鄰居的距離。
+例如，從 `A` 到 `B` 的距離為 `0m + 7m = 7m`。
+
+每當訪問尚未看過的鄰居時，就將其加入優先佇列，
+其優先權為從起點到該鄰居的距離。
+
+節點 `B` 被加入最小優先佇列，以便稍後處理。
+
+
+
+接著訪問節點 `A` 的另一個鄰居 `C`。
+從起點 `A` 到 `C` 的距離為 `0m + 9m = 9m`。
+
+節點 `C` 被加入最小優先佇列，等待後續遍歷。
+
+
+
+同樣地，對於節點 `F`，
+從起點 `A` 到 `F` 的距離為 `0m + 14m = 14m`。
+
+節點 `F` 被加入最小優先佇列，以便稍後處理。
+
+
+
+當目前節點的所有鄰居都被檢查完後，
+將該節點加入 `visited` 集合中。
+之後將不再重新訪問該節點。
+
+接著從佇列中取出距離起點最近的節點，開始訪問它的鄰居。
+
+
+
+若正在訪問的節點（例如 `C`）已存在於佇列中，
+代表先前已經透過另一條路徑（`A → C`）計算過其距離。
+若目前路徑（`A → B → C`）的距離更短，則更新距離；
+若更長，則保持不變。
+
+例如，透過 `B` 訪問 `C`（路徑 `A → B → C`）的距離為 `7m + 10m = 17m`，
+比原先記錄的 `9m` 更長，因此不需更新。
+
+
+
+接著訪問 `B` 的另一個鄰居 `D`。
+到 `D` 的距離為 `7m + 15m = 22m`。
+由於 `D` 尚未訪問，也不在佇列中，因此將其以優先權（距離）`22m` 加入佇列。
+
+
+
+此時 `B` 的所有鄰居都已遍歷完，
+因此將 `B` 加入 `visited` 集合中。
+接著從佇列中取出距離起點最近的節點。
+
+
+
+訪問節點 `C` 的未訪問鄰居。
+經由 `C` 到 `F`（路徑 `A → C → F`）的距離為 `9m + 2m = 11m`。
+這比原本的路徑 `A → F`（`14m`）更短。
+因此，將 `F` 的距離更新為 `11m`，並調整其在佇列中的優先權。
+我們找到了更短的路徑。
+
+
+
+對於 `D` 也是如此。
+經由 `C` 的路徑 `A → C → D` 比 `A → B → D` 更短，
+因此將距離從 `22m` 更新為 `20m`。
+
+
+
+`C` 的所有鄰居已被訪問，因此將 `C` 加入 `visited` 集合。
+接著從佇列中取出下一個最近的節點 `F`。
+
+
+
+記錄到 `E` 的距離為 `11m + 9m = 20m`。
+
+
+
+將節點 `F` 加入 `visited`，接著取出下一個最近的節點 `D`。
+
+
+
+經由 `D` 到 `E` 的距離為 `20m + 6m = 26m`，
+比透過 `F` 的 `20m` 更長，因此忽略。
+
+
+
+節點 `D` 已訪問。
+
+
+
+節點 `E` 也已訪問。
+圖的遍歷完成。
+
+
+
+現在我們已經知道從起始節點 `A` 到各個節點的最短距離。
+
+在實際應用中，計算距離的同時也會記錄每個節點的 `previousVertices`（前一節點），
+以便重建出最短路徑的完整節點序列。
+
+例如，從 `A` 到 `E` 的最短路徑為：`A → C → F → E`。
+
+## 實作範例
+
+- [dijkstra.js](./dijkstra.js)
+
+## 參考資料
+
+- [維基百科](https://zh.wikipedia.org/wiki/Dijkstra算法)
+- [YouTube - Nathaniel Fan](https://www.youtube.com/watch?v=gdmfOwyQlcI&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [YouTube - Tushar Roy](https://www.youtube.com/watch?v=lAXZGERcDf4&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-01.png b/src/algorithms/graph/dijkstra/images/dijkstra-01.png
new file mode 100644
index 0000000000..3f6fba1dc7
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-01.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-02.png b/src/algorithms/graph/dijkstra/images/dijkstra-02.png
new file mode 100644
index 0000000000..6e07084c1a
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-02.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-03.png b/src/algorithms/graph/dijkstra/images/dijkstra-03.png
new file mode 100644
index 0000000000..53765465be
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-03.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-04.png b/src/algorithms/graph/dijkstra/images/dijkstra-04.png
new file mode 100644
index 0000000000..1ceb77cbef
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-04.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-05.png b/src/algorithms/graph/dijkstra/images/dijkstra-05.png
new file mode 100644
index 0000000000..236a11de8f
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-05.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-06.png b/src/algorithms/graph/dijkstra/images/dijkstra-06.png
new file mode 100644
index 0000000000..64dc86482c
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-06.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-07.png b/src/algorithms/graph/dijkstra/images/dijkstra-07.png
new file mode 100644
index 0000000000..0f65577116
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-07.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-08.png b/src/algorithms/graph/dijkstra/images/dijkstra-08.png
new file mode 100644
index 0000000000..519aa22be8
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-08.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-09.png b/src/algorithms/graph/dijkstra/images/dijkstra-09.png
new file mode 100644
index 0000000000..498b1cc8d4
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-09.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-10.png b/src/algorithms/graph/dijkstra/images/dijkstra-10.png
new file mode 100644
index 0000000000..957c38082d
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-10.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-11.png b/src/algorithms/graph/dijkstra/images/dijkstra-11.png
new file mode 100644
index 0000000000..3b03262182
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-11.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-12.png b/src/algorithms/graph/dijkstra/images/dijkstra-12.png
new file mode 100644
index 0000000000..b06b388e50
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-12.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-13.png b/src/algorithms/graph/dijkstra/images/dijkstra-13.png
new file mode 100644
index 0000000000..414c877b93
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-13.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-14.png b/src/algorithms/graph/dijkstra/images/dijkstra-14.png
new file mode 100644
index 0000000000..0ad8bb53f6
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-14.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-15.png b/src/algorithms/graph/dijkstra/images/dijkstra-15.png
new file mode 100644
index 0000000000..986d82a27c
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-15.png differ
diff --git a/src/algorithms/graph/dijkstra/images/dijkstra-16.png b/src/algorithms/graph/dijkstra/images/dijkstra-16.png
new file mode 100644
index 0000000000..4c9d955de0
Binary files /dev/null and b/src/algorithms/graph/dijkstra/images/dijkstra-16.png differ
diff --git a/src/algorithms/search/binary-search/README.es-ES.md b/src/algorithms/search/binary-search/README.es-ES.md
new file mode 100644
index 0000000000..f14aef985f
--- /dev/null
+++ b/src/algorithms/search/binary-search/README.es-ES.md
@@ -0,0 +1,27 @@
+# Búsqueda binaria
+
+_Lea esto en otros idiomas:_
+[English](README.md)
+[Português brasileiro](README.pt-BR.md).
+
+En informática, la búsqueda binaria, también conocida como búsqueda de medio intervalo
+búsqueda, búsqueda logarítmica, o corte binario, es un algoritmo de búsqueda
+que encuentra la posición de un valor objetivo dentro de una matriz
+ordenada. La búsqueda binaria compara el valor objetivo con el elemento central
+de la matriz; si son desiguales, se elimina la mitad en la que
+la mitad en la que no puede estar el objetivo se elimina y la búsqueda continúa
+en la mitad restante hasta que tenga éxito. Si la búsqueda
+termina con la mitad restante vacía, el objetivo no está
+en la matriz.
+
+
+
+## Complejidad
+
+**Complejidad de tiempo**: `O(log(n))` - ya que dividimos el área de búsqueda en dos para cada
+siguiente iteración.
+
+## Referencias
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Binary_search_algorithm)
+- [YouTube](https://www.youtube.com/watch?v=P3YID7liBug&index=29&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
diff --git a/src/algorithms/search/binary-search/README.md b/src/algorithms/search/binary-search/README.md
index ebf3e123e0..34d1bd7a40 100644
--- a/src/algorithms/search/binary-search/README.md
+++ b/src/algorithms/search/binary-search/README.md
@@ -2,15 +2,16 @@
_Read this in other languages:_
[Português brasileiro](README.pt-BR.md).
+[Español](README.es-ES.md).
-In computer science, binary search, also known as half-interval
-search, logarithmic search, or binary chop, is a search algorithm
-that finds the position of a target value within a sorted
-array. Binary search compares the target value to the middle
-element of the array; if they are unequal, the half in which
-the target cannot lie is eliminated and the search continues
-on the remaining half until it is successful. If the search
-ends with the remaining half being empty, the target is not
+In computer science, binary search, also known as half-interval
+search, logarithmic search, or binary chop, is a search algorithm
+that finds the position of a target value within a sorted
+array. Binary search compares the target value to the middle
+element of the array; if they are unequal, the half in which
+the target cannot lie is eliminated and the search continues
+on the remaining half until it is successful. If the search
+ends with the remaining half being empty, the target is not
in the array.
diff --git a/src/algorithms/search/binary-search/README.pt-BR.md b/src/algorithms/search/binary-search/README.pt-BR.md
index 14445a048e..4f9de9f199 100644
--- a/src/algorithms/search/binary-search/README.pt-BR.md
+++ b/src/algorithms/search/binary-search/README.pt-BR.md
@@ -2,6 +2,7 @@
_Leia isso em outras línguas:_
[english](README.md).
+[Español](README.es-ES.md).
Em ciência da computação, busca binária, também conhecida como busca de meio-intervalo, busca logarítmica ou corte binário, é um algoritmo de pesquisa
que encontra a posição de um elemento alvo dentro de um
diff --git a/src/algorithms/stack/valid-parentheses/README.md b/src/algorithms/stack/valid-parentheses/README.md
new file mode 100644
index 0000000000..31d7fd60f3
--- /dev/null
+++ b/src/algorithms/stack/valid-parentheses/README.md
@@ -0,0 +1,44 @@
+# Valid Parentheses Problem
+
+Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.
+
+An input string is valid if:
+
+Open brackets must be closed by the same type of brackets.
+Open brackets must be closed in the correct order.
+Every close bracket has a corresponding open bracket of the same type.
+
+
+Example 1:
+
+`Input: s = "()"`
+
+Output: true
+
+Example 2:
+
+`Input: s = "()[]{}"`
+
+Output: true
+
+Example 3:
+
+`Input: s = "(]"`
+
+Output: false
+
+This is actually a very common interview question and a very good example of how to use a stack data structure to solve problems.
+
+## Solution
+The problem can be solved in two ways
+
+### Bruteforce Approach
+We can iterate through the string and then for each character in the string, we check for it's last closing character in the the string. Once we find the last closing character in the string, we remove both characters and then repeat the iteration, if we don't find a closing character for an opening character, then the string is invalid. The time complexity of this would be O(n^2) which is not so efficient.
+
+### Using a Stack
+We can use a hashtable to store all opening characters and the value would be the respective closing character. We can then iterate through the string and if we encounter an opening parantheses, we push it's closing character to the stack. If we ecounter a closing paraentheses, then we pop the stack and confirm that the popped element is equal to the current closing parentheses character. If it is not then the string is invalid. At the end of the iteration, we also need to check that the stack is empty. If it is not then the string is invalid. If it is, then the string is valid. This is a more efficient approach with a Time complexity and Space complexity of O(n).
+
+
+## References
+
+- [Leetcode](https://leetcode.com/problems/valid-parentheses/)
diff --git a/src/algorithms/stack/valid-parentheses/__test__/validParentheses.test.js b/src/algorithms/stack/valid-parentheses/__test__/validParentheses.test.js
new file mode 100644
index 0000000000..e286688dfd
--- /dev/null
+++ b/src/algorithms/stack/valid-parentheses/__test__/validParentheses.test.js
@@ -0,0 +1,23 @@
+import isValid from '../validParentheses';
+
+describe('validParentheses', () => {
+ it('should return false when string is empty', () => {
+ expect(isValid('')).toBe(false);
+ });
+
+ it('should return true when string contains valid parentheses in correct order', () => {
+ expect(isValid('()')).toBe(true);
+ expect(isValid('()[]{}')).toBe(true);
+ expect(isValid('((({[]})))')).toBe(true);
+ });
+
+ it('should return false when string contains invalid parentheses', () => {
+ expect(isValid('(]')).toBe(false);
+ expect(isValid('()[]{} }')).toBe(false);
+ expect(isValid('((({[(]})))')).toBe(false);
+ });
+
+ it('should return false when string contains valid parentheses in wrong order', () => {
+ expect(isValid('({)}')).toBe(false);
+ });
+});
diff --git a/src/algorithms/stack/valid-parentheses/validParentheses.js b/src/algorithms/stack/valid-parentheses/validParentheses.js
new file mode 100644
index 0000000000..a327780768
--- /dev/null
+++ b/src/algorithms/stack/valid-parentheses/validParentheses.js
@@ -0,0 +1,42 @@
+import Stack from '../../../data-structures/stack/Stack';
+import HashTable from '../../../data-structures/hash-table/HashTable';
+
+// Declare hashtable containg opening parentheses as key and it's closing parentheses as value.
+const hashTable = new HashTable(3);
+hashTable.set('{', '}');
+hashTable.set('(', ')');
+hashTable.set('[', ']');
+
+/**
+ * Check if string has valid parentheses.
+ *
+ * @param {string} parenthesesString
+ * @return {boolean}
+ */
+export default function isValid(parenthesesString) {
+ // If string is empty return false
+ if (parenthesesString.length === 0) {
+ return false;
+ }
+ // Create stack
+ const stack = new Stack();
+
+ // Loop through each character of string
+ for (let i = 0; i < parenthesesString.length; i += 1) {
+ const currentCharacter = parenthesesString[i];
+ // If character is opening parentheses push it's closing parentheses to stack
+ if (hashTable.has(currentCharacter)) {
+ stack.push(hashTable.get(currentCharacter));
+ } else {
+ /* If character is a closing parentheses then,:
+ check If stack is empty, if it is return false.
+ if stack is not empty, pop from stack and compare it with current character.
+ If they are not same return false. */
+ if (stack.isEmpty() || stack.pop() !== currentCharacter) {
+ return false;
+ }
+ }
+ }
+ // If stack is empty return true else return false
+ return stack.isEmpty();
+}
diff --git a/src/algorithms/uncategorized/best-time-to-buy-sell-stocks/README.md b/src/algorithms/uncategorized/best-time-to-buy-sell-stocks/README.md
index 9446993e98..975eade3a4 100644
--- a/src/algorithms/uncategorized/best-time-to-buy-sell-stocks/README.md
+++ b/src/algorithms/uncategorized/best-time-to-buy-sell-stocks/README.md
@@ -46,7 +46,7 @@ Let's say we have an array of prices `[7, 6, 4, 3, 1]` and we're on the _1st_ da
1. _Option 1: Keep the money_ → profit would equal to the profit from buying/selling the rest of the stocks → `keepProfit = profit([6, 4, 3, 1])`.
2. _Option 2: Buy/sell at current price_ → profit in this case would equal to the profit from buying/selling the rest of the stocks plus (or minus, depending on whether we're selling or buying) the current stock price → `buySellProfit = -7 + profit([6, 4, 3, 1])`.
-The overall profit would be equal to → `overalProfit = Max(keepProfit, buySellProfit)`.
+The overall profit would be equal to → `overallProfit = Max(keepProfit, buySellProfit)`.
As you can see the `profit([6, 4, 3, 1])` task is being solved in the same recursive manner.
diff --git a/src/algorithms/uncategorized/n-queens/README.md b/src/algorithms/uncategorized/n-queens/README.md
index 077e26d73d..399256768e 100644
--- a/src/algorithms/uncategorized/n-queens/README.md
+++ b/src/algorithms/uncategorized/n-queens/README.md
@@ -59,7 +59,7 @@ and return false.
queen here leads to a solution.
b) If placing queen in [row, column] leads to a solution then return
true.
- c) If placing queen doesn't lead to a solution then umark this [row,
+ c) If placing queen doesn't lead to a solution then unmark this [row,
column] (Backtrack) and go to step (a) to try other rows.
3) If all rows have been tried and nothing worked, return false to trigger
backtracking.
diff --git a/src/data-structures/bloom-filter/README.md b/src/data-structures/bloom-filter/README.md
index e156310cb4..7880a7f7be 100644
--- a/src/data-structures/bloom-filter/README.md
+++ b/src/data-structures/bloom-filter/README.md
@@ -93,7 +93,7 @@ three factors: the size of the bloom filter, the
number of hash functions we use, and the number
of items that have been inserted into the filter.
-The formula to calculate probablity of a false positive is:
+The formula to calculate probability of a false positive is:
( 1 - e -kn/m ) k
diff --git a/src/data-structures/heap/Heap.js b/src/data-structures/heap/Heap.js
index 45dfcfa267..b978739ec8 100644
--- a/src/data-structures/heap/Heap.js
+++ b/src/data-structures/heap/Heap.js
@@ -279,7 +279,7 @@ export default class Heap {
/* istanbul ignore next */
pairIsInCorrectOrder(firstElement, secondElement) {
throw new Error(`
- You have to implement heap pair comparision method
+ You have to implement heap pair comparison method
for ${firstElement} and ${secondElement} values.
`);
}
diff --git a/src/data-structures/linked-list/README.es-ES.md b/src/data-structures/linked-list/README.es-ES.md
index c21c48cded..6c6ba7ee87 100644
--- a/src/data-structures/linked-list/README.es-ES.md
+++ b/src/data-structures/linked-list/README.es-ES.md
@@ -7,9 +7,9 @@ _Lee este artículo en otros idiomas:_
[_Português_](README.pt-BR.md)
[_English_](README.md)
-En ciencias de la computaciòn una **lista enlazada** es una coleccion linear
-de elementos de datos, en los cuales el orden linear no es dado por
-su posciòn fisica en memoria. En cambio, cada
+En ciencias de la computación una **lista enlazada** es una colección lineal
+de elementos, en los cuales el orden lineal no es dado por
+su posición física en memoria. En cambio, cada
elemento señala al siguiente. Es una estructura de datos
que consiste en un grupo de nodos los cuales juntos representan
una secuencia. En su forma más sencilla, cada nodo está
@@ -19,10 +19,10 @@ permite la inserción o eliminación de elementos
desde cualquier posición en la secuencia durante la iteración.
Las variantes más complejas agregan enlaces adicionales, permitiendo
una eficiente inserción o eliminación desde referencias arbitrarias
-del elemento. Una desventaja de las listas lazadas es que el tiempo de
+del elemento. Una desventaja de las listas enlazadas es que el tiempo de
acceso es lineal (y difícil de canalizar). Un acceso
más rápido, como un acceso aleatorio, no es factible. Los arreglos
-tienen una mejor locazion en caché comparados con las listas lazadas.
+tienen una mejor localización en caché comparados con las listas enlazadas.
@@ -112,7 +112,7 @@ Remove(head, value)
end Remove
```
-### Atrevesar
+### Atravesar
```text
Traverse(head)
diff --git a/src/data-structures/linked-list/README.uk-UA.md b/src/data-structures/linked-list/README.uk-UA.md
index 5424c58db4..9b34a6d828 100644
--- a/src/data-structures/linked-list/README.uk-UA.md
+++ b/src/data-structures/linked-list/README.uk-UA.md
@@ -1,10 +1,10 @@
# Зв'язаний список
-Зв'язаний список — базова динамічна структура даних в інформатиці, що складається з вузлів, кожен з яких містить як дані, так посилання («зв'язку») на наступний вузол списку. Дана структура дозволяє ефективно додавати та видаляти елементи на довільній позиції у послідовності у процесі ітерації. Більш складні варіанти включають додаткові посилання, що дозволяють ефективно додавати та видаляти довільні елементи.
+Зв'язаний список — базова динамічна структура даних в інформатиці, що складається з вузлів, кожен з яких містить як дані, так і посилання («зв'язку») на наступний вузол списку. Ця структура даних дозволяє ефективно додавати та видаляти елементи на довільній позиції у послідовності у процесі ітерації. Більш складні варіанти включають додаткові посилання, що дозволяють ефективно додавати та видаляти довільні елементи.
-Принциповою перевагою перед масивом є структурна гнучкість: порядок елементів зв'язкового списку може збігатися з порядком розташування елементів даних у пам'яті комп'ютера, а порядок обходу списку завжди явно задається його внутрішніми зв'язками. Суть переваги у тому, що у багатьох мовах створення масиву вимагає вказати його заздалегідь. Зв'язковий список дозволяє обійти це обмеження.
+Принциповою перевагою перед масивом є структурна гнучкість: порядок елементів зв'язаного списку може збігатися з порядком розташування елементів даних у пам'яті комп'ютера, а порядок обходу списку завжди явно задається його внутрішніми зв'язками. Це важливо, бо у багатьох мовах створення масиву вимагає вказати його розмір заздалегідь. Зв'язаний список дозволяє обійти це обмеження.
-Недоліком зв'язкових списків є те, що час доступу є лінійним (і важко для реалізації конвеєрів). Неможливий швидкий доступ (випадковий).
+Недоліком зв'язаних списків є те, що час доступу є лінійним (і важко для реалізації конвеєрів). Неможливий швидкий доступ (випадковий).
@@ -17,7 +17,7 @@
```text
Add(value)
Pre: value - значення, що додається
- Post: value поміщено в кінець списку
+ Post: value додано в кінець списку
n ← node(value)
if head = ø
head ← n
@@ -32,7 +32,7 @@ end Add
```text
Prepend(value)
Pre: value - значення, що додається
- Post: value поміщено на початок списку
+ Post: value додано на початку списку
n ← node(value)
n.next ← head
head ← n
@@ -42,7 +42,7 @@ Prepend(value)
end Prepend
```
-### Поиск
+### Пошук
```text
Contains(head, value)
@@ -60,7 +60,7 @@ Contains(head, value)
end Contains
```
-### Вилучення
+### Видалення
```text
Remove(head, value)
@@ -94,7 +94,7 @@ Remove(head, value)
end Remove
```
-### Обход
+### Обхід
```text
Traverse(head)
@@ -108,12 +108,12 @@ Traverse(head)
end Traverse
```
-### Зворотний обхід
+### Зворотній обхід
```text
ReverseTraversal(head, tail)
- Pre: head и tail відносяться до одного списку
- Post: елементи списку пройдено у зворотному порядку
+ Pre: head і tail відносяться до одного списку
+ Post: елементи списку пройдено у зворотньому порядку
if tail != ø
curr ← tail
while curr != head
@@ -131,7 +131,7 @@ end ReverseTraversal
## Складність
-### Тимчасова складність
+### Часова складність
| Читання | Пошук | Вставка | Вилучення |
| :--------: | :-------: | :--------: | :-------: |
@@ -143,5 +143,5 @@ O(n)
## Посилання
-- [Wikipedia](https://uk.wikipedia.org/wiki/%D0%97%D0%B2%27%D1%8F%D0%B7%D0%B0%D0%BD%D0%B8%D0%B9_%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA)
+- [Wikipedia](https://uk.wikipedia.org/wiki/Зв'язаний_список)
- [YouTube](https://www.youtube.com/watch?v=6snsMa4E1Os)
diff --git a/src/data-structures/lru-cache/README.ko-KR.md b/src/data-structures/lru-cache/README.ko-KR.md
new file mode 100644
index 0000000000..93957bc0ed
--- /dev/null
+++ b/src/data-structures/lru-cache/README.ko-KR.md
@@ -0,0 +1,51 @@
+# LRU 캐시 알고리즘
+
+**LRU 캐시 알고리즘** 은 사용된 순서대로 아이템을 정리함으로써, 오랜 시간 동안 사용되지 않은 아이템을 빠르게 찾아낼 수 있도록 한다.
+
+한방향으로만 옷을 걸 수 있는 옷걸이 행거를 생각해봅시다. 가장 오랫동안 입지 않은 옷을 찾기 위해서는, 행거의 반대쪽 끝을 보면 됩니다.
+
+## 문제 정의
+
+LRUCache 클래스를 구현해봅시다:
+
+- `LRUCache(int capacity)` LRU 캐시를 **양수** 의 `capacity` 로 초기화합니다.
+- `int get(int key)` `key` 가 존재할 경우 `key` 값을 반환하고, 그렇지 않으면 `undefined` 를 반환합니다.
+- `void set(int key, int value)` `key` 가 존재할 경우 `key` 값을 업데이트 하고, 그렇지 않으면 `key-value` 쌍을 캐시에 추가합니다. 만약 이 동작으로 인해 키 개수가 `capacity` 를 넘는 경우, 가장 오래된 키 값을 **제거** 합니다.
+
+`get()` 과 `set()` 함수는 무조건 평균 `O(1)` 의 시간 복잡도 내에 실행되어야 합니다.
+
+## 구현
+
+### 버전 1: 더블 링크드 리스트 + 해시맵
+
+[LRUCache.js](./LRUCache.js) 에서 `LRUCache` 구현체 예시를 확인할 수 있습니다. 예시에서는 (평균적으로) 빠른 `O(1)` 캐시 아이템 접근을 위해 `HashMap` 을 사용했고, (평균적으로) 빠른 `O(1)` 캐시 아이템 수정과 제거를 위해 `DoublyLinkedList` 를 사용했습니다. (허용된 최대의 캐시 용량을 유지하기 위해)
+
+
+
+_[okso.app](https://okso.app) 으로 만듦_
+
+LRU 캐시가 어떻게 작동하는지 더 많은 예시로 확인하고 싶다면 LRUCache.test.js](./**test**/LRUCache.test.js) 파일을 참고하세요.
+
+### 버전 2: 정렬된 맵
+
+더블 링크드 리스트로 구현한 첫번째 예시는 어떻게 평균 `O(1)` 시간 복잡도가 `set()` 과 `get()` 으로 나올 수 있는지 학습 목적과 이해를 돕기 위해 좋은 예시입니다.
+
+그러나, 더 쉬운 방법은 자바스크립트의 [Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) 객체를 사용하는 것입니다. 이 `Map` 객체는 키-값 쌍과 키를 **추가하는 순서 원본** 을 지닙니다. 우리는 이걸 아이템을 제거하거나 다시 추가하면서 맵의 "가장 마지막" 동작에서 최근에 사용된 아이템을 유지하기 위해 사용할 수 있습니다. `Map` 의 시작점에 있는 아이템은 캐시 용량이 넘칠 경우 가장 먼저 제거되는 대상입니다. 아이템의 순서는 `map.keys()` 와 같은 `IterableIterator` 을 사용해 확인할 수 있습니다.
+
+해당 구현체는 [LRUCacheOnMap.js](./LRUCacheOnMap.js) 의 `LRUCacheOnMap` 예시에서 확인할 수 있습니다.
+
+이 LRU 캐시 방식이 어떻게 작동하는지 더 많은 테스트 케이스를 확인하고 싶다면 [LRUCacheOnMap.test.js](./__test__/LRUCacheOnMap.test.js) 파일을 참고하세요.
+
+## 복잡도
+
+| | 평균 |
+| --------------- | ------ |
+| 공간 | `O(n)` |
+| 아이템 찾기 | `O(1)` |
+| 아이템 설정하기 | `O(1)` |
+
+## 참조
+
+- [LRU Cache on LeetCode](https://leetcode.com/problems/lru-cache/solutions/244744/lru-cache/)
+- [LRU Cache on InterviewCake](https://www.interviewcake.com/concept/java/lru-cache)
+- [LRU Cache on Wiki](https://en.wikipedia.org/wiki/Cache_replacement_policies)
diff --git a/src/data-structures/lru-cache/README.md b/src/data-structures/lru-cache/README.md
index 05bcc0a0f7..eaa075f809 100644
--- a/src/data-structures/lru-cache/README.md
+++ b/src/data-structures/lru-cache/README.md
@@ -1,5 +1,8 @@
# Least Recently Used (LRU) Cache
+_Read this in other languages:_
+[한국어](README.ko-KR.md),
+
A **Least Recently Used (LRU) Cache** organizes items in order of use, allowing you to quickly identify which item hasn't been used for the longest amount of time.
Picture a clothes rack, where clothes are always hung up on one side. To find the least-recently used item, look at the item on the other end of the rack.
@@ -22,7 +25,7 @@ See the `LRUCache` implementation example in [LRUCache.js](./LRUCache.js). The s
-*Made with [okso.app](https://okso.app)*
+_Made with [okso.app](https://okso.app)_
You may also find more test-case examples of how the LRU Cache works in [LRUCache.test.js](./__test__/LRUCache.test.js) file.
@@ -38,11 +41,11 @@ You may also find more test-case examples of how the LRU Cache works in [LRUCach
## Complexities
-| | Average |
-|---|---|
-| Space |`O(n)`|
-| Get item | `O(1)` |
-| Set item | `O(1)` |
+| | Average |
+| -------- | ------- |
+| Space | `O(n)` |
+| Get item | `O(1)` |
+| Set item | `O(1)` |
## References
diff --git a/src/data-structures/stack/README.uk-UA.md b/src/data-structures/stack/README.uk-UA.md
index 9941114f5b..f71d2274eb 100644
--- a/src/data-structures/stack/README.uk-UA.md
+++ b/src/data-structures/stack/README.uk-UA.md
@@ -10,8 +10,8 @@
Додаткова операція для читання головного елемента (peek) дає доступ
до останнього елементу стека без зміни самого стека.
-Найчастіше принцип роботи стека порівнюють зі чаркою тарілок: щоб узяти другу
-зверху потрібно зняти верхню.
+Найчастіше принцип роботи стека порівнюють із стопкою тарілок: щоб узяти другу
+зверху потрібно спочатку зняти верхню.
Ілюстрація роботи зі стеком.