Düğüm dili: rehber

The Düğüm language: a guide

Die Sprache Düğüm: ein Leitfaden

Bu sitedeki kodlar Düğüm adında küçük bir dille yazılır. Düğüm, veri yapılarını öğretmek için tasarlanmış, JavaScript'e benzeyen bir dildir: her satırı tek tek çalıştırılır ve her satırın veri yapısında ne değiştirdiği tuvalde çizilir. Adı, dilin temel taşı olan düğümden (node) gelir; Türkçede düğüm aynı zamanda iki ipin birbirine bağlandığı yerdir, tıpkı next bağlarının düğümleri birbirine bağlaması gibi.

The code on this site is written in a small language called Düğüm. Düğüm is a JavaScript-like language made for teaching data structures: it runs one line at a time, and what each line changes in the data structure is drawn on the canvas. The name is Turkish for node, the building block of the language; it also means knot, the place where two ropes are tied together, just as next links tie nodes together.

Der Code auf dieser Seite ist in einer kleinen Sprache namens Düğüm geschrieben. Düğüm ist eine JavaScript-ähnliche Sprache zum Lehren von Datenstrukturen: sie führt eine Zeile nach der anderen aus, und was jede Zeile an der Datenstruktur ändert, wird auf der Zeichenfläche gezeichnet. Der Name ist das türkische Wort für Knoten (node), den Grundbaustein der Sprache; er bedeutet auch den Knoten in einem Seil, dort wo zwei Seile verbunden sind, so wie next-Verbindungen Knoten verbinden.

JavaScript bilen biri Düğüm kodunu hemen okur; yine de dil bilerek küçük tutuldu: her satırda tek bir komut vardır, nesneler yerine düğümler ve basit diziler vardır. Böylece öğrenci dile değil, veri yapısına odaklanır. Kodu her sayfada değiştirip yeniden çalıştırabilirsiniz; bu sayfanın blokları da çalışır.

Anyone who knows JavaScript can read Düğüm code right away; still, the language is kept small on purpose: one statement per line, and nodes and simple arrays instead of objects. That way students focus on the data structure, not on the language. You can change and rerun the code on every page; the blocks on this page run too.

Wer JavaScript kennt, kann Düğüm-Code sofort lesen; trotzdem ist die Sprache absichtlich klein gehalten: eine Anweisung pro Zeile, und Knoten und einfache Arrays statt Objekten. So konzentrieren sich Lernende auf die Datenstruktur, nicht auf die Sprache. Sie können den Code auf jeder Seite ändern und erneut ausführen; auch die Blöcke dieser Seite laufen.

Kısa özet

Quick reference

Kurzübersicht

Değişkenler ve sayılar

Variables and numbers

Variablen und Zahlen

Değişkenler var ile tanımlanır (virgülle birkaç tane birden: var a = 1, b = 2); sonra var olmadan yeni değer alabilir. Sayılarla + - * / % işlemleri yapılır, n++, n--, n += 2 de olur. Doğru/yanlış değerleri true / false (ya da doğru / yanlış) ile yazılır. Metin (string) yalnızca print içinde kullanılır; parçalar + ile birleştirilir. Matematik için taban (aşağı yuvarlama), tavan (yukarı yuvarlama), karekök ve mutlak fonksiyonları vardır. Değişkenler panelinde her değişkenin değeri görünür.

Variables are declared with var (several at once with commas: var a = 1, b = 2); afterwards they take new values without var. Numbers support + - * / %, and n++, n--, n += 2. True/false values are written true / false (or doğru / yanlış). Text (strings) is used only in print; the parts are joined with +. For math there are taban (round down), tavan (round up), karekök (square root) and mutlak (absolute value). The Variables panel shows the value of every variable.

Variablen werden mit var deklariert (mehrere auf einmal mit Kommas: var a = 1, b = 2); danach bekommen sie ohne var neue Werte. Zahlen kennen + - * / % sowie n++, n--, n += 2. Wahrheitswerte schreibt man true / false (oder doğru / yanlış). Text (Strings) gibt es nur in print; die Teile werden mit + verbunden. Für Mathematik gibt es taban (abrunden), tavan (aufrunden), karekök (Quadratwurzel) und mutlak (Betrag). Das Feld Variablen zeigt den Wert jeder Variable.

Düğümler ve bağlar

Nodes and links

Knoten und Verbindungen

