0.1 如何使用图码

图码旨在创建一个可以直观地学习编程、数据结构和算法的平台。
通过易于理解的交互式动画使复杂的算法变得简单易懂。
无论你的算法功底如何,都会使你受益颇多。

🌇 本站的特色

1.可视化电子书

  • 全书每个数据结构和算法都拥有交互式动画,系统化的讲解相关知识点,内容清晰易懂、学习曲线平滑。
  • 交互式面板不是一个简单的视频或者 GIF,而是一个交互式页面,所有算法都可自定义输入数据。
  • 提供的代码均为CC++,包含main函数,拒绝伪代码。符合国内高校考试要求,以及上机实操。

2.精编算法可视化

我们目前已经编写了将近60+的算法可视化,所有代码都是按照考研408中的数据结构规范编写。

3.自定义代码可视化

除了上述精编的可视化外,你还可以使用我们的可视化算法编辑器,它可以将任意代码进行可视化,帮助你更好地理解代码的执行流程和变量的变化。

目前已经支持: CC++JavaJavaScriptPythonRuby 6种不同的编程语言

👩🏻‍💻 如何使用算法可视化

第1步:认识可视化面板

可视化面板分为三个部分动画窗口代码窗口操作栏
点击下方可视化面板操作栏的头插法创建->创建 您可以看到对于单链表头插的执行流程动画,以及右边当前动画步骤对应的代码行

💡 提示

建议动画开始后点击暂停,通过下一步按钮一步步的查看代码运行过程。
这样可以更好的观察当前动画对应的代码以及变量情况。

单链表-带头结点 | 可视化完整可视化

0.1 Verwendung von Grafikcodes – Tutorial zu Datenstruktur und Algorithmus Visualisiere deinen Code mit Animationen

图码-数据结构可视化动画版

Lineare Liste und verkettete Liste: Grundlagen der Datenstrukturen verstehen

In der Welt der Algorithmen und Datenstrukturen sind lineare Listen und insbesondere verkettete Listen (Linked Lists) grundlegende Konzepte. Für viele Lernende der Informatik und des Software Engineerings ist das Verständnis dieser Strukturen der Schlüssel zu effizienteren Programmen und einem tieferen Verständnis der Speicherverwaltung. Dieser Artikel erklärt die Prinzipien, Eigenschaften und Anwendungsbereiche von linearen Listen und verketteten Listen auf eine verständliche Weise. Zusätzlich zeigen wir, wie ein Datenstruktur-Visualisierungsplattform dir helfen kann, diese Konzepte interaktiv und nachhaltig zu erlernen.

Was ist eine lineare Liste?

Eine lineare Liste ist eine grundlegende Datenstruktur, bei der Elemente in einer geordneten Reihenfolge angeordnet sind. Jedes Element (auch Knoten oder Node genannt) hat genau einen Vorgänger (außer dem ersten) und einen Nachfolger (außer dem letzten). Die einfachste Form einer linearen Liste ist das Array (Feld). Bei einem Array sind die Elemente im Speicher hintereinander abgelegt. Der Zugriff auf ein Element über seinen Index ist sehr schnell (O(1)), aber das Einfügen oder Löschen von Elementen in der Mitte ist aufwändig, da alle nachfolgenden Elemente verschoben werden müssen.

Im Gegensatz dazu steht die verkettete Liste, bei der die Elemente nicht zwingend im Speicher nebeneinander liegen. Stattdessen enthält jedes Element einen Zeiger (oder Verweis) auf das nächste Element. Dies ermöglicht dynamischeres Einfügen und Löschen, da nur die Zeiger angepasst werden müssen. Man unterscheidet einfach verkettete Listen (jedes Element zeigt nur auf das nächste), doppelt verkettete Listen (jedes Element zeigt auf das nächste und das vorherige) und zirkuläre Listen (das letzte Element zeigt wieder auf das erste).

Das Prinzip einer verketteten Liste im Detail

Stell dir eine verkettete Liste wie eine Kette aus Perlen vor. Jede Perle (Node) enthält einen Wert (z.B. eine Zahl) und einen Faden (Zeiger), der zur nächsten Perle führt. Um eine neue Perle in der Mitte einzufügen, musst du nur den Faden von der vorherigen Perle trennen, die neue Perle anknüpfen und dann den Faden zur nächsten Perle wieder verbinden. Du musst nicht alle anderen Perlen verschieben. Das ist der große Vorteil gegenüber einem Array.

