From d38cecd2e79d64efba1dd0b37cdd9acd60bc42ba Mon Sep 17 00:00:00 2001 From: Coco Guerra Date: Wed, 5 May 2021 22:43:28 -0600 Subject: [PATCH 1/6] Update README.es-ES.md (#704) * Update README.es-ES.md * Update README.es-ES.md --- .../linked-list/README.es-ES.md | 41 +++++++++---------- 1 file changed, 20 insertions(+), 21 deletions(-) diff --git a/src/data-structures/linked-list/README.es-ES.md b/src/data-structures/linked-list/README.es-ES.md index 978e234d..58eb2b86 100644 --- a/src/data-structures/linked-list/README.es-ES.md +++ b/src/data-structures/linked-list/README.es-ES.md @@ -7,27 +7,26 @@ _Lee esto 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 +En ciencias de la computación una **lista enlazada** es una colección linear de elemntos de datos, en los cuales el orden linear no es dado por -su posciòn fisica en memoria. En cambio, cada -elemento señala al siguiente. Es una estructura de datos +su posció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. Bajo la forma mas simple, cada nodo es -compuesto de datos y una referencia (en otras palabras, +una secuencia. Bajo la forma más simple, cada nodo es +compuesto de datos y una referencia (en otras palabras, un lazo) al siguiente nodo en la secuencia. Esta estructura -permite la insercion o remocion de elementos -desde cualquier posicion en la secuencia durante la iteracion. -Variantes mas complejas agregan lazos adicionales, permitiendo -una eficiente insercion o remocion desde referencias arbitrarias +permite la inserción o remoción de elementos +desde cualquier posición en la secuencia durante la iteración. +Variantes más complejas agregan lazos adicionales, permitiendo +una eficiente inserción o remoción desde referencias arbitrarias del elemento. Una desventaja de las listas lazadas es que el tiempo de -acceso es linear (y dificil de canalizar) Un acceso -mas rapido, como un acceso aleatorio, no es factible. Los arreglos +acceso es linear (y difícil de canalizar). Un acceso +más rápido, como un acceso aleatorio, no es factible. Los arreglos tienen una mejor locazion comparados con las listas lazadas. - ![Linked List](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg) -## Pseudocodigo para operacones basicas +## Pseudocódigo para operacones básicas ### Insertar @@ -76,7 +75,7 @@ Contains(head, value) return true end Contains ``` - + ### Borrar ```text @@ -146,19 +145,19 @@ ReverseTraversal(head, tail) end ReverseTraversal ``` -## Complexities +## Complejidades -### Time Complexity +### Complejidad del Tiempo -| Access | Search | Insertion | Deletion | -| :-------: | :-------: | :-------: | :-------: | -| O(n) | O(n) | O(1) | O(n) | +| Access | Search | Insertion | Deletion | +| :----: | :----: | :-------: | :------: | +| O(n) | O(n) | O(1) | O(n) | -### Space Complexity +### Complejidad Espacial O(n) -## References +## Referencias - [Wikipedia](https://en.wikipedia.org/wiki/Linked_list) - [YouTube](https://www.youtube.com/watch?v=njTh_OwMljA&index=2&t=1s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8) From 64abcf12f28e02580b28cc8b64bab5ff0ac9c037 Mon Sep 17 00:00:00 2001 From: Deniz Binay <69312106+denizbinay@users.noreply.github.com> Date: Thu, 6 May 2021 06:46:04 +0200 Subject: [PATCH 2/6] add german translation for main readme (#703) --- README.ar-AR.md | 3 +- README.de-DE.md | 333 ++++++++++++++++++++++++++++++++++++++++++++++++ README.es-ES.md | 3 +- README.fr-FR.md | 3 +- README.id-ID.md | 3 +- README.it-IT.md | 3 +- README.ja-JP.md | 3 +- README.ko-KR.md | 3 +- README.md | 3 +- README.pl-PL.md | 3 +- README.pt-BR.md | 3 +- README.ru-RU.md | 3 +- README.tr-TR.md | 3 +- README.uk-UA.md | 3 +- README.zh-CN.md | 3 +- README.zh-TW.md | 3 +- 16 files changed, 363 insertions(+), 15 deletions(-) create mode 100644 README.de-DE.md diff --git a/README.ar-AR.md b/README.ar-AR.md index 378334fa..797006b6 100644 --- a/README.ar-AR.md +++ b/README.ar-AR.md @@ -21,7 +21,8 @@ _اقرأ هذا في لغات أخرى:_ [_Português_](README.pt-BR.md), [_Русский_](README.ru-RU.md), [_Türk_](README.tr-TR.md), -[_Italiana_](README.it-IT.md) +[_Italiana_](README.it-IT.md), +[_Deutsch_](README.de-DE.md) ☝ ملاحضة هذا المشروع مخصص للاستخدام لأغراض التعلم والبحث فقط ، و ** ليست ** معدة للاستخدام في **الإنتاج** diff --git a/README.de-DE.md b/README.de-DE.md new file mode 100644 index 00000000..3e127c3e --- /dev/null +++ b/README.de-DE.md @@ -0,0 +1,333 @@ +# JavaScript-Algorithmen und Datenstrukturen + +[![CI](https://github.com/trekhleb/javascript-algorithms/workflows/CI/badge.svg)](https://github.com/trekhleb/javascript-algorithms/actions?query=workflow%3ACI+branch%3Amaster) +[![codecov](https://codecov.io/gh/trekhleb/javascript-algorithms/branch/master/graph/badge.svg)](https://codecov.io/gh/trekhleb/javascript-algorithms) + +Dieses Repository enthält JavaScript Beispiele für viele +gängige Algorithmen und Datenstrukturen. + +Jeder Algorithmus und jede Datenstruktur hat eine eigene README +mit zugehörigen Erklärungen und weiterführenden Links (einschließlich zu YouTube-Videos). + +_Lies dies in anderen Sprachen:_ +[_English_](https://github.com/trekhleb/javascript-algorithms/) +[_简体中文_](README.zh-CN.md), +[_繁體中文_](README.zh-TW.md), +[_한국어_](README.ko-KR.md), +[_日本語_](README.ja-JP.md), +[_Polski_](README.pl-PL.md), +[_Français_](README.fr-FR.md), +[_Español_](README.es-ES.md), +[_Português_](README.pt-BR.md), +[_Русский_](README.ru-RU.md), +[_Türk_](README.tr-TR.md), +[_Italiana_](README.it-IT.md), +[_Bahasa Indonesia_](README.id-ID.md), +[_Українська_](README.uk-UA.md), +[_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_ + +## Datenstrukturen + +Eine Datenstruktur ist eine bestimmte Art und Weise, Daten in einem Computer so zu organisieren und zu speichern, dass sie +effizient erreicht und verändert werden können. Genauer gesagt, ist eine Datenstruktur eine Sammlung von Werten, +den Beziehungen zwischen ihnen und den Funktionen oder Operationen, die auf die Daten angewendet werden können. + +`B` - Anfänger:innen, `A` - Fortgeschrittene + +* `B` [Verkettete Liste (Linked List)](src/data-structures/linked-list) +* `B` [Doppelt verkettete Liste (Doubly Linked List)](src/data-structures/doubly-linked-list) +* `B` [Warteschlange (Queue)](src/data-structures/queue) +* `B` [Stapelspeicher (Stack)](src/data-structures/stack) +* `B` [Hashtabelle (Hash Table)](src/data-structures/hash-table) +* `B` [Heap-Algorithmus (Heap)](src/data-structures/heap) - max und min Heap-Versionen +* `B` [Vorrangwarteschlange (Priority Queue)](src/data-structures/priority-queue) +* `A` [Trie (Trie)](src/data-structures/trie) +* `A` [Baum (Tree)](src/data-structures/tree) + * `A` [Binärer Suchbaum (Binary Search Tree)](src/data-structures/tree/binary-search-tree) + * `A` [AVL-Baum (AVL Tree)](src/data-structures/tree/avl-tree) + * `A` [Rot-Schwarz-Baum (Red-Black Tree)](src/data-structures/tree/red-black-tree) + * `A` [Segment-Baum (Segment Tree)](src/data-structures/tree/segment-tree) - mit Min/Max/Summenbereich-Abfrage Beispiel + * `A` [Fenwick Baum (Fenwick Tree)](src/data-structures/tree/fenwick-tree) (Binär indizierter Baum / Binary Indexed Tree) +* `A` [Graph (Graph)](src/data-structures/graph) (sowohl gerichtet als auch ungerichtet) +* `A` [Union-Find-Struktur (Disjoint Set)](src/data-structures/disjoint-set) +* `A` [Bloomfilter (Bloom Filter)](src/data-structures/bloom-filter) + +## Algorithmen + +Ein Algorithmus ist eine eindeutige Spezifikation, wie eine Klasse von Problemen zu lösen ist. Er besteht +aus einem Satz von Regeln, die eine Abfolge von Operationen genau definieren. + +`B` - Anfänger:innen, `A` - Fortgeschrittene + +### Algorithmen nach Thema + +* **Mathe** + * `B` [Bitmanipulation (Bit Manipulation)](src/algorithms/math/bits) - Bits setzen/lesen/aktualisieren/löschen, Multiplikation/Division durch zwei negieren usw.. + * `B` [Faktoriell (Factorial)](src/algorithms/math/factorial) + * `B` [Fibonacci-Zahl (Fibonacci Number)](src/algorithms/math/fibonacci) - Klassische und geschlossene Version + * `B` [Primfaktoren (Prime Factors)](src/algorithms/math/prime-factors) - Auffinden von Primfaktoren und deren Zählung mit Hilfe des Satz von Hardy-Ramanujan (Hardy-Ramanujan's theorem) + * `B` [Primzahl-Test (Primality Test)](src/algorithms/math/primality-test) (Probedivision / trial division method) + * `B` [Euklidischer Algorithmus (Euclidean Algorithm)](src/algorithms/math/euclidean-algorithm) - Berechnen des größten gemeinsamen Teilers (ggT) + * `B` [Kleinstes gemeinsames Vielfaches (Least Common Multiple)](src/algorithms/math/least-common-multiple) (kgV) + * `B` [Sieb des Eratosthenes (Sieve of Eratosthenes)](src/algorithms/math/sieve-of-eratosthenes) - Finden aller Primzahlen bis zu einer bestimmten Grenze + * `B` [Power of two (Is Power of Two)](src/algorithms/math/is-power-of-two) - Prüft, ob die Zahl eine Zweierpotenz ist (naive und bitweise Algorithmen) + * `B` [Pascalsches Dreieck (Pascal's Triangle)](src/algorithms/math/pascal-triangle) + * `B` [Komplexe Zahlen (Complex Number)](src/algorithms/math/complex-number) - Komplexe Zahlen und Grundoperationen mit ihnen + * `B` [Bogenmaß & Grad (Radian & Degree)](src/algorithms/math/radian) - Umrechnung von Bogenmaß in Grad und zurück + * `B` [Fast Powering Algorithmus (Fast Powering)](src/algorithms/math/fast-powering) + * `B` [Horner-Schema (Horner's method)](src/algorithms/math/horner-method) - Polynomauswertung + * `B` [Matrizen (Matrices)](src/algorithms/math/matrix) - Matrizen und grundlegende Matrixoperationen (Multiplikation, Transposition usw.) + * `B` [Euklidischer Abstand (Euclidean Distance)](src/algorithms/math/euclidean-distance) - Abstand zwischen zwei Punkten/Vektoren/Matrizen + * `A` [Ganzzahlige Partitionierung (Integer Partition)](src/algorithms/math/integer-partition) + * `A` [Quadratwurzel (Square Root)](src/algorithms/math/square-root) - Newtonverfahren (Newton's method) + * `A` [Liu Hui π Algorithmus (Liu Hui π Algorithm)](src/algorithms/math/liu-hui) - Näherungsweise π-Berechnungen auf Basis von N-gons + * `A` [Diskrete Fourier-Transformation (Discrete Fourier Transform)](src/algorithms/math/fourier-transform) - Eine Funktion der Zeit (ein Signal) in die Frequenzen zerlegen, aus denen sie sich zusammensetzt +* **Sets** + * `B` [Kartesisches Produkt (Cartesian Product)](src/algorithms/sets/cartesian-product) - Produkt aus mehreren Mengen + * `B` [Fisher-Yates-Verfahren (Fisher–Yates Shuffle)](src/algorithms/sets/fisher-yates) - Zufällige Permutation einer endlichen Folge + * `A` [Potenzmenge (Power Set)](src/algorithms/sets/power-set) - Alle Teilmengen einer Menge (Bitweise und Rücksetzverfahren Lösungen(backtracking solutions)) + * `A` [Permutation (Permutations)](src/algorithms/sets/permutations) (mit und ohne Wiederholungen) + * `A` [Kombination (Combinations)](src/algorithms/sets/combinations) (mit und ohne Wiederholungen) + * `A` [Problem der längsten gemeinsamen Teilsequenz (Longest Common Subsequence)](src/algorithms/sets/longest-common-subsequence) (LCS) + * `A` [Längste gemeinsame Teilsequenz (Longest Increasing Subsequence)](src/algorithms/sets/longest-increasing-subsequence) + * `A` [Der kürzeste gemeinsame String (Shortest Common Supersequence)](src/algorithms/sets/shortest-common-supersequence) (SCS) + * `A` [Rucksackproblem (Knapsack Problem)](src/algorithms/sets/knapsack-problem) - "0/1" und "Ungebunden" + * `A` [Das Maximum-Subarray Problem (Maximum Subarray)](src/algorithms/sets/maximum-subarray) - "Brute-Force-Methode" und "Dynamische Programmierung" (Kadane' Algorithmus) + * `A` [Kombinationssumme (Combination Sum)](src/algorithms/sets/combination-sum) - Alle Kombinationen finden, die eine bestimmte Summe bilden +* **Zeichenketten (Strings)** + * `B` [Hamming-Abstand (Hamming Distance)](src/algorithms/string/hamming-distance) - Anzahl der Positionen, an denen die Symbole unterschiedlich sind + * `A` [Levenshtein-Distanz (Levenshtein Distance)](src/algorithms/string/levenshtein-distance) - Minimaler Editierabstand zwischen zwei Sequenzen + * `A` [Knuth-Morris-Pratt-Algorithmus (Knuth–Morris–Pratt Algorithm)](src/algorithms/string/knuth-morris-pratt) (KMP Algorithmus) - Teilstringsuche (Mustervergleich / Pattern Matching) + * `A` [Z-Algorithmus (Z Algorithm)](src/algorithms/string/z-algorithm) - Teilstringsuche (Mustervergleich / Pattern Matching) + * `A` [Rabin-Karp-Algorithmus (Rabin Karp Algorithm)](src/algorithms/string/rabin-karp) - Teilstringsuche + * `A` [Längstes häufiges Teilzeichenfolgenproblem (Longest Common Substring)](src/algorithms/string/longest-common-substring) + * `A` [Regulärer Ausdruck (Regular Expression Matching)](src/algorithms/string/regular-expression-matching) +* **Suchen** + * `B` [Lineare Suche (Linear Search)](src/algorithms/search/linear-search) + * `B` [Sprungsuche (Jump Search)](src/algorithms/search/jump-search) (oder Blocksuche) - Suche im sortierten Array + * `B` [Binäre Suche (Binary Search)](src/algorithms/search/binary-search) - Suche in einem sortierten Array + * `B` [Interpolationssuche (Interpolation Search)](src/algorithms/search/interpolation-search) - Suche in gleichmäßig verteilt sortiertem Array +* **Sortieren** + * `B` [Bubblesort (Bubble Sort)](src/algorithms/sorting/bubble-sort) + * `B` [Selectionsort (Selection Sort)](src/algorithms/sorting/selection-sort) + * `B` [Einfügesortierenmethode (Insertion Sort)](src/algorithms/sorting/insertion-sort) + * `B` [Haldensortierung (Heap Sort)](src/algorithms/sorting/heap-sort) + * `B` [Mergesort (Merge Sort)](src/algorithms/sorting/merge-sort) + * `B` [Quicksort (Quicksort)](src/algorithms/sorting/quick-sort) - in-place und non-in-place Implementierungen + * `B` [Shellsort (Shellsort)](src/algorithms/sorting/shell-sort) + * `B` [Countingsort (Counting Sort)](src/algorithms/sorting/counting-sort) + * `B` [Fachverteilen (Radix Sort)](src/algorithms/sorting/radix-sort) +* **Verkettete Liste (Linked List)** + * `B` [Gerade Traversierung (Straight Traversal)](src/algorithms/linked-list/traversal) + * `B` [Umgekehrte Traversierung (Reverse Traversal)](src/algorithms/linked-list/reverse-traversal) +* **Bäume** + * `B` [Tiefensuche (Depth-First Search)](src/algorithms/tree/depth-first-search) (DFS) + * `B` [Breitensuche (Breadth-First Search)](src/algorithms/tree/breadth-first-search) (BFS) +* **Graphen** + * `B` [Tiefensuche (Depth-First Search)](src/algorithms/graph/depth-first-search) (DFS) + * `B` [Breitensuche (Breadth-First Search)](src/algorithms/graph/breadth-first-search) (BFS) + * `B` [Algorithmus von Kruskal (Kruskal’s Algorithm)](src/algorithms/graph/kruskal) - Finden des Spannbaum (Minimum Spanning Tree / MST) für einen gewichteten ungerichteten Graphen + * `A` [Dijkstra-Algorithmus (Dijkstra Algorithm)](src/algorithms/graph/dijkstra) - Finden der kürzesten Wege zu allen Knoten des Graphen von einem einzelnen Knotenpunkt aus + * `A` [Bellman-Ford-Algorithmus (Bellman-Ford Algorithm)](src/algorithms/graph/bellman-ford) - Finden der kürzesten Wege zu allen Knoten des Graphen von einem einzelnen Knotenpunkt aus + * `A` [Algorithmus von Floyd und Warshall (Floyd-Warshall Algorithm)](src/algorithms/graph/floyd-warshall) - Die kürzesten Wege zwischen allen Knotenpaaren finden + * `A` [Zykluserkennung (Detect Cycle)](src/algorithms/graph/detect-cycle) - Sowohl für gerichtete als auch für ungerichtete Graphen (DFS- und Disjoint-Set-basierte Versionen) + * `A` [Algorithmus von Prim (Prim’s Algorithm)](src/algorithms/graph/prim) - Finden des Spannbaums (Minimum Spanning Tree / MST) für einen gewichteten ungerichteten Graphen + * `A` [Topologische Sortierung (Topological Sorting)](src/algorithms/graph/topological-sorting) - DFS-Verfahren + * `A` [Artikulationspunkte (Articulation Points)](src/algorithms/graph/articulation-points) - Algorithmus von Tarjan (Tarjan's algorithm) (DFS basiert) + * `A` [Brücke (Bridges)](src/algorithms/graph/bridges) - DFS-basierter Algorithmus + * `A` [Eulerkreisproblem (Eulerian Path and Eulerian Circuit)](src/algorithms/graph/eulerian-path) - Algorithmus von Fleury (Fleury's algorithm) - Jede Kante genau einmal durchlaufen. + * `A` [Hamiltonkreisproblem (Hamiltonian Cycle)](src/algorithms/graph/hamiltonian-cycle) - Jeden Eckpunkt genau einmal durchlaufen. + * `A` [Starke Zusammenhangskomponente (Strongly Connected Components)](src/algorithms/graph/strongly-connected-components) - Kosarajus Algorithmus + * `A` [Problem des Handlungsreisenden (Travelling Salesman Problem)](src/algorithms/graph/travelling-salesman) - Kürzestmögliche Route, die jede Stadt besucht und zur Ausgangsstadt zurückkehrt +* **Kryptographie** + * `B` [Polynomiale Streuwertfunktion(Polynomial Hash)](src/algorithms/cryptography/polynomial-hash) - Rollierende Streuwert-Funktion basierend auf Polynom + * `B` [Schienenzaun Chiffre (Rail Fence Cipher)](src/algorithms/cryptography/rail-fence-cipher) - Ein Transpositionsalgorithmus zur Verschlüsselung von Nachrichten + * `B` [Caesar-Verschlüsselung (Caesar Cipher)](src/algorithms/cryptography/caesar-cipher) - Einfache Substitutions-Chiffre + * `B` [Hill-Chiffre (Hill Cipher)](src/algorithms/cryptography/hill-cipher) - Substitutionschiffre basierend auf linearer Algebra +* **Maschinelles Lernen** + * `B` [Künstliches Neuron (NanoNeuron)](https://github.com/trekhleb/nano-neuron) - 7 einfache JS-Funktionen, die veranschaulichen, wie Maschinen tatsächlich lernen können (Vorwärts-/Rückwärtspropagation) + * `B` [Nächste-Nachbarn-Klassifikation (k-NN)](src/algorithms/ml/knn) - k-nächste-Nachbarn-Algorithmus + * `B` [k-Means (k-Means)](src/algorithms/ml/k-means) - k-Means-Algorithmus +* **Image Processing** + * `B` [Inhaltsabhängige Bildverzerrung (Seam Carving)](src/algorithms/image-processing/seam-carving) - Algorithmus zur inhaltsabhängigen Bildgrößenänderung +* **Unkategorisiert** + * `B` [Türme von Hanoi (Tower of Hanoi)](src/algorithms/uncategorized/hanoi-tower) + * `B` [Rotationsmatrix (Square Matrix Rotation)](src/algorithms/uncategorized/square-matrix-rotation) - In-Place-Algorithmus + * `B` [Jump Game (Jump Game)](src/algorithms/uncategorized/jump-game) - Backtracking, dynamische Programmierung (Top-down + Bottom-up) und gierige Beispiele + * `B` [Eindeutige Pfade (Unique Paths)](src/algorithms/uncategorized/unique-paths) - Backtracking, dynamische Programmierung und Pascalsches Dreieck basierte Beispiele + * `B` [Regenterrassen (Rain Terraces)](src/algorithms/uncategorized/rain-terraces) - Auffangproblem für Regenwasser (trapping rain water problem) (dynamische Programmierung und Brute-Force-Versionen) + * `B` [Rekursive Treppe (Recursive Staircase)](src/algorithms/uncategorized/recursive-staircase) - Zählen der Anzahl der Wege, die nach oben führen (4 Lösungen) + * `B` [Beste Zeit zum Kaufen/Verkaufen von Aktien (Best Time To Buy Sell Stocks)](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - Beispiele für "Teile und Herrsche" und Beispiele für den One-Pass-Algorithmus + * `A` [Damenproblem (N-Queens Problem)](src/algorithms/uncategorized/n-queens) + * `A` [Springerproblem (Knight's Tour)](src/algorithms/uncategorized/knight-tour) + +### Algorithmen nach Paradigma + +Ein algorithmisches Paradigma ist eine generische Methode oder ein Ansatz, der dem Entwurf einer Klasse von Algorithmen zugrunde liegt. Es ist eine Abstraktion, die höher ist als der Begriff des Algorithmus. Genauso wie ein Algorithmus eine Abstraktion ist, die höher ist als ein Computerprogramm. + +* **Brachiale Gewalt (Brute Force)** - schaut sich alle Möglichkeiten an und wählt die beste Lösung aus + * `B` [Lineare Suche (Linear Search)](src/algorithms/search/linear-search) + * `B` [Regenterrassen (Rain Terraces)](src/algorithms/uncategorized/rain-terraces) - Auffangproblem für Regenwasser (trapping rain water problem) (dynamische Programmierung und Brute-Force-Versionen) + * `B` [Rekursive Treppe (Recursive Staircase)](src/algorithms/uncategorized/recursive-staircase) - Zählen der Anzahl der Wege, die nach oben führen (4 Lösungen) + * `A` [Das Maximum-Subarray Problem (Maximum Subarray)](src/algorithms/sets/maximum-subarray) + * `A` [Problem des Handlungsreisenden (Travelling Salesman Problem)](src/algorithms/graph/travelling-salesman) - Kürzestmögliche Route, die jede Stadt besucht und zur Ausgangsstadt zurückkehrt + * `A` [Diskrete Fourier-Transformation (Discrete Fourier Transform)](src/algorithms/math/fourier-transform) - Eine Funktion der Zeit (ein Signal) in die Frequenzen zerlegen, aus denen sie sich zusammensetzt +* **Gierig (Greedy)** - Wählt die beste Option zum aktuellen Zeitpunkt, ohne Rücksicht auf die Zukunft + * `B` [Jump Game (Jump Game)](src/algorithms/uncategorized/jump-game) + * `A` [Rucksackproblem (Unbound Knapsack Problem)](src/algorithms/sets/knapsack-problem) + * `A` [Dijkstra-Algorithmus (Dijkstra Algorithm)](src/algorithms/graph/dijkstra) - Finden der kürzesten Wege zu allen Knoten des Graphen von einem einzelnen Knotenpunkt aus + * `A` [Algorithmus von Prim (Prim’s Algorithm)](src/algorithms/graph/prim) - Finden des Spannbaums (Minimum Spanning Tree / MST) für einen gewichteten ungerichteten Graphen + * `B` [Algorithmus von Kruskal (Kruskal’s Algorithm)](src/algorithms/graph/kruskal) - Finden des Spannbaum (Minimum Spanning Tree / MST) für einen gewichteten ungerichteten Graphen +* **Teile und herrsche** - Das Problem in kleinere Teile aufteilen und diese Teile dann lösen + * `B` [Binäre Suche (Binary Search)](src/algorithms/search/binary-search) + * `B` [Türme von Hanoi (Tower of Hanoi)](src/algorithms/uncategorized/hanoi-tower) + * `B` [Pascalsches Dreieck (Pascal's Triangle)](src/algorithms/math/pascal-triangle) + * `B` [Euklidischer Algorithmus (Euclidean Algorithm)](src/algorithms/math/euclidean-algorithm) - calculate the Greatest Common Divisor (GCD) + * `B` [Mergesort (Merge Sort)](src/algorithms/sorting/merge-sort) + * `B` [Quicksort (Quicksort)](src/algorithms/sorting/quick-sort) + * `B` [Tiefensuche (Depth-First Search)](src/algorithms/tree/depth-first-search) (DFS) + * `B` [Breitensuche (Breadth-First Search)](src/algorithms/graph/depth-first-search) (DFS) + * `B` [Matrizen (Matrices)](src/algorithms/math/matrix) - Matrizen und grundlegende Matrixoperationen (Multiplikation, Transposition usw.) + * `B` [Jump Game (Jump Game)](src/algorithms/uncategorized/jump-game) + * `B` [Fast Powering Algorithmus (Fast Powering)](src/algorithms/math/fast-powering) + * `B` [Beste Zeit zum Kaufen/Verkaufen von Aktien (Best Time To Buy Sell Stocks)](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - Beispiele für "Teile und Herrsche" und Beispiele für den One-Pass-Algorithmus + * `A` [Permutation (Permutations)](src/algorithms/sets/permutations) (mit und ohne Wiederholungen) + * `A` [Kombination (Combinations)](src/algorithms/sets/combinations) (mit und ohne Wiederholungen) +* **Dynamische Programmierung** - Eine Lösung aus zuvor gefundenen Teillösungen aufbauen + * `B` [Fibonacci-Zahl (Fibonacci Number)](src/algorithms/math/fibonacci) + * `B` [Jump Game (Jump Game)](src/algorithms/uncategorized/jump-game) + * `B` [Eindeutige Pfade (Unique Paths)](src/algorithms/uncategorized/unique-paths) + * `B` [Regenterrassen (Rain Terraces)](src/algorithms/uncategorized/rain-terraces) - Auffangproblem für Regenwasser (trapping rain water problem) (dynamische Programmierung und Brute-Force-Versionen) + * `B` [Rekursive Treppe (Recursive Staircase)](src/algorithms/uncategorized/recursive-staircase) - Zählen der Anzahl der Wege, die nach oben führen (4 Lösungen) + * `B` [Inhaltsabhängige Bildverzerrung (Seam Carving)](src/algorithms/image-processing/seam-carving) - Algorithmus zur inhaltsabhängigen Bildgrößenänderung + * `A` [Levenshtein-Distanz (Levenshtein Distance)](src/algorithms/string/levenshtein-distance) - Minimaler Editierabstand zwischen zwei Sequenzen + * `A` [Problem der längsten gemeinsamen Teilsequenz (Longest Common Subsequence)](src/algorithms/sets/longest-common-subsequence) (LCS) + * `A` [Längstes häufiges Teilzeichenfolgenproblem (Longest Common Substring)](src/algorithms/string/longest-common-substring) + * `A` [Längste gemeinsame Teilsequenz (Longest Increasing Subsequence)](src/algorithms/sets/longest-increasing-subsequence) + * `A` [Der kürzeste gemeinsame String (Shortest Common Supersequence)](src/algorithms/sets/shortest-common-supersequence) + * `A` [Rucksackproblem (0/1 Knapsack Problem)](src/algorithms/sets/knapsack-problem) + * `A` [Ganzzahlige Partitionierung (Integer Partition)](src/algorithms/math/integer-partition) + * `A` [Das Maximum-Subarray Problem (Maximum Subarray)](src/algorithms/sets/maximum-subarray) + * `A` [Bellman-Ford-Algorithmus (Bellman-Ford Algorithm)](src/algorithms/graph/bellman-ford) - Finden der kürzesten Wege zu allen Knoten des Graphen von einem einzelnen Knotenpunkt aus + * `A` [Algorithmus von Floyd und Warshall (Floyd-Warshall Algorithm)](src/algorithms/graph/floyd-warshall) - Die kürzesten Wege zwischen allen Knotenpaaren finden + * `A` [Regulärer Ausdruck (Regular Expression Matching)](src/algorithms/string/regular-expression-matching) +* **Zurückverfolgung** - Ähnlich wie bei Brute-Force versuchen Sie, alle möglichen Lösungen zu generieren, aber jedes Mal, wenn Sie die nächste Lösung generieren, testen Sie, ob sie alle Bedingungen erfüllt, und fahren erst dann mit der Generierung weiterer Lösungen fort. Andernfalls gehen Sie zurück und nehmen einen anderen Weg, um eine Lösung zu finden. Normalerweise wird das DFS-Traversal des Zustandsraums verwendet. + * `B` [Jump Game (Jump Game)](src/algorithms/uncategorized/jump-game) + * `B` [Eindeutige Pfade (Unique Paths)](src/algorithms/uncategorized/unique-paths) + * `A` [Potenzmenge (Power Set)](src/algorithms/sets/power-set) - Alle Teilmengen einer Menge + * `A` [Hamiltonkreisproblem (Hamiltonian Cycle)](src/algorithms/graph/hamiltonian-cycle) - Jeden Eckpunkt genau einmal durchlaufen. + * `A` [Damenproblem (N-Queens Problem)](src/algorithms/uncategorized/n-queens) + * `A` [Springerproblem (Knight's Tour)](src/algorithms/uncategorized/knight-tour) + * `A` [Kombinationssumme (Combination Sum)](src/algorithms/sets/combination-sum) - Alle Kombinationen finden, die eine bestimmte Summe bilden +* **Verzweigung & Bindung** - Merkt sich die Lösung mit den niedrigsten Kosten, die in jeder Phase der Backtracking-Suche gefunden wurde, und verwendet die Kosten der bisher gefundenen Lösung mit den niedrigsten Kosten als untere Schranke für die Kosten einer Lösung des Problems mit den geringsten Kosten, um Teillösungen zu verwerfen, deren Kosten größer sind als die der bisher gefundenen Lösung mit den niedrigsten Kosten. Normalerweise wird das BFS-Traversal in Kombination mit dem DFS-Traversal des Zustandsraumbaums verwendet. + +## So verwendest du dieses Repository + +**Alle Abhängigkeiten installieren** + +``` +npm install +``` + +**ESLint ausführen** + +You may want to run it to check code quality. + +``` +npm run lint +``` + +**Alle Tests ausführen** + +``` +npm test +``` + +**Tests nach Namen ausführen** + +``` +npm test -- 'LinkedList' +``` + +**Fehlerbehebung** + +Falls das Linting oder Testen fehlschlägt, versuche, den Ordner "node_modules" zu löschen und die npm-Pakete neu zu installieren: + +``` +rm -rf ./node_modules +npm i +``` + +**Spielwiese** + +Du kannst mit Datenstrukturen und Algorithmen in der Datei `./src/playground/playground.js` herumspielen und +dir in dieser Datei Tests schreiben `./src/playground/__test__/playground.test.js`. + +Dann führe einfach folgenden Befehl aus, um zu testen, ob dein Spielwiesencode wie erwartet funktioniert: + +``` +npm test -- 'playground' +``` + +## Nützliche Informationen + +### Referenzen + +[▶ Datenstrukturen und Algorithmen auf YouTube(Englisch)](https://www.youtube.com/playlist?list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8) + +### O-Notation (_Big O Notation_) + +Die O-Notation wird verwendet, um Algorithmen danach zu klassifizieren, wie ihre Laufzeit oder ihr Platzbedarf mit zunehmender Eingabegröße wächst. In der folgenden Tabelle finden Sie die häufigsten Wachstumsordnungen von Algorithmen, die in Big-O-Notation angegeben sind. + +![O-Notation Graphen](./assets/big-o-graph.png) + +Quelle: [Big O Cheat Sheet](http://bigocheatsheet.com/). + +Nachfolgend finden Sie eine Liste einiger der am häufigsten verwendeten Big O-Notationen und deren Leistungsvergleiche für unterschiedliche Größen der Eingabedaten. + +| Big O Notation | Berechnungen für 10 Elemente | Berechnungen für 100 Elemente | Berechnungen für 1000 Elemente | +| -------------- | ---------------------------- | ----------------------------- | ------------------------------ | +| **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 | + +### Komplexität von Datenstrukturoperationen + +| Datenstruktur | Zugriff auf | Suche | Einfügen | Löschung | Kommentare | +| ---------------------- | :---------: | :----: | :------: | :------: | :-------------------------------------------------------------- | +| **Array** | 1 | n | n | n | | +| **Stack** | n | n | 1 | 1 | | +| **Queue** | n | n | 1 | 1 | | +| **Linked List** | n | n | 1 | n | | +| **Hash Table** | - | n | n | n | Im Falle einer perfekten Hash-Funktion wären die Kosten O(1) | +| **Binary Search Tree** | n | n | n | n | Im Falle eines ausgeglichenen Baumes wären die Kosten O(log(n)) | +| **B-Tree** | log(n) | log(n) | log(n) | log(n) | | +| **Red-Black Tree** | log(n) | log(n) | log(n) | log(n) | | +| **AVL Tree** | log(n) | log(n) | log(n) | log(n) | | +| **Bloom Filter** | - | 1 | 1 | - | Falschpostive sind bei der Suche möglichen | + +### Komplexität von Array-Sortieralgorithmen + +| Name | Bester | Durchschnitt | Schlechtester | Speicher | Stabil | Kommentar | +| ------------------ | :-----------: | :---------------------: | :-------------------------: | :------: | :----: | :------------------------------------------------------------------------- | +| **Bubble sort** | n | n2 | n2 | 1 | JA | | +| **Insertion sort** | n | n2 | n2 | 1 | Ja | | +| **Selection sort** | n2 | n2 | n2 | 1 | Nein | | +| **Heap sort** | n log(n) | n log(n) | n log(n) | 1 | Nein | | +| **Merge sort** | n log(n) | n log(n) | n log(n) | n | Ja | | +| **Quick sort** | n log(n) | n log(n) | n2 | log(n) | Nein | Quicksort wird normalerweise in-place mit O(log(n)) Stapelplatz ausgeführt | +| **Shell sort** | n log(n) | abhängig von Spaltfolge | n (log(n))2 | 1 | Nein | | +| **Counting sort** | n + r | n + r | n + r | n + r | Ja | r - größte Zahl im Array | +| **Radix sort** | n \* k | n \* k | n \* k | n + k | Ja | k - Länge des längsten Schlüssels | + +## Projekt-Unterstützer + +> Du kannst dieses Projekt unterstützen über ❤️️ [GitHub](https://github.com/sponsors/trekhleb) or ❤️️ [Patreon](https://www.patreon.com/trekhleb). + +[Leute, die dieses Projekt unterstützen](https://github.com/trekhleb/javascript-algorithms/blob/master/BACKERS.md) `∑ = 0` diff --git a/README.es-ES.md b/README.es-ES.md index fa1fd340..f350ee05 100644 --- a/README.es-ES.md +++ b/README.es-ES.md @@ -23,7 +23,8 @@ _Léelo en otros idiomas:_ [_Italiana_](README.it-IT.md), [_Bahasa Indonesia_](README.id-ID.md), [_Українська_](README.uk-UA.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.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.* diff --git a/README.fr-FR.md b/README.fr-FR.md index 024a3b19..4508340a 100644 --- a/README.fr-FR.md +++ b/README.fr-FR.md @@ -24,7 +24,8 @@ _Lisez ceci dans d'autres langues:_ [_Italiana_](README.it-IT.md), [_Bahasa Indonesia_](README.id-ID.md), [_Українська_](README.uk-UA.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.md), +[_Deutsch_](README.de-DE.md) ## Data Structures diff --git a/README.id-ID.md b/README.id-ID.md index 2a258f97..2f5212ac 100644 --- a/README.id-ID.md +++ b/README.id-ID.md @@ -21,7 +21,8 @@ _Baca ini dalam bahasa yang lain:_ [_Türk_](README.tr-TR.md), [_Italiana_](README.it-IT.md), [_Українська_](README.uk-UA.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.md), +[_Deutsch_](README.de-DE.md) _☝ Perhatikan bahwa proyek ini hanya dimaksudkan untuk tujuan pembelajaran dan riset, dan **tidak** dimaksudkan untuk digunakan sebagai produksi._ diff --git a/README.it-IT.md b/README.it-IT.md index 9d8c664f..d74befd6 100644 --- a/README.it-IT.md +++ b/README.it-IT.md @@ -20,7 +20,8 @@ _Leggilo in altre lingue:_ [_Türk_](README.tr-TR.md), [_Bahasa Indonesia_](README.id-ID.md), [_Українська_](README.uk-UA.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.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.* diff --git a/README.ja-JP.md b/README.ja-JP.md index af2c887c..a1c13211 100644 --- a/README.ja-JP.md +++ b/README.ja-JP.md @@ -23,7 +23,8 @@ _Read this in other languages:_ [_Italiana_](README.it-IT.md), [_Bahasa Indonesia_](README.id-ID.md), [_Українська_](README.uk-UA.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.md), +[_Deutsch_](README.de-DE.md) ## データ構造 diff --git a/README.ko-KR.md b/README.ko-KR.md index 02f35d02..e9b77dca 100644 --- a/README.ko-KR.md +++ b/README.ko-KR.md @@ -22,7 +22,8 @@ _Read this in other languages:_ [_Italiana_](README.it-IT.md), [_Bahasa Indonesia_](README.id-ID.md), [_Українська_](README.uk-UA.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.md), +[_Deutsch_](README.de-DE.md) ## 자료 구조 diff --git a/README.md b/README.md index a9fc7b5e..d16c264d 100644 --- a/README.md +++ b/README.md @@ -24,7 +24,8 @@ _Read this in other languages:_ [_Italiana_](README.it-IT.md), [_Bahasa Indonesia_](README.id-ID.md), [_Українська_](README.uk-UA.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.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.* diff --git a/README.pl-PL.md b/README.pl-PL.md index 08dc09b6..235d0d47 100644 --- a/README.pl-PL.md +++ b/README.pl-PL.md @@ -24,7 +24,8 @@ _Read this in other languages:_ [_Italiana_](README.it-IT.md), [_Bahasa Indonesia_](README.id-ID.md), [_Українська_](README.uk-UA.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.md), +[_Deutsch_](README.de-DE.md) ## Struktury Danych diff --git a/README.pt-BR.md b/README.pt-BR.md index baffbc31..c410fda6 100644 --- a/README.pt-BR.md +++ b/README.pt-BR.md @@ -24,7 +24,8 @@ _Leia isto em outros idiomas:_ [_Italiana_](README.it-IT.md), [_Bahasa Indonesia_](README.id-ID.md), [_Українська_](README.uk-UA.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.md), +[_Deutsch_](README.de-DE.md) ## Estrutura de Dados diff --git a/README.ru-RU.md b/README.ru-RU.md index 32f4b2f5..ef9e9444 100644 --- a/README.ru-RU.md +++ b/README.ru-RU.md @@ -21,7 +21,8 @@ _Читать на других языках:_ [_Italiana_](README.it-IT.md), [_Bahasa Indonesia_](README.id-ID.md), [_Українська_](README.uk-UA.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.md), +[_Deutsch_](README.de-DE.md) *☝ Замечание: этот репозиторий предназначен для учебно-исследовательских целей (**не** для использования в продакшн-системах).* diff --git a/README.tr-TR.md b/README.tr-TR.md index f7ed57fc..fff640c4 100644 --- a/README.tr-TR.md +++ b/README.tr-TR.md @@ -22,7 +22,8 @@ _Read this in other languages:_ [_Italiana_](README.it-IT.md), [_Bahasa Indonesia_](README.id-ID.md), [_Українська_](README.uk-UA.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.md), +[_Deutsch_](README.de-DE.md) *☝ Not, bu proje araştırma ve öğrenme amacı ile yapılmış olup üretim için **yaplılmamıştır**.* diff --git a/README.uk-UA.md b/README.uk-UA.md index 4391ed19..6fdd7b4c 100644 --- a/README.uk-UA.md +++ b/README.uk-UA.md @@ -21,7 +21,8 @@ _Вивчення матеріалу на інших мовах:_ [_Türk_](README.tr-TR.md), [_Italiana_](README.it-IT.md), [_Bahasa Indonesia_](README.id-ID.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.md), +[_Deutsch_](README.de-DE.md) *☝ Зверніть увагу! Даний проект призначений лише для навчальних та дослідницьких цілей, і він **не** призначений для виробництва (продакшн).* diff --git a/README.zh-CN.md b/README.zh-CN.md index 35a3733f..22b50d40 100644 --- a/README.zh-CN.md +++ b/README.zh-CN.md @@ -21,7 +21,8 @@ _Read this in other languages:_ [_Italiana_](README.it-IT.md), [_Bahasa Indonesia_](README.id-ID.md), [_Українська_](README.uk-UA.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.md), +[_Deutsch_](README.de-DE.md) *注意：这个项目仅用于学习和研究，**不是**用于生产环境。* diff --git a/README.zh-TW.md b/README.zh-TW.md index 4a09b843..bf90fbbe 100644 --- a/README.zh-TW.md +++ b/README.zh-TW.md @@ -20,7 +20,8 @@ _Read this in other languages:_ [_Italiana_](README.it-IT.md), [_Bahasa Indonesia_](README.id-ID.md), [_Українська_](README.uk-UA.md), -[_Arabic_](README.ar-AR.md) +[_Arabic_](README.ar-AR.md), +[_Deutsch_](README.de-DE.md) ## 資料結構 From 464a84bc7cb8fcc9c78ccb9fab0d77d978e8363c Mon Sep 17 00:00:00 2001 From: justforever Date: Thu, 6 May 2021 12:56:40 +0800 Subject: [PATCH 3/6] Update README.zh-TW.md (#690) --- README.zh-TW.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.zh-TW.md b/README.zh-TW.md index bf90fbbe..ddf043d7 100644 --- a/README.zh-TW.md +++ b/README.zh-TW.md @@ -215,7 +215,7 @@ npm test -- 'playground' | 名稱 | 最佳 | 平均 | 最差 | 記憶體 | 穩定 | | ---------------------- | :-------: | :-------: | :-----------: | :-------: | :-------: | -| **氣派排序** | n | n^2 | n^2 | 1 | Yes | +| **氣泡排序** | n | n^2 | n^2 | 1 | Yes | | **插入排序** | n | n^2 | n^2 | 1 | Yes | | **選擇排序** | n^2 | n^2 | n^2 | 1 | No | | **Heap 排序** | n log(n) | n log(n) | n log(n) | 1 | No | From 5ffab573ca4610c3ea6bd00709883b0a2ec5b898 Mon Sep 17 00:00:00 2001 From: Freivin Campbell Date: Wed, 5 May 2021 23:00:10 -0600 Subject: [PATCH 4/6] Create README.es-ES.md (#680) new translation added --- .../doubly-linked-list/README.es-ES.md | 102 ++++++++++++++++++ 1 file changed, 102 insertions(+) create mode 100644 src/data-structures/doubly-linked-list/README.es-ES.md diff --git a/src/data-structures/doubly-linked-list/README.es-ES.md b/src/data-structures/doubly-linked-list/README.es-ES.md new file mode 100644 index 00000000..0736d499 --- /dev/null +++ b/src/data-structures/doubly-linked-list/README.es-ES.md @@ -0,0 +1,102 @@ +# Lista doblemente enlazada + +_Lea esto en otros idiomas:_ +[_Русский_](README.ru-RU.md), +[_简体中文_](README.zh-CN.md), +[_日本語_](README.ja-JP.md), +[_Português_](README.pt-BR.md) +[_한국어_](README.ko-KR.md) + +En informática, una **lista doblemente enlazada** es una estructura de datos enlazados que consta de un conjunto de registros enlazados secuencialmente llamados nodos. Cada nodo contiene dos campos, llamados enlaces, que son referencias al nodo anterior y al siguiente en la secuencia de nodos. Los enlaces anterior y siguiente de los nodos inicial y final, respectivamente, apuntan a algún tipo de terminador, normalmente un nodo centinela o nulo, para facilitar el recorrido de la lista. Si solo hay un ganglio centinela, la lista se enlaza circularmente a través del ganglio centinela. Puede conceptualizarse como dos listas enlazadas individualmente formadas a partir de los mismos elementos de datos, pero en órdenes secuenciales opuestos. + +![Lista doblemente enlazada](https://upload.wikimedia.org/wikipedia/commons/5/5e/Doubly-linked-list.svg) + +Los dos enlaces de nodo permiten recorrer la lista en cualquier dirección. Si bien agregar o eliminar un nodo en una lista doblemente enlazada requiere cambiar más enlaces que las mismas operaciones en una lista enlazada individualmente, las operaciones son más simples y potencialmente más eficientes (para nodos que no sean los primeros) porque no hay necesidad de realizar un seguimiento de el nodo anterior durante el recorrido o no es necesario recorrer la lista para encontrar el nodo anterior, de modo que se pueda modificar su enlace. + +## Pseudocódigo para operaciones básicas + +### Insertar + +```text +Add(value) + Pre: value is the value to add to the list + Post: value has been placed at the tail of the list + n ← node(value) + if head = ø + head ← n + tail ← n + else + n.previous ← tail + tail.next ← n + tail ← n + end if +end Add +``` + +### Eliminar + +```text +Remove(head, value) + Pre: head is the head node in the list + value is the value to remove from the list + Post: value is removed from the list, true; otherwise false + if head = ø + return false + end if + if value = head.value + if head = tail + head ← ø + tail ← ø + else + head ← head.next + head.previous ← ø + end if + return true + end if + n ← head.next + while n != ø and value !== n.value + n ← n.next + end while + if n = tail + tail ← tail.previous + tail.next ← ø + return true + else if n != ø + n.previous.next ← n.next + n.next.previous ← n.previous + return true + end if + return false +end Remove +``` + +### Recorrido Inverso + +```text +ReverseTraversal(tail) + Pre: tail is the node of the list to traverse + Post: the list has been traversed in reverse order + n ← tail + while n != ø + yield n.value + n ← n.previous + end while +end Reverse Traversal +``` + +## Complejidades + +## Complejidad del Tiempo + +| Acceso | Busqueda | Inserción | Supresión | +| :-------: | :-------: | :-------: | :-------: | +| O(n) | O(n) | O(1) | O(n) | + +### Complejidad del Espacio + +O(n) + +## Referencias + +- [Wikipedia](https://en.wikipedia.org/wiki/Doubly_linked_list) +- [YouTube](https://www.youtube.com/watch?v=JdQeNxWCguQ&t=7s&index=72&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8) From 22b323e6b112a85210369f48bf9044d9fa9c6371 Mon Sep 17 00:00:00 2001 From: CodingInvoker <71058225+CodingInvoker@users.noreply.github.com> Date: Thu, 6 May 2021 13:02:52 +0800 Subject: [PATCH 5/6] update linkedlist comment (#687) Co-authored-by: Jiachen Zhou Co-authored-by: Oleksii Trekhleb --- src/data-structures/linked-list/LinkedList.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/data-structures/linked-list/LinkedList.js b/src/data-structures/linked-list/LinkedList.js index 1fb0b5ea..71c2b497 100644 --- a/src/data-structures/linked-list/LinkedList.js +++ b/src/data-structures/linked-list/LinkedList.js @@ -65,7 +65,7 @@ export default class LinkedList { let deletedNode = null; - // If the head must be deleted then make next node that is differ + // If the head must be deleted then make next node that is different // from the head to be a new head. while (this.head && this.compare.equal(this.head.value, value)) { deletedNode = this.head; From cb50e4e9f394ebaf8172f71bc31dd2f68b1417d4 Mon Sep 17 00:00:00 2001 From: Oleksii Trekhleb Date: Thu, 6 May 2021 07:05:27 +0200 Subject: [PATCH 6/6] Add link to Spanish translation in Doubly-Linked list README. --- .../doubly-linked-list/README.md | 37 ++++++++++--------- 1 file changed, 19 insertions(+), 18 deletions(-) diff --git a/src/data-structures/doubly-linked-list/README.md b/src/data-structures/doubly-linked-list/README.md index c64b5126..703520aa 100644 --- a/src/data-structures/doubly-linked-list/README.md +++ b/src/data-structures/doubly-linked-list/README.md @@ -4,26 +4,27 @@ _Read this in other languages:_ [_Русский_](README.ru-RU.md), [_简体中文_](README.zh-CN.md), [_日本語_](README.ja-JP.md), -[_Português_](README.pt-BR.md) -[_한국어_](README.ko-KR.md) +[_Português_](README.pt-BR.md), +[_한국어_](README.ko-KR.md), +[_Español_](README.es-ES.md), -In computer science, a **doubly linked list** is a linked data structure that -consists of a set of sequentially linked records called nodes. Each node contains -two fields, called links, that are references to the previous and to the next -node in the sequence of nodes. The beginning and ending nodes' previous and next -links, respectively, point to some kind of terminator, typically a sentinel -node or null, to facilitate the traversal of the list. If there is only one -sentinel node, then the list is circularly linked via the sentinel node. It can -be conceptualized as two singly linked lists formed from the same data items, +In computer science, a **doubly linked list** is a linked data structure that +consists of a set of sequentially linked records called nodes. Each node contains +two fields, called links, that are references to the previous and to the next +node in the sequence of nodes. The beginning and ending nodes' previous and next +links, respectively, point to some kind of terminator, typically a sentinel +node or null, to facilitate the traversal of the list. If there is only one +sentinel node, then the list is circularly linked via the sentinel node. It can +be conceptualized as two singly linked lists formed from the same data items, but in opposite sequential orders. ![Doubly Linked List](https://upload.wikimedia.org/wikipedia/commons/5/5e/Doubly-linked-list.svg) -The two node links allow traversal of the list in either direction. While adding -or removing a node in a doubly linked list requires changing more links than the -same operations on a singly linked list, the operations are simpler and -potentially more efficient (for nodes other than first nodes) because there -is no need to keep track of the previous node during traversal or no need +The two node links allow traversal of the list in either direction. While adding +or removing a node in a doubly linked list requires changing more links than the +same operations on a singly linked list, the operations are simpler and +potentially more efficient (for nodes other than first nodes) because there +is no need to keep track of the previous node during traversal or no need to traverse the list to find the previous node, so that its link can be modified. ## Pseudocode for Basic Operations @@ -45,7 +46,7 @@ Add(value) end if end Add ``` - + ### Delete ```text @@ -82,7 +83,7 @@ Remove(head, value) return false end Remove ``` - + ### Reverse Traversal ```text @@ -96,7 +97,7 @@ ReverseTraversal(tail) end while end Reverse Traversal ``` - + ## Complexities ## Time Complexity