new Node(değer) yeni bir düğüm oluşturur (new yazılmasa da olur); değer bir ifade de olabilir. İkinci bir değer verilirse yeni düğümün next'i olur: head = new Node(0, head) başa ekler, new Node(1, new Node(2, new Node(3))) üç düğümlü bir listeyi tek satırda kurar. Her düğümün data (değer) ve next (sonraki düğüm) alanları vardır; next başta null'dır. Bir değişken düğümün kendisini değil, onu gösteren bir pointer'ı tutar: p = x yeni bir düğüm oluşturmaz, iki değişken aynı düğümü gösterir. Alanlar zincirlenebilir: x.next.next.data. delete bir düğümü siler; ona hâlâ ulaşan bir bağ ya da pointer kalmamasına dikkat etmek programcının işidir. Artık hiçbir yerden ulaşılamayan düğümler soluk çizilir ve uyarı verilir.

new Node(value) makes a new node (new may be left out); the value can be an expression. A second value becomes the new node's next: head = new Node(0, head) inserts at the head, and new Node(1, new Node(2, new Node(3))) builds a list of three nodes in one line. Every node has the fields data (its value) and next (the next node); next starts as null. A variable does not hold the node itself but a pointer to it: p = x makes no new node, the two variables point to the same node. Fields can be chained: x.next.next.data. delete deletes a node; making sure that no link or pointer still leads to it is the programmer's job. Nodes that nothing reaches any more are drawn faded, with a warning.

new Node(Wert) erzeugt einen neuen Knoten (new darf fehlen); der Wert kann ein Ausdruck sein. Ein zweiter Wert wird das next des neuen Knotens: head = new Node(0, head) fügt am Anfang ein, und new Node(1, new Node(2, new Node(3))) baut eine Liste aus drei Knoten in einer Zeile. Jeder Knoten hat die Felder data (sein Wert) und next (der nächste Knoten); next ist anfangs null. Eine Variable enthält nicht den Knoten selbst, sondern einen Zeiger auf ihn: p = x erzeugt keinen neuen Knoten, beide Variablen zeigen auf denselben Knoten. Felder lassen sich verketten: x.next.next.data. delete löscht einen Knoten; dafür zu sorgen, dass keine Verbindung und kein Zeiger mehr zu ihm führt, ist Aufgabe des Programmierers. Knoten, die nichts mehr erreicht, werden blass gezeichnet, mit einer Warnung.

Koşullar ve döngüler

Conditions and loops

Bedingungen und Schleifen

if / else, while ve for JavaScript'teki gibidir; gövde tek satırsa süslü parantez gerekmez. Karşılaştırmalar == != < <= > >=, birleştirmeler &&, ||, ! (ya da and, or, not) ile yazılır. Bir pointer tek başına da koşul olabilir: while(p), p != null demektir. Her koşulun doğru mu yanlış mı çıktığı editörde yeşil ya da kırmızıyla işaretlenir. Sonsuz döngüye karşı bir döngü en fazla 1000 tur döner.

if / else, while and for work as in JavaScript; a one-line body needs no braces. Comparisons are written == != < <= > >=, combinations &&, ||, ! (or and, or, not). A pointer on its own can be a condition: while(p) means p != null. Whether each condition is true or false is marked green or red in the editor. To stop endless loops, a loop runs at most 1000 rounds.

if / else, while und for funktionieren wie in JavaScript; ein einzeiliger Rumpf braucht keine geschweiften Klammern. Vergleiche schreibt man == != < <= > >=, Verknüpfungen &&, ||, ! (oder and, or, not). Ein Zeiger allein kann eine Bedingung sein: while(p) bedeutet p != null. Ob eine Bedingung wahr oder falsch ist, wird im Editor grün oder rot markiert. Gegen Endlosschleifen läuft eine Schleife höchstens 1000 Runden.

Fonksiyonlar

Functions

Funktionen

function ile tanımlanan fonksiyonlar parametre alır ve return ile değer döndürür; tanımından önce de çağrılabilir. Fonksiyonun kendi yerel değişkenleri vardır ve global değişkenleri görür. Her çağrı Çağrı yığını panelinde yerel değişkenleriyle görünür; özyinelemede derin çağrıların pointer'ları p₂, p₃ diye adlandırılır. Sonsuz özyinelemeye karşı en fazla 200 çağrı iç içe girebilir. Çağrı bir ifadenin içinde de olur: 1 + count(p.next), t.left = insert(t.left, v).