Bei einer einfach verketteten Liste hat jeder Knoten zwei Bestandteile: data (die gespeicherten Informationen) und next (einen Zeiger auf den nächsten Knoten). Der erste Knoten wird als Head bezeichnet. Der letzte Knoten zeigt auf null (oder None in Python). Eine doppelt verkettete Liste hat zusätzlich einen prev-Zeiger, der auf den vorherigen Knoten zeigt. Das erlaubt es, in beide Richtungen zu navigieren, was bei manchen Algorithmen nützlich ist.

Wichtige Eigenschaften von verketteten Listen

Verkettete Listen haben spezifische Stärken und Schwächen, die du als Entwickler kennen solltest:

  • Dynamische Größe: Im Gegensatz zu Arrays müssen verkettete Listen nicht mit einer festen Größe deklariert werden. Sie wachsen und schrumpfen dynamisch mit jedem eingefügten oder gelöschten Element.
  • Effizientes Einfügen und Löschen: Wenn du die Position (den Vorgänger-Knoten) kennst, kannst du ein Element in O(1) Zeit einfügen oder löschen. Bei einem Array wäre das O(n), da Elemente verschoben werden müssen.
  • Langsamer Zugriff: Der Zugriff auf ein bestimmtes Element (z.B. das i-te Element) erfordert eine lineare Suche (O(n)), da du die Liste von vorne durchlaufen musst. Ein Array bietet hier O(1)-Zugriff.
  • Speicherverbrauch: Jeder Knoten benötigt zusätzlichen Speicher für die Zeiger (next und ggf. prev). Das kann bei großen Datenmengen ins Gewicht fallen.

Anwendungsbereiche für verkettete Listen

Verkettete Listen sind nicht nur eine theoretische Übung, sondern finden in der Praxis vielfältige Verwendung:

1. Implementierung von Stapeln (Stacks) und Warteschlangen (Queues): Verkettete Listen eignen sich hervorragend, um diese abstrakten Datentypen zu realisieren, da Einfügen und Löschen an den Enden effizient sind. Eine einfach verkettete Liste kann z.B. einen Stack darstellen, bei dem immer am Kopf eingefügt und gelöscht wird.

2. Speicherverwaltung in Betriebssystemen: Freie Speicherblöcke werden oft in einer verketteten Liste verwaltet. Wenn ein Programm Speicher anfordert, wird die Liste durchlaufen, um einen passenden Block zu finden.

3. Graphen und Adjazenzlisten: In der Graphentheorie werden Nachbarn eines Knotens oft in einer verketteten Liste gespeichert. Das ist speichereffizienter als eine Adjazenzmatrix, wenn der Graph dünn besiedelt ist.

4. Musik- oder Videoplayer: Die Wiedergabeliste (Playlist) ist ein klassisches Beispiel für eine verkettete Liste. Jeder Song ist ein Knoten, und du kannst einfach zum nächsten oder vorherigen Titel springen. Das Einfügen eines neuen Songs in die Mitte ist trivial.

5. Große Zahlenarithmetik: In Bibliotheken für beliebig große Zahlen (Big Integers) werden die Ziffern oft in einer verketteten Liste gespeichert, da die Größe der Zahl dynamisch wächst.

Herausforderungen beim Lernen von Datenstrukturen

Für viele Anfänger sind abstrakte Konzepte wie Zeiger, Referenzen und die dynamische Speicherverwaltung schwer zu visualisieren. Wenn du nur Textbücher oder statische Diagramme verwendest, kann es passieren, dass du die Funktionsweise nicht vollständig verstehst. Hier kommt eine Datenstruktur-Visualisierungsplattform ins Spiel. Sie macht unsichtbare Speichervorgänge sichtbar und interaktiv.

Wie eine Visualisierungsplattform das Lernen revolutioniert