Functions are defined with function, take parameters and give back a value with return; they can be called before the line that defines them. A function has its own local variables and sees the global ones. Every call appears in the Call stack panel with its locals; in a recursion the pointers of deeper calls are named p₂, p₃. To stop endless recursion, at most 200 calls can be nested. A call can be part of an expression: 1 + count(p.next), t.left = insert(t.left, v).

Funktionen werden mit function definiert, nehmen Parameter und geben mit return einen Wert zurück; man kann sie schon vor der Zeile aufrufen, die sie definiert. Eine Funktion hat eigene lokale Variablen und sieht die globalen. Jeder Aufruf erscheint im Aufrufstapel mit seinen lokalen Variablen; bei einer Rekursion heißen die Zeiger tieferer Aufrufe p₂, p₃. Gegen endlose Rekursion können höchstens 200 Aufrufe verschachtelt sein. Ein Aufruf kann Teil eines Ausdrucks sein: 1 + count(p.next), t.left = insert(t.left, v).

Türkçe anahtar kelimeler

Turkish keywords

Türkische Schlüsselwörter

Programlamaya ana dilinde başlamak isteyenler için Düğüm'ün Türkçe bir yazımı da var. Ayarlarda kod dili olarak Düğüm (Türkçe) seçilirse bütün örnekler Türkçe kelimelerle gösterilir ve öyle çalışır: değişken (var), eğer (if), değilse (else), yinele (while), için (for), fonksiyon (function), döndür (return), kır (break), devam (continue), yaz (print), boş (null), doğru / yanlış (true / false), yeni Düğüm(…) (new Node), yeni Dizi(n) (new Array), sil (delete), ve / veya / değil (and / or / not); alanlar da .veri, .sonraki, .önceki, .sol, .sağ, .yükseklik. Anlatım ve değişkenler paneli de aynı kelimeleri kullanır. eğer, değilse, yinele, fonksiyon, döndür, değil, doğru ve yanlış ise her zaman tanınır; aşağıdaki gibi iki yazım bir programda karışık da kullanılabilir. Değişken adlarında Türkçe harfler kullanılabilir.

For those who want to start programming in their mother tongue, Düğüm also has a Turkish spelling. When Düğüm (Türkçe) is chosen as the code language in the settings, all examples are shown and run with Turkish words: değişken (var), eğer (if), değilse (else), yinele (while), için (for), fonksiyon (function), döndür (return), kır (break), devam (continue), yaz (print), boş (null), doğru / yanlış (true / false), yeni Düğüm(…) (new Node), yeni Dizi(n) (new Array), sil (delete), ve / veya / değil (and / or / not); and the fields .veri, .sonraki, .önceki, .sol, .sağ, .yükseklik. The narration and the variables panel use the same words. eğer, değilse, yinele, fonksiyon, döndür, değil, doğru and yanlış are always understood; as below, both spellings can even be mixed in one program. Variable names may contain Turkish letters.

Für alle, die in ihrer Muttersprache mit dem Programmieren beginnen wollen, gibt es Düğüm auch in türkischer Schreibweise. Wird in den Einstellungen Düğüm (Türkçe) als Code-Sprache gewählt, werden alle Beispiele mit türkischen Wörtern gezeigt und ausgeführt: değişken (var), eğer (if), değilse (else), yinele (while), için (for), fonksiyon (function), döndür (return), kır (break), devam (continue), yaz (print), boş (null), doğru / yanlış (true / false), yeni Düğüm(…) (new Node), yeni Dizi(n) (new Array), sil (delete), ve / veya / değil (and / or / not); und die Felder .veri, .sonraki, .önceki, .sol, .sağ, .yükseklik. Erzählung und Variablenbereich benutzen dieselben Wörter. eğer, değilse, yinele, fonksiyon, döndür, değil, doğru und yanlış werden immer verstanden; wie unten lassen sich beide Schreibweisen sogar in einem Programm mischen. Variablennamen dürfen türkische Buchstaben enthalten.

Diziler

Arrays

Arrays