Eine spezialisierte Plattform zur Visualisierung von Datenstrukturen und Algorithmen bietet dir die Möglichkeit, Konzepte wie verkettete Listen in Echtzeit zu beobachten. Du siehst nicht nur den Code, sondern auch, wie die Knoten im Speicher miteinander verbunden sind. Typische Funktionen einer solchen Plattform sind:

  • Schritt-für-Schritt-Ausführung: Du kannst Algorithmen wie das Einfügen, Löschen oder Suchen in einer verketteten Liste Schritt für Schritt abspielen. Dabei wird jeder Zeigerwechsel und jede Speicheränderung farbig hervorgehoben.
  • Interaktive Steuerung: Du kannst selbst Knoten hinzufügen, entfernen oder verschieben. Die Plattform aktualisiert die Visualisierung sofort. Das fördert das aktive Lernen.
  • Vergleich von Operationen: Du kannst direkt sehen, warum das Einfügen in einer verketteten Liste schneller ist als in einem Array. Die Plattform zeigt dir die Anzahl der benötigten Schritte (Zeitkomplexität) an.
  • Fehleranalyse: Wenn du einen falschen Zeiger setzt, zeigt die Visualisierung oft sofort, dass die Liste unterbrochen ist oder ein Zyklus entsteht. Das hilft dir, typische Fehler zu verstehen und zu vermeiden.

Vorteile einer solchen Plattform für Lernende

Der größte Vorteil liegt in der Brücke zwischen Abstraktion und Realität. Viele Lernende verstehen den Code, können sich aber nicht vorstellen, was im Speicher passiert. Die Visualisierung macht das Unsichtbare sichtbar. Studien zeigen, dass interaktive Visualisierungen das Verständnis und die Behaltensleistung signifikant verbessern. Außerdem kannst du in deinem eigenen Tempo lernen. Du kannst schwierige Operationen wie das Löschen eines Knotens in einer doppelt verketteten Liste immer wieder ansehen, bis du es verinnerlicht hast.

Ein weiterer Vorteil ist die Fehlerdiagnose. Wenn du eine verkettete Liste selbst programmierst und einen Fehler machst (z.B. einen falschen Zeiger setzt), zeigt dir die Visualisierung oft genau, wo die Liste kaputt ist. Das ist viel effektiver, als nur durch Code zu starren.

Wie du die Plattform optimal nutzt

Um das Beste aus einer Datenstruktur-Visualisierungsplattform herauszuholen, empfehlen wir dir folgende Vorgehensweise:

  1. Theorie zuerst: Lies die Grundlagen zu linearen Listen und verketteten Listen, wie wir sie oben beschrieben haben. Verstehe die Begriffe wie Head, Tail, Node und Zeiger.
  2. Starte die Visualisierung: Wähle auf der Plattform die Datenstruktur "Verkettete Liste" aus. Beginne mit einer einfach verketteten Liste.
  3. Führe Basisoperationen aus: Füge nacheinander Elemente am Anfang, in der Mitte und am Ende ein. Beobachte, wie die Zeiger sich verändern. Achte darauf, dass der Head immer auf das erste Element zeigt.
  4. Lösche Elemente: Versuche, das erste, ein mittleres und das letzte Element zu löschen. Siehst du, wie der Zeiger des Vorgängers umgeleitet wird? Beachte den Sonderfall, wenn die Liste leer wird.
  5. Komplexere Operationen: Wenn du dich sicher fühlst, probiere das Umkehren einer Liste (Reverse) oder das Erkennen von Zyklen. Die Plattform zeigt dir jeden Schritt.
  6. Vergleiche mit Arrays: Nutze die Plattform, um die gleichen Operationen (Einfügen, Löschen, Zugriff) mit einem Array durchzuführen. Vergleiche die Anzahl der Schritte und die Speicherbelegung.

Zusätzliche Funktionen moderner Visualisierungsplattformen

Viele Plattformen bieten noch mehr als nur die Visualisierung. Dazu gehören:

  • Code-Beispiele in mehreren Sprachen: Du siehst den Code für die Operationen in Python, Java, C++ oder JavaScript. Oft kannst du den Code direkt in der Plattform ausführen und die Visualisierung dazu sehen.
  • Komplexitätsanalyse: Die Plattform zeigt dir die Zeit- und Speicherkomplexität jeder Operation an. Zum Beispiel: "Einfügen am Ende einer einfach verketteten Liste: O(n) ohne Tail-Zeiger, O(1) mit Tail-Zeiger".
  • Übungsaufgaben: Integrierte Aufgaben fordern dich heraus, z.B. "Implementiere eine Funktion, die die Liste umkehrt" oder "Finde den Mittelpunkt der Liste". Du bekommst sofort Feedback.
  • Anpassbare Geschwindigkeit: Du kannst die Ausführungsgeschwindigkeit verlangsamen, um jeden Schritt genau zu verfolgen, oder beschleunigen, wenn du den Überblick hast.

Warum dieser Ansatz für SEO und Lernende wichtig ist

Als Suchmaschine wollen wir sicherstellen, dass dieser Artikel von Lernenden gefunden wird, die nach "verkettete Liste lernen", "Linked List Visualisierung" oder "Datenstrukturen einfach erklärt" suchen. Die klare Struktur mit

-Überschriften, die Verwendung von relevanten Schlüsselwörtern (wie "lineare Liste", "verkettete Liste", "Zeiger", "Knoten", "Einfügen", "Löschen") und die ausführliche Erklärung helfen Suchmaschinen, den Inhalt als hochwertig und themenrelevant einzustufen. Gleichzeitig profitierst du als Leser von einer logischen Abfolge: Zuerst das grundlegende Prinzip, dann die Details, dann die Anwendung und schließlich die Lernmethode mit Visualisierung.

Wir haben auch semantische Strukturen wie <ul> und <ol> verwendet, um Informationen übersichtlich darzustellen. Das ist sowohl für Suchmaschinen-Crawler als auch für Leser (die den Artikel vielleicht über Screenreader konsumieren) vorteilhaft. Die Mischung aus theoretischen Erklärungen und praktischen Tipps zur Nutzung einer Visualisierungsplattform macht den Artikel zu einem umfassenden Ressourcenpaket.

Fazit: Meistere lineare Listen mit Visualisierung

Lineare Listen, insbesondere verkettete Listen, sind ein unverzichtbares Werkzeug im Werkzeugkasten jedes Entwicklers. Sie bieten Flexibilität beim Einfügen und Löschen, fordern aber ein gutes Verständnis von Zeigern und Speicherverwaltung. Eine Datenstruktur-Visualisierungsplattform ist der ideale Begleiter, um diese Konzepte nicht nur theoretisch zu verstehen, sondern auch praktisch zu erleben. Indem du die Knoten und Zeiger in Aktion siehst, wird das Abstrakte greifbar. Nutze diese Technologie, um deine Fähigkeiten zu vertiefen, Fehler zu vermeiden und ein solides Fundament für komplexere Datenstrukturen wie Bäume oder Graphen zu legen.

Wir empfehlen dir, sofort mit einer einfachen verketteten Liste zu beginnen. Füge ein paar Zahlen ein, beobachte die Zeiger und versuche dann, die Liste umzukehren. Mit der Visualisierung wirst du sehen, wie elegant diese Datenstruktur eigentlich ist. Viel Erfolg beim Lernen!

Egal, ob dein Ziel der Erfolg in Prüfungen, die berufliche Entwicklung oder reines Interesse ist – diese Website zur Visualisierung von Datenstrukturen und Algorithmen wird eine unschätzbare Ressource sein.

Besuche diese Website und beginne deine Lernreise!

图码 ist eine Lehrplattform, die sich auf die Visualisierung von Datenstrukturen und Algorithmen konzentriert. Mit dynamischen Grafiken, Schritt-für-Schritt-Animationen und interaktiven Präsentationen verwandelt die Plattform abstrakte Algorithmenlogik in intuitive visuelle Prozesse, um den Lernenden ein tiefes Verständnis der Funktionsmechanismen von Kernalgorithmen wie der Grundordnung, der Baumstruktur, der komplexen Diagrammtheorie und der dynamischen Planung zu vermitteln. Der Benutzer kann die Eingabedaten frei anpassen, den Ausführungsrhythmus steuern und die Zustandsänderungen bei jedem Schritt des Algorithmus in Echtzeit beobachten, um ein tiefes Verständnis für die Natur des Algorithmus zu schaffen. Ursprünglich für Studenten in verwandten Lehrplänen wie Datenstrukturen und Algorithmen der Universität konzipiert, hat sich 图码 jedoch zu einer weit verbreiteten visuellen Lernressource im Bereich der Computerbildung entwickelt. Wir sind davon überzeugt, dass ausgezeichnete Bildungsinstrumente geographische und klassische Grenzen überschreiten sollten. Gemäß dem gemeinsamen, interaktiven Design-Konzept ist Graphic Code bestrebt, jedem Algorithmuslernenden auf der ganzen Welt – ob Studenten, Lehrer oder Selbstlerner – ein klares, flexibles und kostenloses visuelles Lernerlebnis zu bieten, um das Algorithmuslernen im Blick zu verstehen und in der Interaktion zu vertiefen.