new Array(n) (ya da new Dizi(n)) n hücreli bir dizi oluşturur; hücrelerin hepsi başta null'dır. t[i] i numaralı hücredir (0'dan başlar); bir düğüm, bir sayı ya da null tutabilir. Hücre okumak her ifadede olur: var p = t[k], n.next = t[k], t[k].data. Hücreye yazmak t[i] = … ile yapılır. Dizinin nasıl çizileceğini içine konan ilk değer belirler. Sayı tutan dizi tuvalin üstünde yatay hücreler olarak çizilir; s[size] = v gibi bir yazımda indis olarak kullanılan değişken hücrelerin altında bir okla gösterilir (dizi ile yığın ve kuyruk sayfasına bakın). Kod bir heap'in indis formüllerini kullanırsa (2 * i + 1, taban((i - 1) / 2)), sayı dizisi satırın altında temsil ettiği ağaç olarak da çizilir: 0. hücre kök, i. hücrenin çocukları 2i+1 ve 2i+2 (heap sayfasına bakın). Adı adj (ya da graph, graf, komşu) olan ve listelerinde yalnızca köşe numaraları (0 … n-1) bulunan bir düğüm dizisi, listelerinin sağında temsil ettiği graf olarak da çizilir; aynı boyda visited adlı bir dizide dolu olan köşeler renklenir (graflar sayfasına bakın). Kenar düğümüne e.weight = w ile ağırlık yazılırsa ağırlık kenarın ortasında görünür; aynı boyda dist dizisinin değerleri köşelerin içinde yazar (INF adlı değişkenin değeri ∞ olarak), parent dizisinin oluşturduğu en kısa yol ağacı kalın çizilir (Dijkstra sayfasına bakın). Sıralanacak ya da aranacak veriyi tutan bir sayı dizisi (adı a, arr, dizi, nums…) hücrelerin üstünde çubuk olarak da çizilir: çubuğun boyu değerdir. Bir adımın okuduğu (karşılaştırdığı) hücreler mavi, yazdığı hücre turuncu çerçevelenir; a[mid] gibi indis olarak kullanılan değişkenler (ve low, high, size gibi sınır değişkenleri) hücrelerin altında işaretlenir. Oynatıcının yanındaki sayaç, o bloğun yaptığı karşılaştırma (dizi hücresine bakan koşul) ve yazma (hücreye atama) sayısını gösterir (dizide arama ve sıralama sayfalarına bakın). Graf görünümünde aynı boyda comp (ya da renk) dizisinin sayıları köşeleri renklendirir (aynı sayı, aynı renk); indeg ve key dizileri Dijkstra'daki dist gibi köşenin içinde yazar; bir kenar düğümünün chosen alanı (Türkçe kodda .seçili) true yapılınca kenar kalın mavi çizilir (graf sayfalarına bakın). Adı leader (ya da lider, uf) olan ve her hücresi bir ebeveyn numarası taşıyan bir dizi, altta temsil ettiği orman olarak da çizilir (birleşik küme sayfasına bakın). Düğüm tutan dizi ise solda dikey hücreler olarak çizilir ve her hücreden başlayan zincir o hücrenin satırına yerleşir: zincirlemeli hash tablosunun görüntüsü (hash tablosu sayfasına bakın). Bir dizi en fazla 50 hücreli olabilir; dizinin dışındaki bir indise yazmak açıklamalı bir hata verir.

new Array(r, c) (ya da new Dizi(r, c)) r satır, c sütunluk bir matris (2B dizi) kurar; en fazla 12 × 12. g[i][j] i. satırın j. sütunundaki hücredir; okuma her ifadede, yazma g[i][j] = … ile yapılır. Matris tuvalde satır ve sütun numaralı bir ızgara olarak çizilir: okunan hücreler çerçevelenir, yazılan hücre turuncu yanar, eski değer üstü çizili görünür; g[i][j] içinde indis olarak kullanılan değişkenler satırın yanında ve sütunun altında işaretlenir (matris ve dinamik programlama sayfalarına bakın). Satır ya da sütun indisi sınırın dışındaysa (okurken de, yazarken de) açıklamalı bir hata verir. Düzensiz matris (g[i] = new Array(5)) ve üç boyutlu dizi yoktur. C++ gösteriminde int g[3][4], Java'da int[][] g = new int[3][4] olur.

new Array(n) (or new Dizi(n)) makes an array of n cells; all cells start as null. t[i] is cell number i (counting from 0); it can hold a node, a number or null. Reading a cell works in any expression: var p = t[k], n.next = t[k], t[k].data. A cell is written with t[i] = …. The first value put into an array decides how it is drawn. An array of numbers is a row of cells over the drawing; the variable used as the index in a line like s[size] = v is marked with an arrow under the cells (see the page on stacks and queues with an array). If the code uses the index formulas of a heap (2 * i + 1, taban((i - 1) / 2)), an array of numbers is also drawn under its row as the tree it stands for: cell 0 is the root, the children of cell i are 2i+1 and 2i+2 (see the heap page). An array of nodes named adj (or graph, graf, komşu) whose lists hold only vertex numbers (0 … n-1) is also drawn, right of its lists, as the graph it stands for; vertices filled in an array of the same size named visited are coloured (see the graphs page). If an edge's node gets a weight with e.weight = w, the weight shows in the middle of the edge; the values of an array of the same size named dist stand inside the vertices (the value of a variable named INF as ∞), and the tree of shortest paths that an array named parent forms is drawn thick (see the Dijkstra page). An array of numbers that holds data to search or sort (named a, arr, dizi, nums…) is also drawn as bars over its cells: the height of a bar is the value. The cells a step read (compared) get a blue frame, the cell it wrote an orange one; variables used as an index such as in a[mid] (and bound variables such as low, high, size) are marked under the cells. The counter next to the player shows the number of comparisons (conditions that look at an array cell) and writes (assignments to a cell) of that block (see the pages on searching and sorting arrays). In the graph view the numbers of an array of the same size named comp (or renk) colour the vertices (the same number, the same colour); the arrays indeg and key are written inside the vertices like dist in Dijkstra; when the chosen field of an edge's node (.seçili in Turkish code) is set to true, the edge is drawn thick and blue (see the graph pages). An array named leader (or lider, uf) whose cells hold parent numbers is also drawn as the forest it stands for (see the disjoint sets page). An array of nodes is a column of cells on the left, and the chain starting at each cell is placed on that cell's row: the picture of a hash table with chaining (see the hash table page). An array can have at most 50 cells; writing to an index outside the array gives an explained error.

new Array(r, c) (or new Dizi(r, c)) builds a matrix (2D array) of r rows and c columns, at most 12 × 12. g[i][j] is the cell in row i, column j; reading works in any expression, writing is done with g[i][j] = …. A matrix is drawn as a grid with row and column numbers: the cells that are read get a frame, the cell that is written lights up in orange and the old value is shown struck through; variables used as an index inside g[i][j] are marked beside the row and under the column (see the pages on matrices and dynamic programming). A row or column index outside the matrix gives an explained error, both when reading and when writing. There is no jagged matrix (g[i] = new Array(5)) and no three-dimensional array. In C++ it is shown as int g[3][4], in Java as int[][] g = new int[3][4].