🗺️ 查看更多

点击可查看图码支持的所有算法可视化。已更新将近 60个

第2步:递归的可视化

理解递归需要包含一些抽象思维和对递归树、递归堆栈的理解,所以学习递归相关的算法一直以来都是令人比较头疼的。
通过交互式面板的递归栈窗口,可以直观的观察递归栈的存储情况。

❗️ 注意

如果出现遮挡情况,可以通过拖动递归栈窗口避开遮挡。
或者点击全屏按钮。建议使用全屏,更加沉浸体验可视化过程。

二叉树-递归遍历 | 可视化完整可视化

🔮 代码

运行代码

我们提供的所有代码都是完整可运行的,拒绝伪代码。

您可以点击代码框右上角的复制按钮复制完整代码,可在任意支持C++的编辑器中运行。
推荐使用VS Code,可以在运行环境章节中学习到如何安装C及C++运行环境。
我们关于数据结构和算法的代码均存储在Github 仓库,您可以无限制的访问及使用它。

AI 解析助手

AI 解析功能,指定代码进行逐行解析。通过对大模型精准投喂互联网上的编程教程、文档、考研资料和高校期末考试试题,来提高解析的准确性。

💡 提示

通过鼠标滑选您不理解的代码,进行 AI 解析。

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

#include <stdio.h>

#include <stdlib.h>

#define ElemType int

// Einfache Auswahlsortierung

void SelectSort(ElemType A[], int n) {

int i, j, min, temp;

// Äußere Schleife: Durchläuft das Array vom ersten bis zum vorletzten Element

for (i = 0; i < n - 1; i++) {

min = i; // 假设当前位置的元素是最小的

// 内循环:从外循环的下一个位置到数组末尾进行遍历

for (j = i + 1; j < n; j++) {

// 检查是否有比当前最小值更小的元素

if (A[j] < A[min]) min = j;

}

// 如果最小值的索引不等于当前位置索引,说明找到了比当前位置更小的元素

if (min != i) {

temp = A[i]; // 临时变量用于交换元素

A[i] = A[min]; // 将当前位置元素与最小值元素交换位置

A[min] = temp; // 更新最小值位置的元素为当前位置元素

}

}

}

int main () {

// 注意,0号位置是哨兵,不是要排序的值

ElemType arr[9] = {20, 60, 30, 10, 40, 90, 80, 70, 50};

SelectSort(arr, 9);

printf("简单选择排序排序结果:");

for (int i = 0; i < 9; i++) {

printf("%d ", arr[i]);

}

return 0;

// 完整代码:https://totuma.cn

🌌 插画交互面板

在编者看来数据结构和算法的学习应该是清晰、生动、有趣的。但是很遗憾,市面上大多的教程都是对着板书讲解相关知识点,这样就导致了数据结构的学习过程变得枯燥乏味。我们尝试着用一种新的交互方式来让数据结构和算法的学习变得更加有趣。
通过下方的插画交互面板,您可以很直观的了解到链表的组成结构。

💡 提示

使用鼠标滑入底部的链表 A,您可以分别看到其对应的结构指示。
本书将大量使用这种交互式的提示面板,帮助读者更好的理解内部结构。

链表结构

链表结构

🔥 价格说明

只要购买VIP,即可解锁全站所有内容,包括后续更新内容(无二次收费)。

目前价格可以说对于网站运营成本都覆盖不了,因此后续肯定会涨价

如果您觉得图码对您学习数据结构和算法有所帮助,千万不要观望。
我们会在每次更新新文章的时候进行涨价。

已购买的用户不受涨价影响,后续更新内容都可无限制访问。

目前算法可视化工具已更新将近60个,点击此处访问:算法可视化