new Array(n) (oder new Dizi(n)) erzeugt ein Array mit n Zellen; alle Zellen sind anfangs null. t[i] ist die Zelle Nummer i (ab 0 gezählt); sie kann einen Knoten, eine Zahl oder null enthalten. Eine Zelle lesen geht in jedem Ausdruck: var p = t[k], n.next = t[k], t[k].data. Geschrieben wird eine Zelle mit t[i] = …. Der erste Wert, der in ein Array kommt, bestimmt, wie es gezeichnet wird. Ein Array aus Zahlen ist eine Reihe von Zellen über der Zeichnung; die Variable, die in einer Zeile wie s[size] = v als Index dient, wird unter den Zellen mit einem Pfeil markiert (siehe die Seite zu Stapel und Warteschlange mit einem Array). Benutzt der Code die Indexformeln eines Heaps (2 * i + 1, taban((i - 1) / 2)), wird ein Array von Zahlen unter seiner Zeile auch als der Baum gezeichnet, für den es steht: Zelle 0 ist die Wurzel, die Kinder von Zelle i sind 2i+1 und 2i+2 (siehe die Heap-Seite). Ein Array von Knoten namens adj (oder graph, graf, komşu), dessen Listen nur Knotennummern (0 … n-1) enthalten, wird rechts seiner Listen auch als der Graph gezeichnet, für den es steht; Knoten, die in einem gleich großen Array namens visited gefüllt sind, werden eingefärbt (siehe die Seite zu Graphen). Bekommt der Knoten einer Kante mit e.weight = w ein Gewicht, erscheint es in der Mitte der Kante; die Werte eines gleich großen Arrays namens dist stehen innen an den Knoten (der Wert einer Variable namens INF als ∞), und der Baum der kürzesten Wege, den ein Array namens parent bildet, wird dick gezeichnet (siehe die Dijkstra-Seite). Ein Array von Zahlen, das Daten zum Suchen oder Sortieren hält (Name a, arr, dizi, nums…), wird über seinen Zellen auch als Balken gezeichnet: die Höhe eines Balkens ist der Wert. Die Zellen, die ein Schritt gelesen (verglichen) hat, bekommen einen blauen Rahmen, die geschriebene Zelle einen orangen; als Index benutzte Variablen wie in a[mid] (und Grenzvariablen wie low, high, size) werden unter den Zellen markiert. Der Zähler neben dem Player zeigt die Zahl der Vergleiche (Bedingungen, die eine Array-Zelle ansehen) und Schreibvorgänge (Zuweisungen an eine Zelle) dieses Blocks (siehe die Seiten zum Suchen und Sortieren in Arrays). In der Graphansicht färben die Zahlen eines gleich großen Arrays namens comp (oder renk) die Knoten (dieselbe Zahl, dieselbe Farbe); die Arrays indeg und key stehen wie dist bei Dijkstra in den Knoten; wird das Feld chosen des Knotens einer Kante (.seçili im türkischen Code) auf true gesetzt, wird die Kante dick und blau gezeichnet (siehe die Graphseiten). Ein Array namens leader (oder lider, uf), dessen Zellen Elternnummern enthalten, wird auch als der Wald gezeichnet, für den es steht (siehe die Seite zu disjunkten Mengen). Ein Array aus Knoten ist eine Spalte von Zellen links, und die Kette ab jeder Zelle steht in der Zeile dieser Zelle: das Bild einer Hashtabelle mit Verkettung (siehe die Seite zur Hashtabelle). Ein Array kann höchstens 50 Zellen haben; das Schreiben an einen Index außerhalb des Arrays gibt einen erklärten Fehler.

new Array(r, c) (oder new Dizi(r, c)) erzeugt eine Matrix (2D-Array) mit r Zeilen und c Spalten, höchstens 12 × 12. g[i][j] ist die Zelle in Zeile i, Spalte j; gelesen wird in jedem Ausdruck, geschrieben mit g[i][j] = …. Eine Matrix wird als Gitter mit Zeilen- und Spaltennummern gezeichnet: gelesene Zellen bekommen einen Rahmen, die geschriebene Zelle leuchtet orange und der alte Wert steht durchgestrichen daneben; als Index in g[i][j] benutzte Variablen werden neben der Zeile und unter der Spalte markiert (siehe die Seiten zu Matrizen und dynamischer Programmierung). Ein Zeilen- oder Spaltenindex außerhalb der Matrix gibt einen erklärten Fehler, beim Lesen wie beim Schreiben. Eine unregelmäßige Matrix (g[i] = new Array(5)) und dreidimensionale Arrays gibt es nicht. In C++ wird sie als int g[3][4] gezeigt, in Java als int[][] g = new int[3][4].

Çift yönlü listeler ve ağaçlar

Doubly linked lists and trees

Doppelt verkettete Listen und Bäume

Düğümlerin next'ten başka üç bağ alanı daha vardır. Kodda .prev geçince düğümler çift yönlü liste düğümü olarak çizilir: [prev | değer | next]. .left ya da .right geçince ağaç düğümü olarak çizilir: [left | değer | right]; düğümler derinliklerine göre satırlara yerleşir. Örnekler menüsündeki çift yönlü liste ve ağaç sayfalarına bakın.

Besides next, nodes have three more link fields. When the code uses .prev, nodes are drawn as doubly linked list nodes: [prev | value | next]. When it uses .left or .right, they are drawn as tree nodes: [left | value | right], and nodes are placed in rows by their depth. See the doubly linked list and tree pages in the Examples menu.

Neben next haben Knoten drei weitere Verbindungsfelder. Verwendet der Code .prev, werden Knoten als Knoten einer doppelt verketteten Liste gezeichnet: [prev | Wert | next]. Verwendet er .left oder .right, werden sie als Baumknoten gezeichnet: [left | Wert | right], und die Knoten stehen nach ihrer Tiefe in Zeilen. Siehe die Seiten zu doppelt verketteten Listen und Bäumen im Menü Beispiele.

Komut satırı ve hatalar

The command line and errors

Befehlszeile und Fehler

Görselleştirmenin altındaki Komut satırı sekmesine tek satırlık kod yazılır ve Enter ile çalışır: x.next.data yazınca değeri, x yazınca listenin kendisi görünür (bir ağaç {data, left, right} olarak). Bir hata olunca hangi satırda ne olduğu açıklanır ve satır editörde kırmızıyla işaretlenir: örneğin null bir pointer'ın alanına erişmek, tanımlanmamış bir değişken, kapanmamış bir parantez. Bazı adlar tarayıcıda ayrılmıştır (ör. top, name); onların yerine başka bir ad seçmek gerekir.

In the Command line tab under the visualization you type a single line and run it with Enter: typing x.next.data shows its value, typing x shows the list itself (a tree as {data, left, right}). When something goes wrong, the message says on which line and what happened, and the line is marked red in its editor: for example reading a field of a null pointer, a variable that was never defined, or a bracket that was not closed. Some names are reserved by the browser (e.g. top, name); choose another name instead.

In der Registerkarte Befehlszeile unter der Visualisierung tippt man eine einzelne Zeile und führt sie mit Enter aus: x.next.data zeigt den Wert, x die Liste selbst (ein Baum als {data, left, right}). Geht etwas schief, sagt die Meldung, in welcher Zeile was passiert ist, und die Zeile wird im Editor rot markiert: zum Beispiel beim Lesen eines Feldes eines null-Zeigers, bei einer nie definierten Variable oder einer nicht geschlossenen Klammer. Einige Namen sind im Browser reserviert (z. B. top, name); wählen Sie stattdessen einen anderen Namen.

C++ ve Java ile kullanmak

Using C++ and Java

Mit C++ und Java arbeiten

Veri yapıları dersini C++ ile alanlar için örnekler C++ olarak da gösterilip çalıştırılabilir: ayarlarda Kod dili olarak C++'ı seçin. Sayfalardaki kod kendiliğinden C++'a çevrilir (türler koddan çıkarılır: Node*, int, bool, dizi ve fonksiyon türleri), çizim ve anlatım aynen çalışır. Anlaşılan C++, veri yapıları için gereken kısımdır: hazır gelen struct Node (data, next, prev, left, right, height), Node* p, int, bool, double değişkenleri, Node* t[5] ve int s[5] dizileri, new Node(5), new Node(5, head), delete, ->, nullptr / NULL, if / else / while / for, türleri yazılmış fonksiyonlar, cout << … << endl. #include, using namespace std; ve struct Node { … }; satırları atlanır; int main() varsa çalıştırılır. Farklar: her satırda tek komut olur (aynı satırdaki birkaç tanım dışında); sınıf, şablon, referans ve cin yoktur; iki tarafı da tam sayı olan bölme C++'taki gibi kesilir (7 / 2 3, -7 / 2 -3, 7 / 2.0 3,5; sıfıra bölme hata verir). Bu rehber Düğüm'ü anlattığı için kodları hep Düğüm'dür.

For those who take the data structures course in C++, the examples can also be shown and run in C++: choose C++ as the Code language in the settings. The code on the pages is translated to C++ by itself (the types come from the code: Node*, int, bool, array and function types), and the drawing and the narration work the same. The C++ that is understood is the part data structures need: a predefined struct Node (data, next, prev, left, right, height), Node* p, int, bool and double variables, arrays Node* t[5] and int s[5], new Node(5), new Node(5, head), delete, ->, nullptr / NULL, if / else / while / for, functions with types, cout << … << endl. Lines with #include, using namespace std; and struct Node { … }; are skipped; an int main() is run. Differences: one statement per line (except several declarations on a line); no classes, templates, references or cin; a division with two integer sides is cut as in C++ (7 / 2 is 3, -7 / 2 is -3, 7 / 2.0 is 3.5; dividing by zero is an error). As this guide is about Düğüm, its code is always Düğüm.

Wer den Kurs Datenstrukturen in C++ belegt, kann die Beispiele auch in C++ anzeigen und ausführen: wählen Sie in den Einstellungen C++ als Code-Sprache. Der Code der Seiten wird von selbst nach C++ übersetzt (die Typen ergeben sich aus dem Code: Node*, int, bool, Array- und Funktionstypen), Zeichnung und Erklärungen funktionieren genauso. Verstanden wird der Teil von C++, den Datenstrukturen brauchen: ein vordefiniertes struct Node (data, next, prev, left, right, height), Variablen Node* p, int, bool und double, Arrays Node* t[5] und int s[5], new Node(5), new Node(5, head), delete, ->, nullptr / NULL, if / else / while / for, Funktionen mit Typen, cout << … << endl. Zeilen mit #include, using namespace std; und struct Node { … }; werden übersprungen; ein int main() wird ausgeführt. Unterschiede: eine Anweisung pro Zeile (außer mehreren Deklarationen in einer Zeile); keine Klassen, Templates, Referenzen oder cin; eine Division mit zwei ganzzahligen Seiten wird wie in C++ abgeschnitten (7 / 2 ist 3, -7 / 2 ist -3, 7 / 2.0 ist 3,5; Division durch null ist ein Fehler). Da dieser Leitfaden Düğüm beschreibt, ist sein Code immer Düğüm.

Java da aynı biçimde seçilir. Örneklerde Node p, p.next, null, boolean, Node[] t = new Node[5], int[] s = new int[5], static metotlar ve System.out.println(…) kullanılır. Elle yazılan Java'da public class Main { … } sarmalayıcısı, class Node { … } tanımı ve import satırları atlanır, public static void main(String[] args) çalıştırılır. Java'da delete yoktur: örneklerdeki delete satırları açıklayıcı bir yoruma dönüşür; hiçbir değişkenden ya da bağdan ulaşılamayan düğümler soluk çizilir ve "çöp" diye işaretlenir, çünkü onları Java'nın çöp toplayıcısı siler. Sınırlar C++ ile aynıdır; ayrıca String değişkeni yoktur (metin yalnızca println içinde).

Java is chosen the same way. The examples use Node p, p.next, null, boolean, Node[] t = new Node[5], int[] s = new int[5], static methods and System.out.println(…). In hand-written Java, a public class Main { … } wrapper, a class Node { … } definition and import lines are skipped, and public static void main(String[] args) is run. Java has no delete: the delete lines of the examples become an explaining comment; nodes that no variable and no link reaches are drawn faded and marked "garbage", because Java's garbage collector removes them. The limits are those of C++; in addition there are no String variables (text only inside println).

Java wird genauso gewählt. Die Beispiele verwenden Node p, p.next, null, boolean, Node[] t = new Node[5], int[] s = new int[5], static-Methoden und System.out.println(…). In selbst geschriebenem Java werden eine umschließende public class Main { … }, eine Definition class Node { … } und import-Zeilen übersprungen, und public static void main(String[] args) wird ausgeführt. Java hat kein delete: die delete-Zeilen der Beispiele werden zu einem erklärenden Kommentar; Knoten, die keine Variable und keine Verbindung mehr erreicht, werden blass gezeichnet und als „Müll“ markiert, weil der Garbage Collector von Java sie entfernt. Die Grenzen sind die von C++; zusätzlich gibt es keine String-Variablen (Text nur in println).

JavaScript'ten farkları

Differences from JavaScript

Unterschiede zu JavaScript

Her satırda tek komut olur ve satır sonunda ; gerekmez. Nesne ve metin değişkeni yoktur; veri yapıları düğümler ve düğüm tutan dizilerle kurulur. Fonksiyon içinde fonksiyon tanımlanamaz. Bir çağrının sonucunun alanı okunabilir (find(3).data), ama ona yazılamaz (find(3).next = … yerine önce var p = find(3)). Dilin grameri grammer.pegjs dosyasındadır (PEG.js); sayfa açılınca tarayıcıda derlenir.

One statement per line, and no ; needed at the end of a line. There are no objects or text variables; data structures are built from nodes and arrays of nodes. A function cannot be defined inside another function. The field of a call's result can be read (find(3).data) but not written (instead of find(3).next = …, first var p = find(3)). The grammar of the language is in the file grammer.pegjs (PEG.js); it is compiled in the browser when a page opens.

Eine Anweisung pro Zeile, und am Zeilenende ist kein ; nötig. Es gibt keine Objekte oder Textvariablen; Datenstrukturen werden aus Knoten und Arrays von Knoten gebaut. Eine Funktion kann nicht innerhalb einer anderen Funktion definiert werden. Das Feld eines Aufrufergebnisses kann man lesen (find(3).data), aber nicht beschreiben (statt find(3).next = … zuerst var p = find(3)). Die Grammatik der Sprache steht in der Datei grammer.pegjs (PEG.js); sie wird beim Öffnen einer Seite im Browser übersetzt.