Programmier-Tutorial
Die Kunst des Programmierens
Die Kunst des Programmierens geht über das Schreiben von Code hinaus. Es geht um unseren Denkprozess, unseren Problemlösungsansatz und die Auswirkungen, die wir auf die Welt haben. Programmieren ist eine kreative Sprache, die Ideen zum Leben erweckt und es uns ermöglicht, uns durch Technologie auszudrücken. Es fordert uns heraus, innovativ zu denken, unkonventionelle Lösungen zu finden und unser Verständnis der Welt und uns selbst zu erweitern. In diesem Video werden grundlegende Programmierkonzepte untersucht, von grundlegender Syntax und Datenstrukturen bis hin zu erweiterten Algorithmen und Programmierparadigmen. Lass uns anfangen.
Beim Bearbeiten von Code gibt es zwei Haupttypen von Tools: Texteditoren und IDEs. Während sich Texteditoren auf die Bearbeitung von reinem Text konzentrieren, bieten IDEs zusätzliche Funktionen. Für die meisten Zwecke spielt die Unterscheidung zwischen den beiden jedoch keine große Rolle und die Begriffe können austauschbar verwendet werden. Zu den beliebten Optionen für Texteditoren und IDEs gehören Vim, Atom, Sublime Text, Eclipse, IntelliJ, PyCharm und Visual Studio Code. Insbesondere Visual Studio Code ist hochgradig anpassbar und wird allgemein empfohlen.
Um Code auszuführen, müssen wir ihn in Maschinencode kompilieren, den Computer verstehen. Dies erfordert die Installation eines Sprachcompilers oder einer Laufzeitumgebung. Verschiedene Sprachen haben ihre eigenen Compiler oder Laufzeiten, z. B. GCC, Java SDK, Python-Interpreter, Node.js-Laufzeit und .NET SDK. Es ist nicht erforderlich, die Details dieser Tools zu verstehen. Alles, was Sie wissen müssen, ist, eine Sprache zu installieren, um Ihren Code auszuführen.
Zum Ausführen von Code wird das Terminal verwendet, das Zugriff auf die Befehlszeilenschnittstelle bietet. Zu den häufig verwendeten Terminals gehören Powershell und Bash. Mit dem Terminal können wir Befehle wie das Erstellen von Verzeichnissen, das Auflisten von Dateien und das Ausführen von Programmen ausführen. Paketmanager wie npm für Node.js und pip für Python können verwendet werden, um Software aus Repositorys über die Befehlszeile zu installieren. Git, ein Versionskontrollsystem, ist für die Verwaltung von Codeänderungen und die Zusammenarbeit mit anderen unerlässlich.
Um mit dem Codieren zu beginnen, benötigen Sie einen geeigneten Texteditor oder eine IDE, einen Sprachcompiler und Grundkenntnisse über Terminalbefehle. Visual Studio Code ist eine empfohlene Wahl für einen Texteditor oder eine IDE. Wenn Sie eine Programmiersprache installieren und sich mit Terminalbefehlen vertraut machen, können Sie Code schreiben und ausführen. Das Erlernen von Programmiersprachen erfordert das Verständnis ihrer Syntax, Umgebung und Konventionen. Verschiedene Sprachen weisen unterschiedliche Komplexitätsgrade auf, weisen jedoch alle Ähnlichkeiten in Struktur und Konzepten auf.
Die Druckausgabe in verschiedenen Programmiersprachen kann mithilfe von Funktionen oder Methoden erfolgen, die für jede Sprache spezifisch sind. Beispielsweise verfügt Python über die integrierte Druckfunktion, JavaScript über die Methode console.log und Java und C++ verfügen über eine eigene Syntax zum Drucken auf der Standardausgabe.
Variablen werden zum Speichern von Werten unterschiedlicher Datentypen verwendet. Variablen werden mit Werten deklariert, definiert und initialisiert. Programmiersprachen können statisch oder dynamisch typisiert sein und haben eine unterschiedliche Syntax für Variablen. Statische Typisierung erfordert eine explizite Deklaration des Variablentyps, dynamische Typisierung hingegen nicht. Variablen haben einen Gültigkeitsbereich, der bestimmt, wo in einem Programm auf sie zugegriffen und sie verwendet werden können. Der Geltungsbereich kann global oder lokal sein und ermöglicht eine bessere Organisation und Vermeidung von Fehlern.
Datentypen stellen verschiedene Arten von Daten dar, z. B. Zeichenfolgen, boolesche Werte, Ganzzahlen, Gleitkommazahlen, Zeichen und Arrays. Datenstrukturen bieten eine Möglichkeit, Daten zu organisieren und zu bearbeiten. Zu den beliebten Datenstrukturen gehören Arrays, Stacks, Heaps, Bäume, verknüpfte Listen, Hash-Tabellen, Hash-Maps und Diagramme. Arrays und Karten sind zwei häufig verwendete Datenstrukturen mit unterschiedlichen Anwendungen.
Zusammenfassend lässt sich sagen, dass Programmieren eine Kunst ist, die das Denken, Problemlösen und Gestalten der Welt durch Code umfasst. Dazu gehört die Verwendung von Texteditoren oder IDEs, das Ausführen von Code über Compiler oder Laufzeiten sowie das Verständnis von Terminalbefehlen und Versionskontrolle. Das Erlernen von Programmiersprachen erfordert das Verständnis von Syntax, Variablen, Datentypen und Datenstrukturen. Das Video bietet einen umfassenden Überblick über diese Konzepte, um Ihnen den Einstieg in Ihre Programmierreise zu erleichtern.
Die Kunst, Software zu schreiben
Die Kunst, Software zu schreiben
Computer sind wie Musikinstrumente sorgfältig gefertigte Maschinen, die darauf ausgelegt sind, bestimmte Aufgaben auf der Grundlage der erhaltenen Anweisungen auszuführen. Diese in Code geschriebenen Anweisungen sind die Software, die ihre Abläufe steuert. So wie die Notenschrift der von Komponisten verwendete Code ist, verwenden Computerprogrammierer Softwarecode, um Programme zu erstellen.
Programmieren kann eine Quelle der Freude und Zufriedenheit sein, ähnlich den Gefühlen, die Dichter oder Musiker empfinden. Frühe Computer waren faszinierend und beflügelnd für diejenigen, die Spaß an der Lösung von Problemen und der Komplexität hatten. Sie arbeiteten mit erstaunlicher Geschwindigkeit und waren in der Lage, ein breites Spektrum an Problemen zu lösen, solange sie mit den nativen Befehlen des Computers ausgedrückt wurden. Allerdings sind Computer von Natur aus dumm und benötigen genaue Anweisungen, um zu verstehen, was zu tun ist. Frühe Programmierer mussten Maschinensprache mit Zahlen schreiben, die binäre Befehle darstellten. Dieser Prozess war langwierig und fehleranfällig und führte zur Entwicklung benutzerfreundlicherer Programmiersprachen.
Die Einführung höherer Sprachen wie Fortran und COBOL machte die Programmierung leichter zugänglich. Programmierer könnten ihre Anweisungen mithilfe vertrauter wissenschaftlicher Formeln oder logischer Aussagen ausdrücken, die für sie Sinn ergeben. Anschließend wurden Compiler verwendet, um diese Anweisungen in die Binärsprache des Computers zu übersetzen. Dieser Durchbruch löste die Software-Revolution aus, da Programmierer nicht mehr die spezifische Maschinensprache jedes Computers lernen mussten.
Im Laufe der Jahre wurden Hunderte von Programmiersprachen entwickelt, um unterschiedlichen Anforderungen gerecht zu werden. Die Kluft zwischen diesen Sprachen und der Maschinensprache ist größer geworden, sodass sich Programmierer auf das konzentrieren können, was sie erreichen wollen, und nicht auf die Details auf niedriger Ebene. Je persönlicher das Rechnen wurde, desto vielfältiger und benutzerfreundlicher wurden die Programmiersprachen. Heutzutage kommunizieren Menschen routinemäßig mit Computern, indem sie ihnen sagen, was sie tun sollen, beispielsweise Durchschnittswerte berechnen oder Daten organisieren. Das Programmieren ist zu einem Werkzeug geworden, das es Einzelpersonen ermöglicht, Computersysteme individuell anzupassen und an ihre Bedürfnisse anzupassen.
Beim Schreiben von Software geht es nicht nur um das Codieren, sondern auch darum, zu definieren, wie Daten dargestellt und organisiert werden. Daten können je nach Anforderungen in Zeichenfolgen, Listen, Tabellen, Bäumen usw. organisiert werden. Die Wahl der Sprache und Datenstruktur ist entscheidend für die effektive Lösung von Programmierproblemen. Programmierer erstellen Schritt-für-Schritt-Verfahren, sogenannte Algorithmen, um Probleme zu lösen. Diese Algorithmen spezifizieren die Operationen, die erforderlich sind, um die gewünschten Ergebnisse zu erzielen. Allerdings kann es eine komplexe Aufgabe sein, den effizientesten Algorithmus für ein bestimmtes Problem zu finden. Es erfordert sorgfältiges Denken, Konzentration und manchmal umfassende Kenntnisse in Spezialgebieten.
Softwareentwicklung ist ein herausforderndes und kreatives Unterfangen, bei dem zahlreiche Aspekte gleichzeitig berücksichtigt werden müssen. Programmierer passen sich ständig den technologischen Fortschritten an und erweitern die Grenzen dessen, was Computer leisten können. Sie streben nach Eleganz und Kohärenz in ihrem Code und schaffen Software, die sowohl funktional als auch ästhetisch ansprechend ist. Durch ihre Bemühungen haben Softwareprogrammierer unsere Fähigkeiten erweitert und es uns ermöglicht, die riesigen Informationsmengen zu nutzen und auf eine Weise mit der Welt zu interagieren, die einst als magisch galt. Programmierung ist die treibende Kraft hinter der Funktionsfähigkeit von Computern und der Gestaltung der High-Tech-Welt, in der wir heute leben.
C++-Tutorial für Anfänger – Vollständiger Kurs
C++-Tutorial für Anfänger – Vollständiger Kurs
00:00:00 - 01:00:00 Dieses Video ist ein Tutorial für Anfänger, die lernen möchten, wie man in C++ programmiert. Es behandelt die Grundlagen der Arbeit mit Zeichenfolgen, Zahlen und Variablen. Außerdem wird das Konzept des Importierens von Code aus anderen Dateien vorgestellt.
01:00:00 - 02:00:00 In diesem C++-Tutorial für Anfänger wird erläutert, wie man einen Rechner mit vier Funktionen erstellt. Das Tutorial erklärt, wie man Daten eingibt, die Operatorgleichheit prüft und Code basierend auf dieser Bedingung ausführt.
02:00:00 - 03:00:00 Dieses Video bietet eine grundlegende Einführung in die C++-Programmierung, wobei der Schwerpunkt auf der Verwendung von for-Schleifen zur Berechnung eines bestimmten Ergebnisses liegt. Die demonstrierte Funktion berechnet das Ergebnis einer auf eine bestimmte Potenz gesteigerten Zahl.
03:00:00 - 04:00:00 In diesem C++-Tutorial für Anfänger zeigt der Kursleiter, wie man Vererbung nutzt, um die Funktionalität in einer Klassenhierarchie zu erweitern. Durch Vererbung kann eine Klasse die gleiche Funktionalität wie eine andere Klasse haben und diese Funktionalität gleichzeitig um zusätzliche Funktionen erweitern. Der Kursleiter zeigt außerdem, wie man geerbte Funktionen überschreibt, um das Verhalten einer Klasse zu ändern.
Teil 1
- 00:00:00 In diesem Video-Tutorial lernen Anfänger, wie man grundlegenden C++-Code schreibt. Der erste Schritt besteht darin, einen Texteditor und einen C++-Compiler zu installieren, die beide im Codeblocks-Paket enthalten sind. Anschließend zeigt das Tutorial, wie man ein einfaches Projekt in Codeblöcken einrichtet.
- 00:05:00 Dieses Tutorial bietet eine kurze Einführung in die Programmiersprache C++ und die zum Schreiben und Ausführen von C++-Programmen erforderlichen Tools. Der erste Teil des Tutorials zeigt, wie man die notwendigen Tools auf einem Mac installiert, und im zweiten Teil geht es darum, wie man ein neues C++-Projekt in Codeblöcken erstellt.
- 00:10:00 In diesem Video-Tutorial führt der Moderator die Grundlagen des Schreibens eines C++-Programms durch. Er geht auf die Notwendigkeit eines C++-Projekts und einer C++-Datei ein, erklärt Funktionen und zeigt, wie man ein Programm erstellt und ausführt.
- 00:15:00 In diesem Tutorial wird erklärt, wie man grundlegenden Code in C++ schreibt und wie man Druckanweisungen verwendet, um Informationen an die Konsole auszugeben.
- 00:20:00 In diesem Video zeigt der Moderator, wie nützlich Variablen beim Programmieren sind, indem er ein Beispiel für ein Programm liefert, das eine Geschichte ausdruckt. Der Moderator zeigt dann, wie man eine Variable mit dem Namen „Charaktername“ erstellt und ihr einen Wert zuweist, in der der Name des Charakters gespeichert wird. Als Nächstes zeigt der Moderator, wie man eine Variable namens „age“ erstellt und ihr einen Wert zuweist, der das Alter der Figur speichert. Abschließend demonstriert der Moderator, wie eine Variable zum Speichern mehrerer Daten verwendet wird.
- 00:25:00 In diesem Video stellt der Moderator das Konzept von Variablen vor und zeigt, wie man sie zum Speichern von Daten in einem Programm verwendet. Sie zeigen, wie man mit print-Anweisungen auf die in Variablen gespeicherten Daten zugreift und diese manipuliert. Schließlich zeigen sie, wie man eine Variable in eine Druckanweisung einfügt, sodass die Daten in einer separaten Zeichenfolge gedruckt werden.
- 00:30:00 Dieses Video stellt das Konzept von Variablen und Datentypen in C++ vor. Eine Variable ist ein Container, der Daten speichert, und Sie können ihn zum Speichern jeder Art von Informationen verwenden. Zeichenfolgen sind ein häufiger Variablentyp und bestehen aus einer Zeichenfolge. Sie können auch Ganzzahlen zum Speichern ganzer Zahlen oder negative Ganzzahlen zum Speichern negativer Zahlen verwenden. Sie können Dezimalzahlen auch in Ganzzahlen speichern.
- 00:35:00 Dieses Tutorial behandelt die Grundlagen der Programmierung mit C++, angefangen bei einfachem Text und Zahlen bis hin zu komplexeren Datentypen wie Zeichenfolgen und booleschen Werten.
- 00:40:00 In diesem Video erfahren Sie, wie Sie mit den C++-String-Funktionen Länge und String-Indizierung Strings drucken und die Position bestimmter Zeichen in einem String bestimmen und wie Sie bestimmte Zeichen in einem String ändern.
- 00:45:00 Das Video behandelt die Grundlagen der Arbeit mit Strings in C++, einschließlich der Übergabe von Argumenten an Funktionen und der Verwendung verschiedener mathematischer Funktionen zur Manipulation von Strings.
- 00:50:00 In diesem C++-Tutorial werden die Grundlagen von Zahlen, Addition, Subtraktion, Multiplikation und Division behandelt. Außerdem wird der Moduloperator eingeführt, der für die Division zweier Zahlen und die Berechnung des Rests nützlich ist. Abschließend wird das Speichern von Zahlen in Variablen demonstriert.
- 00:55:00 Dieses C++-Tutorial für Anfänger erklärt, wie man mathematische Funktionen zur Lösung von Problemen verwendet. Zu den Funktionen gehören Quadratwurzel, Pow und Runde. Außerdem wird das Importieren von Code aus anderen Dateien erläutert.
Teil 2
- 01:00:00 In diesem C++-Tutorial für Anfänger wird der Benutzer aufgefordert, sein Alter und seinen Namen einzugeben. Das Programm speichert die Informationen dann in einer Variablen namens „Alter“ und gibt den Namen und das Alter des Benutzers aus.
- 01:05:00 Dieses Video-Tutorial zeigt, wie man einen einfachen Taschenrechner in C++ erstellt und wie man ein Mad Libs-Spiel erstellt.
- 01:10:00 In diesem Video wird erläutert, wie Arrays in C++ erstellt und verwendet werden. Arrays ähneln Variablen, können jedoch mehrere Werte enthalten.
- 01:15:00 Dieses Video-Tutorial erklärt die Grundlagen von Arrays in C++. Ein Array ist ein Container, der mehrere Datenelemente speichern kann, und Sie können über den Index oder durch Zuweisen eines Werts zur „Size“-Eigenschaft des Arrays auf einzelne Elemente zugreifen.
- 01:20:00 In diesem Tutorial zeigt der Autor, wie man eine Funktion in C++ erstellt. Eine Funktion ist ein Codeblock, der eine bestimmte Aufgabe ausführt und im gesamten Programm wiederverwendet werden kann. Der Rückgabetyp der Funktion kann entweder void oder eine Ganzzahl sein. Der Autor zeigt auch, wie man eine Funktion aufruft.
- 01:25:00 In diesem Video erklärt der Autor, wie Funktionen funktionieren und wie sie wiederverwendet werden können. Außerdem zeigt er, wie man eine Funktionssignatur erstellt und wie man eine Funktion mithilfe ihrer Signatur aufruft. Abschließend geht er auf Rückgaben in C++ ein, bei denen eine Funktion Informationen an den Aufrufer zurückgibt.
- 01:30:00 Im Video wird erläutert, wie Funktionen in C++ erstellt werden und wie das Schlüsselwort „return“ verwendet wird, um anzugeben, dass die Ausführung der Funktion abgeschlossen ist. Das Video zeigt außerdem, wie Sie die Cube-Funktion verwenden, um das Ergebnis des Würfelns einer Zahl zurückzugeben.
- 01:35:00 In diesem Tutorial bringt der Autor Anfängern die if-Anweisung in C++ bei. Eine if-Anweisung ist eine Programmierstruktur, die es einem Programm ermöglicht, auf verschiedene Situationen zu reagieren. Der Autor demonstriert, wie man eine if-Anweisung zum Überprüfen von Bedingungen verwendet und wie man komplexere if-Anweisungen erstellt.
- 01:40:00 In diesem Video-Tutorial wird erklärt, wie Sie die Operatoren „and“ und „or“ in C++ verwenden, um zwei Bedingungen zu überprüfen. Wenn eine der Bedingungen falsch ist, ist der gesamte if-Block falsch und der Code wird nicht ausgeführt.
- 01:45:00 In diesem Tutorial bringt der Autor Anfängern if-Anweisungen bei und erklärt, wie man Vergleiche verwendet, um wahre oder falsche Werte zu erstellen. Die Funktion verwendet zwei Zahlen als Eingabe und gibt die größte zurück.
- 01:50:00 In diesem Video wird erklärt, wie Vergleiche in C++ funktionieren und wie man mit „größer als“, „kleiner als“ und „gleich“ prüft, ob zwei Zahlen gleich oder größer oder gleich sind.
- 01:55:00 In diesem C++-Tutorial für Anfänger erfahren Sie, wie Sie einen Rechner mit vier Funktionen erstellen, einschließlich der Eingabe von Daten, der Überprüfung der Operatorgleichheit und der Ausführung von Code basierend auf dieser Bedingung.
Teil 3
- 02:00:00 In diesem Video-Tutorial wird eine Funktion zum Konvertieren einer Ganzzahl in einen Wochentag demonstriert. Die Funktion wird erstellt und eine if-Anweisung wird verwendet, um zu bestimmen, ob die angegebene Tageszahl eins oder größer ist. Wenn es eins ist, gibt die Funktion „Sonntag“ zurück; Wenn es keiner ist, gibt die Funktion „Montag“ zurück.
- 02:05:00 In diesem Video wird erklärt, wie eine Switch-Anweisung verwendet werden kann, um den Code in einer if-Anweisung effizienter zu gestalten. Das Video erklärt weiter, wie man für jeden Wochentag eine Switch-Anweisung erstellt, und demonstriert die Funktion, indem der Wochentag für eine als Eingabe übergebene Zahl gedruckt wird.
- 02:10:00 Dieses Video bietet einen Überblick über das Video „C++-Tutorial für Anfänger – Vollständiger Kurs“. Das Video zeigt, wie Sie eine While-Schleife verwenden, um einen Codeblock zu durchlaufen, während eine Bedingung erfüllt ist.
- 02:15:00 Dieses C++-Tutorial für Anfänger behandelt die Grundlagen von Schleifen, einschließlich der Erstellung einer While-Schleife und einer Do-While-Schleife. Das Video bespricht auch eine Endlosschleife und wie man sie vermeidet. Abschließend wird eine for-Schleife demonstriert.
- 02:20:00 Dieses Tutorial zeigt, wie man ein Ratespiel mit einer While-Schleife und einer Do-While-Schleife erstellt. Das Spiel ist zunächst in dem Sinne unfair, dass der Benutzer unbegrenzt raten kann, aber das Tutorial zeigt, wie man das Spiel fairer gestalten kann, indem man ein Ratelimit festlegt.
- 02:25:00 In diesem Video erklärt der Autor, wie For-Schleifen funktionieren und wie sie in C++ verwendet werden können. Er zeigt auch ein Beispiel dafür, wie for-Schleifen zur Lösung eines Problems verwendet werden können.
- 02:30:00 In diesem Video erklärt der Autor die while-Schleife, ein Schleifenkonstrukt, bei dem sich eine Variable bei jeder Ausführung ändert. Die for-Schleife ist ein ähnliches Konstrukt, enthält jedoch eine Variablendeklaration, eine Initialisierung und eine Schleifenbedingung.
- 02:35:00 Dieses Video-Tutorial zeigt, wie man for-Schleifen verwendet, um den Inhalt von Arrays zu durchlaufen, und wie man eine Funktion erstellt, die eine Zahl in eine bestimmte Potenz bringt.
- 02:40:00 Dieses Video-Tutorial bietet eine grundlegende Einführung in die C++-Programmierung, wobei der Schwerpunkt auf der Verwendung von for-Schleifen zur Berechnung eines bestimmten Ergebnisses liegt. Die demonstrierte Funktion berechnet das Ergebnis einer auf eine bestimmte Potenz gesteigerten Zahl.
- 02:45:00 In diesem Tutorial zeigt der Autor, wie man ein zweidimensionales Array erstellt und verwendet und erläutert, wie man auf darin enthaltene Elemente zugreift.
- 02:50:00 Dieses Video-Tutorial stellt die Sprache C++ vor und zeigt, wie man for- und int-Iteratoren verwendet, um Datenarrays zu durchlaufen. Die verschachtelten for-Schleifen ermöglichen eine einfache Iteration von Daten innerhalb von Arrays.
- 02:55:00 In diesem Video wird erklärt, was ein Zeiger ist, wie nützlich er ist und wie man ihn in C++ erstellt.
Teil 4
- 03:00:00 Dieses Video bietet eine anfängerfreundliche Einführung in die C++-Programmierung mit Beispielen für die Verwendung von Variablen und Konstanten zum Speichern von Informationen. Das Video zeigt auch, wie man auf Speicheradressen zugreift, um darin gespeicherte Informationen abzurufen.
- 03:05:00 Dieses Video bietet einen Überblick über das Video „C++-Tutorial für Anfänger – Vollständiger Kurs“. Im Video demonstriert der Moderator, wie man mithilfe von Zeigern auf Speicheradressen von Variablen zugreift. Ein Zeiger ist lediglich eine Speicheradresse, bei der es sich lediglich um einen Datentyp handelt, und Sie können ihn verwenden, um einen Zeiger auf eine andere Variable zu speichern.
- 03:10:00 Dieses Tutorial erklärt, wie man Zeiger in der Programmierung verwendet und zeigt, wie man sie dereferenziert, um auf den an einer bestimmten Speicheradresse gespeicherten Wert zuzugreifen. Darüber hinaus werden im Tutorial Klassen und Objekte in C++ erläutert und gezeigt, wie eine Klasse erstellt und verwendet wird.
- 03:15:00 In diesem Video, einem C++-Tutorial für Anfänger, erstellt der Autor eine Klasse zur Darstellung von Büchern. Die Klasse hat zwei Attribute, den Titel und den Autor. Anschließend erstellt der Autor ein Buchobjekt und legt den Titel und den Autor fest.
- 03:20:00 In diesem Video lernen Anfänger, wie man Objekte in C++ erstellt und mit ihnen arbeitet. Ein Objekt ist eine tatsächliche Instanz einer Klasse und eine Klasse ist die Vorlage für einen Datentyp. Objekte können gedruckt und ihre Werte geändert werden.
- 03:25:00 In diesem Video wird erklärt, wie Konstruktoren in C++ funktionieren und wie sie zum Initialisieren von Objekten mit Standardwerten verwendet werden können.
- 03:30:00 In diesem Video-Tutorial wird erläutert, wie Sie einen C++-Konstruktor erstellen, der Titel, Autor und Seiten als Eingabewerte akzeptiert. Nach der Initialisierung kann der Konstruktor zum Erstellen eines neuen Objekts verwendet werden, ohne jedes Mal die Werte übergeben zu müssen.
- 03:35:00 In diesem Video wird erläutert, wie Funktionen in C++ verwendet werden, um festzustellen, ob ein Student Auszeichnungen erhält oder nicht. Funktionen sind Vorlagen, die jedes Objekt verwenden kann, um je nach GPA des Objekts „true“ oder „false“ zurückzugeben.
- 03:40:00 In diesem Video lernen Anfänger, wie man Getter und Setter in C++-Klassen verwendet. Mit Gettern und Settern können Sie den Zugriff auf Attribute und Elemente in Ihren Klassen steuern. Dieses Beispiel zeigt, wie mithilfe von Gettern und Settern eine gültige Bewertung für einen Film erzwungen wird.
- 03:45:00 In diesem C++-Tutorial für Anfänger zeigt der Autor, wie man Getter und Setter verwendet, um die Bewertungen einzuschränken, die einem Filmobjekt zugewiesen werden können. Wenn die übergebene Bewertung keine der gültigen Bewertungen ist, wird ein Fehler ausgegeben oder die Bewertung wird nicht festgelegt.
- 03:50:00 In diesem Video erklärt der Autor, wie man mit C++ Bewertungen für Videos festlegt. Zunächst erklären sie, wie Bewertungen in C++ dargestellt werden, wobei eine Bewertung einem positiven Wert wie 13 oder einem negativen Wert wie -3 entspricht. Als Nächstes zeigen sie, wie man mithilfe einer Funktion namens „Bewertung festlegen“ eine Bewertung für ein Video festlegt. Diese Funktion benötigt einen Parameter, einen String, der die Bewertung darstellt. Wenn die eingegebene Bewertung ungültig ist, gibt die Funktion eine Zeichenfolge zurück, die die nicht bewertete Bewertung darstellt. Abschließend demonstriert der Autor, wie man die Bewertung für ein Video mithilfe einer Funktion namens „Get Rating“ ausdruckt. Diese Funktion benötigt keine Parameter und gibt lediglich die Bewertung für das Video zurück.
- 03:55:00 In diesem C++-Tutorial für Anfänger zeigt der Kursleiter, wie man Funktionen erbt und wie man sie in einer Klassenhierarchie überschreibt. Dadurch kann eine Klasse die gleiche Funktionalität wie eine andere Klasse haben und diese Funktionalität gleichzeitig um zusätzliche Funktionen erweitern.
Einführung in Programmierung und Informatik – Vollständiger Kurs
Einführung in Programmierung und Informatik – Vollständiger Kurs
Dieses Video ist ein Leitfaden für Einsteiger in die Programmierung und Informatik für diejenigen, die wenig bis gar keine Kenntnisse im Programmieren haben. Es behandelt grundlegende Konzepte und Techniken, die für jede Programmiersprache gelten. Das Video erklärt die Grundlagen des Codeschreibens in einer integrierten Entwicklungsumgebung (IDE) und betont die Bedeutung der Programmiergrammatik.
Zu den im Video behandelten Themen gehören:
- Einführung in die Programmierung und Informatik, einschließlich Syntax und Programmierregeln.
- Verwenden der Konsole zum Ausgeben von Text aus einem Programm.
- Grundlegende mathematische Operationen und der Moduloperator in der Programmierung.
- Drucken von Zeichenfolgen auf der Konsole.
- Variablen, Datentypen und Namenskonventionen verstehen.
- Wie Variablen in Programmen definiert, referenziert und manipuliert werden.
- Erkunden von if-Anweisungen, elsif-Anweisungen und else-Anweisungen für die bedingte Ausführung.
- Einführung von Arrays als Möglichkeit zum Speichern verwandter Variablen.
- Grundlagen von Schleifen, einschließlich for-Schleifen, while-Schleifen und do-while-Schleifen.
- Verschiedene Arten von Programmierfehlern verstehen: Syntaxfehler, Laufzeitfehler und Logikfehler.
- Debugging-Techniken, z. B. die Verwendung von Druckanweisungen, Haltepunkten und Kommentaren.
- Strategien zur Fehlervermeidung in der Programmierung.
- Arbeiten mit Funktionen, um Code zu organisieren und Wiederholungen zu reduzieren.
- Importieren von Funktionen aus Bibliotheken und Benennungskonventionen für Funktionen.
- Verschiedene Arten von Funktionen und ihre Zwecke.
- Einführung in Wörterbücher als flexible Datenspeichermöglichkeit.
- Überblick über Suchalgorithmen, einschließlich linearer Suche und binärer Suche.
- Rekursive Programmierung und ihre Anwendungsfälle, einschließlich des Basisfallkonzepts.
- Soft Skills für die Informatik, wie Problemlösung und Planung.
- Verwendung von Pseudocode als Planungstool zum Schreiben von Code.
- Verschiedene Methoden zum Planen und Schreiben von Code, einschließlich Flussdiagrammen und chronologischer Planung.
- Überblick über Programmiersprachen und verfügbare Ressourcen zum Lernen.
Das Video bietet eine umfassende Einführung in die Programmierung und Informatik und bietet den Zuschauern die notwendige Grundlage für den Beginn ihrer Programmierreise. Außerdem werden zusätzliche Ressourcen und Websites vorgeschlagen, um das Thema weiter zu erforschen.
- 00:00:00 Dieses Video deckt die Hauptpunkte des Videos ab, das für diejenigen gedacht ist, die sich für Informatik und Programmierung interessieren, aber keine Ahnung haben, wo sie anfangen sollen, und wenig bis gar keine Hintergrundinformationen zum Programmieren haben. Das Video behandelt die Grundlagen der Computerprogrammierung, die auf alle Programmiersprachen angewendet werden können, die Sie lernen möchten.
- 00:05:00 In diesem Video werden die Grundlagen der Programmierung, das Schreiben von Code in einer integrierten Entwicklungsumgebung (IDEs) und die Bedeutung der Programmiergrammatik erläutert.
- 00:10:00 Dieses Video führt in die Programmierung und Informatik ein und behandelt die Grundlagen der Syntax und Programmierregeln. Der Hauptzweck der Konsole besteht darin, Text aus dem Programm auszugeben.
- 00:15:00 Dieses Video behandelt grundlegende Mathematik, einschließlich Arithmetik, Addition, Subtraktion, Multiplikation und Division sowie Modul, einen grundlegenden Operator in vielen Programmiersprachen. Es behandelt auch das Drucken von Zeichenfolgen auf der Konsole.
- 00:20:00 Dieses Video stellt Programmier- und Informatikkonzepte vor, einschließlich Variablen, Typen und Namen. Zu den primitiven Variablen gehören Ganzzahlen, Boolesche Werte, Gleitkommazahlen und Doppelzahlen. String-Variablen speichern Zeichenfolgen. Char-Variablen enthalten ein Zeichen. Variablen sind wichtig, um Informationen in einem Format zu speichern, auf das leicht verwiesen werden kann.
- 00:25:00 In diesem Video wird erläutert, was passiert, wenn wir Variablen definieren oder erstellen, wie wir auf sie verweisen und wie wir sie für unsere Programme manipulieren. Die wichtigsten Punkte, die man mitnehmen sollte, sind, dass Variablen einfach Speicherplätze sind, die einen bestimmten Wert speichern, und dass wir die Zahlen aktualisieren können und ihre Position im gesamten Code konstant bleibt.
- 00:30:00 Eine Variable ist ein Ort, an dem Sie beim Programmieren Informationen speichern können. Namenskonventionen für Variablen sind wichtig für die Lesbarkeit. Wenn eine Bedingung in einer if-Anweisung wahr ist, wird der Code in den geschweiften Klammern ausgeführt. Es gibt zwei zusätzliche Anweisungen, elsif und eltons, die ähnlich wie if-Anweisungen funktionieren. Wenn die Bedingung in elsif wahr ist, wird der Code nach elsif ausgeführt. Ansonsten folgt der Code elsif
wird übersprungen. Wenn die Bedingung in elsif nicht wahr ist, wird der Code nach elsif übersprungen und der Code nach der if-Anweisung ausgeführt. - 00:35:00 Ein Array ist eine Liste von Variablen, die miteinander in Beziehung stehen. Sie sind nützlich, wenn ein Programmierer viele Variablen speichern möchte, die Informationen enthalten, die alle miteinander in Beziehung stehen.
- 00:40:00 Ein Einführungskurs in die Programmierung und Informatik behandelt Arrays, Indizes, Größe und Arrays innerhalb von Arrays. Auch Schleifen werden abgedeckt.
- 00:45:00 Dieses Video behandelt die verschiedenen Arten von Schleifen, for-, while- und do while-Schleifen. Es erklärt, wie man eine Bedingung für eine Schleife einrichtet und wie man eine Endlosschleife vermeidet.
- 00:50:00 Dieses Video behandelt die drei Arten von Fehlern, die beim Programmieren auftreten können: Syntaxfehler, Laufzeitfehler und Logikfehler. Syntaxfehler lassen sich am einfachsten beheben, da sie normalerweise innerhalb von Sekunden behoben werden können. Laufzeitfehler werden durch Anweisungen in Ihrem Code verursacht, die logisch sinnvoll erscheinen, der Computer jedoch physisch nicht in der Lage ist, die Aufgabe in angemessener Zeit abzuschließen. Logikfehler sind am ärgerlichsten und am schwierigsten zu debuggen, da sie häufig dazu führen können, dass Programme nicht wie vorgesehen funktionieren. Um Ihren Code zu debuggen, sollten Sie ihn inkrementell testen und nach Syntax- und Laufzeitfehlern suchen.
- 00:55:00 Wenn Sie auf einen Fehler in Ihrem Code stoßen, können Sie mithilfe von Druckanweisungen und der Konsole ermitteln, wo im Code ein Fehler auftritt, Haltepunkte verwenden, um die Fehlerursache aufzuspüren, und Kommentare zum Markieren verwenden Code, der für Sie und nicht für den Computer bestimmt ist. Abschließend werden Strategien zur Fehlervermeidung diskutiert.
- 01:00:00 In diesem Video behandelt der Dozent die Grundlagen der Programmierung und Informatik, einschließlich Fehler und Funktionen. Anschließend erklärt er, wie Argumente in einer Funktion funktionieren und wie man Funktionen verwendet, um Wiederholungen im Code zu reduzieren.
- 01:05:00 In dieser Videoeinführung in Programmierung und Informatik werden die vier verschiedenen Arten von Funktionen, ihre Zwecke und deren Verwendung in Ihrem Code erläutert. Funktionen können hilfreich sein, um Code zu organisieren, Zeit zu sparen und große Änderungen am Code vorzunehmen, ohne das gesamte Programm durchgehen zu müssen.
- 01:10:00 In diesem Video werden die Grundlagen der Programmierung und Informatik vorgestellt. Das Importieren von Funktionen aus Bibliotheken wird erläutert und Regeln für die Benennung von Funktionen werden besprochen. Außerdem werden Regeln zum Erstellen von Funktionen basierend auf Typ und Anzahl der Argumente eingeführt.
- 01:15:00 In diesem Video erklärt der Dozent die Grundlagen der Programmierung und Informatik, einschließlich Funktionen, Umfang und Argumentübergabe. Er behandelt auch, wie man Funktionen erstellt, die keine Werte zurückgeben.
- 01:20:00 In diesem Video bespricht der Moderator Arrays, Funktionen und Wörterbücher. Arrays sind wie zusammen gespeicherte Wertelisten, und Funktionen geben abhängig vom eingeschlagenen Pfad eine Variable zurück. Ein kleines Detail, das Sie beachten sollten, ist, dass Sie einen Variablentyp nicht zurückgeben können, wenn Sie die Funktion bereits so definiert haben, dass sie einen anderen Typ zurückgibt. Array-Listen wachsen von selbst, wenn die Größe der Liste 10 Elemente überschreitet, und Wörterbücher speichern mehrere Werte.
- 01:25:00 Ein Computer speichert Daten auf unterschiedliche Weise, was schwer zu verstehen sein kann. Ein Wörterbuch ist eine Art Datenspeicher, der flüssiger und einfacher zu organisieren ist als herkömmliche Arrays. Suchalgorithmen werden verwendet, um schnell ein bestimmtes Datenelement in einer Werteliste zu finden.
- 01:30:00 Dieses Video stellt das Konzept von Suchalgorithmen und ihre Effizienz vor. Die lineare Suche ist ein guter Basisalgorithmus für unsortierte Listen, im schlimmsten Fall jedoch ineffizient. Die binäre Suche ist ein effizienter Suchalgorithmus für sortierte Listen, der sich die Tatsache zunutze macht, dass die Liste sortiert ist.
- 01:35:00 Der binäre Suchalgorithmus ist schneller und effizienter als eine lineare Suche, um ein Element in einer sortierten Liste zu finden. Die rekursive Funktion ist ein Beispiel für eine rekursive Programmieranweisung. Der Basisfall für eine rekursive Anweisung ist ein bestimmter Wert, den alle rekursiven Anweisungen erfüllen müssen. Wenn n nicht kleiner oder gleich eins ist, gibt die rekursive Anweisung die Summe von n und dann den Rückgabewert der rekursiven Summenmethode minus eins zurück.
- 01:40:00 Dieses Video führt in die Programmierung und Informatik ein und erklärt, warum Rekursion eine nützliche Technik ist. Zu den für die Informatik erforderlichen Soft Skills gehören Problemlösung und Planung. Pseudocode ist eine vereinfachte Form der Programmierung, die bei dieser Planung helfen kann.
- 01:45:00 Pseudocode ist eine visuelle Möglichkeit, Computercode zu planen, ähnlich dem Erstellen einer Gliederung für eine Arbeit. Flussdiagramme und das Aufschreiben, was das Programm chronologisch tun soll, sind zwei gängige Methoden.
- 01:50:00 Dieses Video stellt Programmier- und Informatikkonzepte vor, einschließlich der verschiedenen Methoden zum Planen und Schreiben von Code und der Bedeutung von Pseudocode. Es behandelt auch verschiedene Programmiersprachen und deren Verwendung.
- 01:55:00 In dieser Serie behandelt der Autor die Grundlagen der Programmierung, einschließlich Syntax und Regeln, und lehrt, wie man eine bestimmte Sprache lernt. Er stellt außerdem Websites und Ressourcen zur Verfügung, die Ihnen den Einstieg erleichtern.
C++-Programmierkurs – Anfänger bis Fortgeschrittene
C++-Programmierkurs – Anfänger bis Fortgeschrittene
Der Kurs behandelt verschiedene Aspekte der C++-Programmierung.
Die behandelten Themen:
-
Einrichten einer C++-Entwicklungsumgebung: Die Videos bieten einen Überblick über die Einrichtung einer C++-Entwicklungsumgebung auf verschiedenen Plattformen. Dazu gehört die Installation verschiedener Compiler und die Konfiguration von Visual Studio Code für die Verwendung der Compiler und der C++-Standardbibliothek. Die Anweisungen decken Plattformen wie Windows, Mac und Linux ab.
-
Grundlagen der Programmierung in C++: Die Videos behandeln grundlegende Konzepte wie Variablen, Datentypen, Funktionen und Flusskontrollanweisungen. Sie erklären, wie man Variablen deklariert, Funktionen definiert und Kontrollstrukturen wie Schleifen und bedingte Anweisungen verwendet. In den Videos werden auch Konzepte wie Kommentare und die Hauptfunktion in C++ vorgestellt.
-
String-Manipulation: Spezielle Videos konzentrieren sich auf die Arbeit mit Strings in C++. Sie erklären, wie man Strings mit Funktionen wie strcmp und strcat vergleicht und verkettet. Die Videos zeigen auch, wie man Strings mit der strcpy-Funktion kopiert.
-
Arrays: Die Videos stellen das Konzept von Arrays in C++ vor. Sie behandeln Themen wie das Deklarieren und Initialisieren von Arrays, den Zugriff auf Elemente mithilfe von Zeigern und das Drucken von Zeichenarrays.
-
Dynamische Speicherzuweisung und Zeiger: In diesen Videos wird erläutert, wie Speicher in C++ verwaltet wird und wie dynamische Speicherzuweisungstechniken verwendet werden, um einem Programm zusätzlichen Speicher zuzuweisen. Sie behandeln die Konzepte von Zeigern, Speicherkarten und Speicherverwaltungseinheiten. In den Videos wird außerdem erläutert, wie man Zeiger sicher verwendet, Abstürze vermeidet und mit mehreren Zeigern umgeht, die auf denselben Speicherort verweisen.
-
Funktionsvorlagen und Lambda-Funktionen: Die Videos erklären, wie man generische Funktionen mithilfe von Funktionsvorlagen in C++ erstellt. Sie zeigen, wie der Compiler Funktionsdefinitionen basierend auf den übergebenen Parametertypen generieren kann. Darüber hinaus behandeln die Videos Lambda-Funktionen, bei denen es sich um anonyme Funktionen handelt, die aufgerufen werden können, ohne ihnen einen Namen zu geben. Sie erläutern die Syntax und die Spezifikation des Rückgabetyps für Lambda-Funktionen.
-
Klassen und Vererbung: Diese Videos stellen das Konzept von Klassen in C++ vor und erklären, wie Mitgliedsvariablen und Funktionen innerhalb einer Klasse definiert werden. Sie behandeln Themen wie Konstruktoren, Destruktoren, Zugriffsspezifizierer (geschützt und privat) und die Verwendung statischer und dynamischer Bindung zur Erzielung von Polymorphismus. Die Videos zeigen auch, wie abgeleitete Klassen basierend auf bereits vorhandenen Klassen mithilfe von Vererbung erstellt und verwendet werden.
-
Debuggen und Fehlerbehandlung: Die Videos bieten Anleitungen zum Debuggen von C++-Programmen. Sie erklären, wie man Haltepunkte setzt, Variablen im lokalen Bereich untersucht und Fehler im Zusammenhang mit nicht initialisierten Zeigern und Speicherlecks behandelt. Die Videos behandeln auch Konzepte wie Objekt-Slicing und das Überschreiben von Basisklassenkonstruktoren.
-
Schnittstellen und Polymorphismus: Einige Videos konzentrieren sich auf Schnittstellen und Polymorphismus in C++. Sie erklären, wie dynamische Bindungen, Referenzen und das Schlüsselwort override verwendet werden, um polymorphes Verhalten in Programmen zu erreichen. In den Videos wird auch der finale Spezifizierer besprochen, der verwendet werden kann, um eine virtuelle Methode als final zu markieren und zu verhindern, dass sie in abgeleiteten Klassen überschrieben wird.
-
Weitere Themen: Zu den weiteren behandelten Themen gehören Standardparameter, eine in Streams einfügbare Schnittstelle zum automatischen Drucken von Ausgabestreams und die Verwendung von Schnittstellen zur Erstellung besser lesbaren Codes.
Das Video bietet Schritt-für-Schritt-Anleitungen, Demonstrationen und Erklärungen, um Anfängern das Erlernen der C++-Programmierung von der Installation und Konfiguration bis hin zu fortgeschritteneren Konzepten wie objektorientierter Programmierung, Speicherverwaltung und Polymorphismus zu erleichtern. Die Inhalte eignen sich sowohl für Einsteiger, die die Grundlagen der C++-Programmierung erlernen möchten, als auch für erfahrene Programmierer, die ihre Kenntnisse auffrischen oder bestimmte Themen vertiefen möchten.
Code: https://github.com/rutura/The-C-20-Masterclass-Source-Code
Kapitel 1: Einrichten der Tools
- 00:04:32 C++-Entwicklungstools
- 00:11:06 Installieren von C++-Compilern unter Windows
- 00:24:27 VS-Code unter Windows installieren
- 00:28:00 Konfigurieren von Visual Studio-Code für C++ unter Windows
- 00:57:27 C++-Compiler unter Linux installieren
- 01:04:02 Visual Studio-Code unter Linux installieren
- 01:07:40 Konfigurieren von Visual Studio-Code für C++ unter Linux
- 01:22:45 C++-Compiler unter MacOS installieren
- 01:28:07 Visual Studio-Code unter MacOS installieren
- 01:30:16 Konfigurieren von Visual Studio-Code für C++ unter MacOS
- 01:35:37 Online-Compiler
Kapitel 2: Eintauchen
- 01:43:01 Ihr erstes C++-Programm
- 01:55:56 Kommentare
- 02:01:56 Fehler und Warnungen
- 02:13:12 Anweisungen und Funktionen
- 02:31:34 Eingabe Ausgabe
- 02:49:57 C++-Programmausführungsmodell und Speichermodell
- 02:56:42 C++-Kernsprache VS. Standardbibliothek VS. STL
Kapitel 3: Variablen und Datentypen
- 03:00:47 Einführung in Variablen und Datentypen
- 03:05:05 Zahlensysteme
- 03:21:52 Ganzzahlen
- 03:40:44 Ganzzahlmodifikatoren
- 03:54:00 Bruchzahlen
- 04:16:39 Boolesche Werte
- 04:24:49 Zeichen und Text
- 04:32:05 Automatisch
- 04:38:06 Aufgaben
- 04:45:42 Zusammenfassung der Variablen und Datentypen
Kapitel 4: Operationen an Daten
- 04:46:45 Operationen zur Dateneinführung
- 04:47:31 Grundlegende Operationen
- 04:58:01 Vorrang und Assoziativität
- 05:12:06 Präfix und Postfix + & -
- 05:23:22 Zusammengesetzte Operatoren
- 05:31:43 Relationale Operatoren: Dinge vergleichen
- 05:40:51 Logische Operatoren
- 05:56:09 Ausgabeformatierung
- 06:33:26 Numerische Grenzwerte
- 06:41:10 Mathematische Funktionen
- 06:54:23 Seltsame Integraltypen
- 06:59:41 Operationen zur Datenzusammenfassung
- 07:01:58 Flusskontrolle: Einführung in die bedingte Programmierung
- 07:03:30 If-Anweisung
- 07:20:49 Sonst wenn
- 07:28:46 Wechsel
- 07:42:44 Ternärer Operator
- 07:52:20 Flusskontrolle: Bedingte Programmierung Zusammenfassung Kapitel 6: Schleifen
- 07:53:49 Loops Einführung
- 07:55:20 For-Schleife
- 08:25:20 While-Schleife
- 08:36:54 While-Schleife ausführen
- 08:47:08 Einführung in Arrays
- 08:48:45 Arrays deklarieren und verwenden
- 09:15:53 Größe eines Arrays
- 09:26:44 Arrays von Zeichen
- 09:46:46 Grenzen eines Arrays
- 09:53:23 Hinweise Einführung
- 09:56:03 Zeiger deklarieren und verwenden
- 10:14:48 Zeiger auf Char
- 10:27:26 Programmspeicherzuordnung
- 10:36:30 Dynamische Speicherzuweisung
- 11:05:45 Baumelnde Zeiger
- 11:24:15 Wenn Neues scheitert
- 11:38:00 Nullzeigersicherheit
- 11:45:18 Speicherlecks
- 11:55:44 Dynamische Arrays
- 12:11:04 Referenzen Einführung
- 12:11:58 Referenzen deklarieren und verwenden
- 12:22:28 Referenzen mit Zeigern vergleichen
- 12:37:25 Referenzen und Konst
Kapitel 10: Zeichenmanipulation und Zeichenfolgen
- 12:44:29 Einführung in Zeichenmanipulation und Zeichenfolgen
- 12:46:24 Zeichenmanipulation
- 13:09:28 C-String-Manipulation
- 13:41:42 C-String-Verkettung und Kopieren
- 14:01:19 Einführung von std::string
- 14:03:38 std::string deklarieren und verwenden
- 14:12:47 Eine Definitionsregel
- 14:28:25 Funktionen aus erster Hand
- 15:00:50 Funktionsdeklaration und -definition
- 15:15:30 Funktionen über mehrere Dateien hinweg – Kompilierungsmodell überarbeitet
- 15:42:30 Pass-By-Wert
- 15:50:30 Pass-by-Pointer
- 15:57:46 Referenz übergeben
Kapitel 12: Dinge aus Funktionen herausholen
- 16:03:20 Einführung in Funktionen
- 16:03:58 Eingabe- und Ausgabeparameter
- 16:17:54 Rückkehr von den Funktionen
Kapitel 13: Funktionsüberladung
- 16:32:35 Einführung in die Funktionsüberladung
- 16:34:17 Überlastung mit unterschiedlichen Parametern
- 16:49:00 Einführung in die Lambda-Funktionen
- 16:49:38 Deklarieren und Verwenden von Lambda-Funktionen
- 17:20:25 Erfassungslisten
- 17:34:24 Erfassen Sie alles im Kontext
Kapitel 15: Funktionsvorlagen
- 17:40:08 Einführung in Funktionsvorlagen
- 17:41:45 Funktionsvorlagen ausprobieren
- 18:19:52 Vorlagentyp-Ableitung und explizite Argumente
- 18:35:47 Vorlagentypparameter nach Referenz
- 18:48:55 Vorlagenspezialisierung
Kapitel 16: Konzepte
- 19:04:31 Einführung in die Konzepte
- 19:06:47 Konzepte
- 19:25:32 Konzepte: Erstellen Sie Ihre eigenen
- 19:42:45 Erforderliche Klausel: Vergrößern
- 19:59:53 Logische Kombinationen von Konzepten
- 20:09:39 Konzepte und Auto
Kapitel 17: Klassen
- 20:15:40 Einführung in den Unterricht
- 20:16:33 Ihre erste C++-Klasse
- 20:38:03 Konstrukteure
- 20:53:35 Standardkonstruktoren
- 20:59:42 Setter und Getter
- 21:10:06 Unterricht über mehrere Dateien hinweg
- 21:30:49 Verwalten von Klassenobjekten durch Zeiger
- 21:42:48 Zerstörer
- 22:05:44 Aufrufreihenfolge für Konstruktor und Destruktor
- 22:11:03 Der This-Zeiger
- 22:33:33 Struktur
- 22:42:37 Größe der Klassenobjekte
Kapitel 18: Vererbung
- 22:52:43 Einführung in die Vererbung
- 22:55:59 Ihr erster Versuch mit der Vererbung
- 23:21:10 Geschützte Mitglieder
- 23:32:06 Basisklassen-Zugriffsspezifizierer: Vergrößern
- 23:36:49 Basisklassen-Zugriffsspezifizierer: Eine Demo
- 24:07:42 Private Erbschaft steht kurz bevor
- 24:26:36 Wiederbelebung der Mitglieder im Wirkungsbereich
- 24:46:59 Standard-Arg-Konstruktoren mit Vererbung
- 24:57:37 Benutzerdefinierte Konstruktoren mit Vererbung
- 25:26:56 Konstruktoren mit Vererbung kopieren
- 25:51:53 Basiskonstruktoren erben
- 26:06:00 Vererbung mit Destruktoren
- 26:12:20 Wiederverwendete Symbole bei der Vererbung
Kapitel 19: Polymorphismus
- 26:21:03 Einführung in den Polymorphismus
- 26:26:54 Statische Bindung mit Vererbung
- 26:55:24 Polymorphismus (dynamische Bindung) mit virtuellen Funktionen
- 27:14:31 Größe polymorpher Objekte und Slicing
- 27:26:37 In Sammlungen gespeicherte polymorphe Objekte
- 27:45:42 Überschreiben
- 27:52:45 Überladen, Überschreiben und Verstecken
- 28:07:35 Vererbung und Polymorphismus auf verschiedenen Ebenen
- 28:33:03 Vererbung und Polymorphismus mit statischen Mitgliedern
- 28:49:13 Finale
- 29:07:42 Virtuelle Funktionen mit Standardargumenten
- 29:23:18 Virtuelle Destruktoren
- 29:35:38 Dynamic_cast<>()
- 30:08:17 Rufen Sie keine virtuellen (polymorphen) Funktionen aus Konstruktoren und Destruktoren auf
- 30:24:45 Reine virtuelle Funktionen und abstrakte Klassen
- 30:43:37 Abstrakte Klassen als Schnittstellen
Einfacher bis fortgeschrittener Kurs „Datenstrukturen“ – Vollständiges Tutorial von einem Google-Ingenieur (Teile 1–4)
Kurze Zusammenfassung:
00:00:00 - 01:00:00 Der Dozent erklärt Datenstrukturen und ihre Bedeutung für die Erstellung schnellerer und leistungsfähigerer Algorithmen. Das Tutorial befasst sich mit der Big-O-Notation und ihrer Verwendung zur Standardisierung, wie viel Zeit und Platz ein Algorithmus benötigt. Außerdem werden konkrete Beispiele für unterschiedliche Zeitkomplexitäten bereitgestellt. Das Tutorial behandelt außerdem die Implementierung statischer und dynamischer Arrays, einschließlich ihrer Vor- und Nachteile, und befasst sich intensiv mit dem Erstellen und Einfügen von Knoten in einfach und doppelt verknüpften Listen. Abschließend bietet das Tutorial eine Einführung in die Stack-Datenstruktur und erläutert kurz ihre Hauptoperationen.
01:00:00 - 02:00:00 Dieser Abschnitt des Tutorials „Datenstrukturen für einfache bis fortgeschrittene Kurse“ bietet eine umfassende Abdeckung verschiedener Datenstrukturen und ihrer Funktionalitäten. Das Tutorial führt das Publikum in die Funktionsprinzipien von Stapeln und Warteschlangen, ihre Implementierungen mithilfe von Arrays und verknüpften Listen sowie ihre Bedeutung in verschiedenen Anwendungen ein, einschließlich Graph-Traversierung und Verwaltung von Serveranfragen. Das Tutorial untersucht außerdem Prioritätswarteschlangen und ihre Implementierung mithilfe von Heaps und erläutert den Unterschied zwischen Prioritätswarteschlangen und Heaps sowie die Arten von Heaps. Das Tutorial endet mit einer schrittweisen Demonstration, wie Elemente zu einem Binärheap hinzugefügt und daraus entfernt werden.
02:00:00 - 03:00:00 Der Google Engineer präsentiert ein vollständiges Tutorial zu Datenstrukturen und erklärt, wie man Knoten aus einer binären Heap-Datenstruktur entfernt, wie man die Heap-Invariante in einer Prioritätswarteschlange beibehält und wie man schwimmt und Senkenknoten in einer binären Heap-Datenstruktur. Das Video behandelt auch die Union-Find-Datenstruktur, die zum Verfolgen von in disjunkte Mengen unterteilten Elementen und zum Zusammenführen zweier Gruppen verwendet wird, mit einem Beispiel über Magnete, um die Funktionsweise der Datenstruktur zu veranschaulichen. Darüber hinaus wird Kruskals Algorithmus zum Finden eines minimalen aufspannenden Baums in einem Diagramm erläutert und das Konzept der Pfadkomprimierung eingeführt, um die Union-Datenstruktur effizienter zu finden.
03:00:00 - 04:00:00 Dieses Tutorial behandelt verschiedene Datenstrukturen, beginnend mit der Union-Find-Datenstruktur und ihren Methoden, einschließlich find, connected, parent, size und unify. Das Tutorial geht dann zu Bäumen über, einschließlich Definitionen für Bäume, Wurzelbäume, Binärbäume und binäre Suchbäume. Das Video bietet Beispiele für das Einfügen und Entfernen von Knoten aus binären Suchbäumen sowie für verschiedene Traversal-Algorithmen, einschließlich Pre-Order, In-Order, Post-Order und Level-Order, und erklärt, wie diese Konstrukte in Python und Java implementiert werden. Darüber hinaus stellt das Video Hash-Tabellen vor und diskutiert die Bedeutung von Hash-Funktionen und gängigen Methoden zur Kollisionsauflösung.
04:00:00 - 05:00:00 Der Abschnitt behandelt verschiedene Aspekte von Hash-Tabellen und deren Implementierung. Es wird die Bedeutung von Hash-Funktionen erörtert, die Schlüssel Werten zuordnen, und wie Hash-Kollisionen mithilfe von Techniken wie separater Verkettung und offener Adressierung behandelt werden. Das Tutorial behandelt außerdem Methoden zum Einfügen, Entfernen und Suchen von Einträgen in Hash-Tabellen sowie zur Größenänderung und Verwaltung von Auslastungsfaktoren. Der Redner betont, wie wichtig es ist, eine geeignete Messfunktion und Tischgröße auszuwählen, um Endlosschleifen und Leistungsprobleme zu vermeiden. Im gesamten Tutorial werden praktische Beispiele verwendet, um die Konzepte zu veranschaulichen.
05:00:00 - 06:00:00 Dieser Abschnitt bietet einen umfassenden Überblick über Hash-Tabellen, doppeltes Hashing und quadratisches Prüfen bei der Kollisionsauflösung. Das Video behandelt die Konzepte der Größenänderung und Vergrößerung einer Hash-Tabelle, der Handhabung von Kollisionen und Löschungen sowie der Implementierung von Hash-Tabellen mithilfe quadratischer Sondierung. Das Video stellt außerdem den Fenwick-Baum vor, eine Datenstruktur, die Bereichsabfragen und Punktaktualisierungen in logarithmischer Zeit mit linearer Konstruktionszeit unterstützt. Das Video erklärt Schritt für Schritt, wie Präfixsummen und Bereichsabfragen mithilfe des Fenwick-Baums durchgeführt werden.
06:00:00 - 07:00:00 Das Video-Tutorial behandelt verschiedene Themen, darunter das Konzept eines Fenwick-Baums für schnelle Bereichsabfragen und Punktaktualisierungen, die Verwendung von Suffix-Arrays und LCP-Arrays zum Suchen eindeutiger Teilzeichenfolgen und längster gemeinsamer Teilzeichenfolgen sowie das Lösen das längste häufige Teilstringproblem unter Verwendung einer Schiebefenstertechnik. Das Tutorial erklärt außerdem, wie man mithilfe des LCP-Arrays den längsten wiederholten Teilstring effizient findet, und untersucht die Eigenschaften und Bedeutung ausgeglichener binärer Suchbäume, insbesondere AVL-Bäume, und wie sie mithilfe von Baumrotationen im Gleichgewicht gehalten werden können. Das Video bietet ausführliche Erklärungen, Beispiele und Quellcode in Java, verfügbar auf GitHub.
Teil 1
- 00:00:00 Der Redner stellt das Konzept von Datenstrukturen als Möglichkeit zur effizienten Organisation von Daten vor und wie sie für die Erstellung schnellerer und leistungsfähigerer Algorithmen unerlässlich sind. Der Redner spricht darüber, wie wichtig es ist, zu verstehen, wie und wann die richtige Datenstruktur für die jeweilige Aufgabe verwendet werden muss und wie Datenstrukturen den Code sauberer und verständlicher machen können. Außerdem wird das Konzept des abstrakten Datentyps erläutert, zusammen mit Beispielen dafür, wie ein abstrakter Datentyp nur die Schnittstelle und nicht die spezifischen Details zur Implementierung der Datenstruktur bereitstellt. Darüber hinaus geht das Video kurz auf die Rechenkomplexität ein, um die Leistung von Datenstrukturen zu verstehen.
- 00:05:00 Das Konzept der Big-O-Notation wird eingeführt, um zu standardisieren, wie viel Zeit und Platz benötigt wird, damit ein Algorithmus auf der Grundlage der schlechtesten Eingabeanordnung ausgeführt werden kann. Big O kümmert sich nur darum, was passiert, wenn die Eingaben wirklich groß werden, und entfernt konstante Werte, die zur Big-O-Notation hinzugefügt wurden. Das Konzept einer Funktion f wird ebenfalls eingeführt und es wird angegeben, dass das große O von f von n nur n kubisch ist, was der größte und dominanteste Term in dieser Funktion ist.
- 00:10:00 Der Google Engineer liefert konkrete Beispiele für die Verwendung der Big-O-Notation. Die Beispiele werden nach ihrer Zeitkomplexität kategorisiert – konstante Zeit, lineare Zeit, quadratische Zeit, logarithmische Zeit. Außerdem erläutert er Schritt für Schritt, wie eine logarithmische Zeitkomplexität am Beispiel der binären Suche erreicht wird. Darüber hinaus zeigt er, wie man die Zeitkomplexität eines komplizierteren Algorithmus berechnet und erklärt die Regel zur Bestimmung der Komplexität eines Algorithmus.
- 00:15:00 Der Referent diskutiert die Komplexitätsanalyse einer verschachtelten Schleife mit einer äußeren Schleife und einer inneren Schleife. Die innere Schleife hat einen konstanten Arbeitsaufwand und die äußere Schleife hat einen variablen Arbeitsaufwand. Das große O der Funktion ist O(n^4), da n^3 der dominierende Term ist. Anschließend stellt der Sprecher statische Arrays vor, bei denen es sich um einen Container fester Länge handelt, der indizierbare Elemente enthält, die zusammenhängende Speicherblöcke darstellen. Statische Arrays werden überall verwendet, von der temporären Speicherung von Objekten bis hin zur Speicherung von Informationen aus einem Eingabe- oder Ausgabestream. Der Referent skizziert die Grundstruktur eines Arrays, allgemeine Operationen, die auf ihnen ausgeführt werden können, und ihre Komplexitätsanalyse.
- 00:20:00 Der Dozent diskutiert die Verwendung von Arrays in der Programmierung, auch als Workaround für Sprachen, die nur einen Rückgabewert zulassen, und in der dynamischen Programmierung. Er erklärt, dass Arrays aufgrund ihrer indizierbaren Eigenschaft eine konstante Zugriffszeit haben, die Suche jedoch im schlimmsten Fall bis zur linearen Zeit dauern kann. Das Einfügen, Anhängen und Löschen aus einem statischen Array ist nicht möglich, aber bei einem dynamischen Array führt die Größenänderung des internen Arrays zum Anhängen zu einem seltenen, aber konstanten Zeitvorgang. Abschließend weist er darauf hin, dass Elemente mithilfe einer for-each-Schleife iteriert werden können und dass die Array-Indizierung in der Informatik bei Null beginnt, was für einige Anfänger verwirrend sein kann.
- 00:25:00 Das Video erläutert das Konzept der Indizierung in Arrays, wobei eine eckige Klammer die Indizierung kennzeichnet, und wie dynamische Arrays je nach Bedarf vergrößert und verkleinert werden können, wodurch ähnliche Get-Set-Vorgänge wie statische Arrays möglich sind. Um ein dynamisches Array zu implementieren, wird ein statisches Array verwendet. Wenn die Kapazität überschritten wird, wird die Array-Größe verdoppelt und alle Elemente werden in das neue statische Array kopiert. Das Video zeigt auch den Quellcode für die Array-Klasse, die Generika vom Typ T unterstützt und über Instanzvariablen für das interne statische Array, die Länge und die Kapazität verfügt.
- 00:30:00 Der Kursleiter geht durch die Implementierung mehrerer Methoden für ein dynamisches Array, einschließlich Größe, Einfügung, Löschen, Hinzufügen, Entfernen, Index von, Enthält und toString. Bei der Add-Methode wird die Größe des Arrays geändert, indem seine Größe verdoppelt wird, wenn die Kapazität erreicht ist. Die Remove-Methode verwendet zwei Indizes, um alle Elemente des Arrays mit Ausnahme des Entfernungsindex zu kopieren. Der Kursleiter zeigt außerdem, wie ein Iterator für das dynamische Array erstellt wird, und spricht über die Vorteile der Verwendung eines Iterators zum Durchlaufen der Elemente eines Arrays. Insgesamt bietet das Tutorial eine einfache, aber umfassende Einführung in die Implementierung dynamischer Arrays.
- 00:35:00 Der Kursleiter gibt eine Einführung in einfach und doppelt verknüpfte Listen und erklärt, dass es sich dabei um eine sequentielle Liste von Knoten handelt, die Daten enthalten und auf andere Knoten verweisen, die Daten enthalten. Verknüpfte Listen werden bei der Implementierung von Listen, Stapeln und Warteschlangen sowie bei zirkulären Listen, bei der separaten Verkettung von Hash-Tabellen sowie für Adjazenzlisten und Diagramme verwendet. Der Dozent behandelt auch einige nützliche Terminologie zum Erstellen verknüpfter Listen. Darüber hinaus werden die Vor- und Nachteile einfach und doppelt verknüpfter Listen diskutiert, wobei einfach verknüpfte Listen speichereffizienter sind, aber nicht auf frühere Elemente zugreifen können, während doppelt verknüpfte Listen rückwärts durchlaufen werden können und das einfache Entfernen eines Knotens ermöglichen.
- 00:40:00 Der Kursleiter erklärt die Implementierungsdetails zum Erstellen und Einfügen von Knoten in einer einfach verknüpften Liste und einer doppelt verknüpften Liste. Um einen Knoten in eine einfach verknüpfte Liste einzufügen, wird ein neuer Zeiger erstellt und der Traverserzeiger an die gewünschte Position verschoben. Anschließend wird der neue Knoten erstellt und mit den anderen Knoten verknüpft. Andererseits verfügt eine doppelt verknüpfte Liste sowohl über den nächsten als auch den vorherigen Zeiger, und beim Einfügen eines neuen Knotens müssen beide Zeiger der benachbarten Knoten und des neuen Knotens aktualisiert werden. Das Entfernen eines Knotens aus einer einfach verknüpften Liste erfordert die Verwendung von zwei Zeigern, um zum gewünschten Knoten vorzurücken und ihn zu entfernen, und anschließend die Freigabe seines Speichers zu einem späteren Zeitpunkt.
- 00:45:00 Der Referent erläutert, wie man Knoten aus einer doppelt verknüpften Liste entfernt. Dies ist einfacher als das Entfernen von Knoten aus einer einfach verknüpften Liste, da wir Verweise auf den letzten Knoten nicht manuell pflegen müssen. Der Referent zeigt eine Implementierung in Java und erörtert die Komplexität verschiedener Operationen in verknüpften Listen, wie zum Beispiel das Suchen und Entfernen von Elementen aus dem Kopf oder Ende. Während die Suche in einer verknüpften Liste im schlimmsten Fall linear verläuft, ist das Einfügen bis zum Kopf oder das Entfernen des Kopfes eine konstante Zeit. Das Entfernen aus dem Ende dauert in einer einfach verknüpften Liste linear, in einer doppelt verknüpften Liste jedoch nicht, da sie einen Verweis auf den vorherigen Knoten enthält.
- 00:50:00 In diesem Abschnitt des Videos erklärt der Moderator die Implementierung einer doppelt verknüpften Liste mit Methoden zum Löschen der Liste, zum Ermitteln der Größe und zum Überprüfen, ob sie leer ist, sowie zum Hinzufügen von Knoten am Anfang und Ende der Liste. Er erklärt außerdem, wie man einen Blick auf das erste oder letzte Element der Liste wirft, das erste oder letzte Element entfernt und einen beliebigen Knoten in der Mitte der Liste entfernt. Der Moderator betont, wie wichtig es ist, den Speicher ordnungsgemäß freizugeben, und legt die Knotenklasse auf privat fest, um zu verhindern, dass Benutzer direkt darauf zugreifen.
- 00:55:00 In diesem Abschnitt des Videos erklärt der Tutor, wie man einen Knoten eines bestimmten Index aus einer verknüpften Liste entfernt, auch wenn die Knoten nicht explizit indiziert sind. Die Remove-Methode unterstützt das Entfernen eines beliebigen Werts aus der verknüpften Liste und die Suche nach Nullwerten. Der Tutor erklärt außerdem die Indexmethode zum Abrufen des Index eines Objekts in einer verknüpften Liste und die Iteratormethode. Abschließend stellt der Tutor die Stack-Datenstruktur vor und gibt kurz einen Überblick über die primären Operationen Push und Pop. Der Tutor hebt außerdem hervor, dass sich die kommenden Videos der Reihe mit der Stack-Implementierung, mit Stacks gelösten Problemen und der mit Stack-Operationen verbundenen Zeitkomplexität befassen werden.
Teil 2
- 01:00:00 Das Video erläutert die Funktionsweise einer Stack-Datenstruktur und ihre verschiedenen Verwendungsmöglichkeiten in der Programmierung. Das Video bietet ein detailliertes Beispiel dafür, wie Vorgänge einem Stapel hinzugefügt und daraus entfernt werden, und erklärt, wie Stapel in Texteditoren und Compilern verwendet werden und wie sie die Rekursion unterstützen. Darüber hinaus zeigt das Video, wie ein Stapel verwendet werden kann, um eine Tiefensuche in einem Diagramm durchzuführen, und stellt ein cooles Beispielproblem vor, wie mithilfe eines Stapels ermittelt werden kann, ob eine Klammersequenz gültig ist oder nicht. Abschließend enthält das Video eine Komplexitätsanalyse von Stapeln und wie sie als verknüpfte Liste funktionieren.
- 01:05:00 Der Google-Ingenieur zeigt, wie man anhand einer Stack-Datenstruktur prüft, ob eine Klammersequenz gültig ist. Er geht den Algorithmus Schritt für Schritt durch, schiebt linke Klammern auf den Stapel und entfernt sie, wenn er auf rechte Klammern trifft, und prüft, ob sie übereinstimmen. Er erklärt auch, wie das Spiel „Turm von Hanoi“ mit Stapeln in Zusammenhang gebracht werden kann, da jeder Stift einen Stapel darstellt und die Scheiben Elemente darstellen, die nur unter bestimmten Bedingungen bewegt werden können. Abschließend diskutiert er, wie Stacks mithilfe von Arrays oder verknüpften Listen implementiert werden können.
- 01:10:00 Wir lernen, wie man einen Stapel mithilfe einer einfach verknüpften Liste erstellt und Elemente aus dem Stapel entfernt, in einer einfachen Implementierung einer Stapeldatenstruktur in der Programmiersprache Java. Der Stapel wird erstellt, indem der Kopf auf einen Nullknoten zeigt, was bedeutet, dass der Stapel leer ist. Neue Elemente werden vor dem Kopf eingefügt, und das Einfügen von Elementen erfolgt durch Verschieben des Kopfzeigers auf den nächsten Knoten und Aufheben der Zuordnung des letzten Knotens. Speicherlecks in Datenstrukturen können Probleme verursachen. Daher ist es wichtig, in allen Datenstrukturen auf sie zu achten und sie bei Bedarf zu beheben.
- 01:15:00 Der Kursleiter bespricht Warteschlangen, eine lineare Datenstruktur, die zur Modellierung einer realen Warteschlange mit zwei Hauptoperationen verwendet wird: Einreihen in die Warteschlange und Entfernen aus der Warteschlange. Die Vorderseite und die Rückseite der Warteschlange werden zum Einfügen bzw. Entfernen von Elementen verwendet. Der Kursleiter erklärt außerdem die verschiedenen Terminologien im Zusammenhang mit Warteschlangen, wobei das Einreihen in die Warteschlange manchmal als Hinzufügen und das Entfernen aus der Warteschlange als Abfragen oder Entfernen vom Anfang der Warteschlange bezeichnet wird. Ein klassisches Beispiel für eine Warteschlange ist eine Warteschlange in einem Kino oder Restaurant. Warteschlangen können nützlich sein, um den Überblick über die x neuesten Elemente in einer Sequenz zu behalten.
- 01:20:00 Das Video erklärt, wie Warteschlangen verwendet werden, um Serveranfragen zu verwalten und eine Breitensuche in einem Diagramm durchzuführen. Das Konzept der Warteschlangen-Anforderungen wird eingeführt, wobei ein inaktiver Server jeweils nur eine bestimmte Anzahl von Anforderungen verarbeiten kann und alle überschüssigen Anforderungen in eine Warteschlange gestellt werden. Das Video behandelt auch die Grundlagen der Breitensuche, bei der Knoten eines Diagramms in der Reihenfolge ihrer Entfernung von einem Startknoten besucht werden. Das Video schließt mit der Erläuterung der Implementierung von n-Warteschlangen- und Entnahmeelementen mithilfe einer Warteschlangendatenstruktur.
- 01:25:00 Das Tutorial befasst sich intensiv mit Warteschlangen und erklärt, wie der abstrakte Datentyp der Warteschlange mithilfe von Arrays oder verschiedenen Arten verknüpfter Listen – einfach verknüpfte Listen und doppelt verknüpfte Listen – implementiert werden kann. Das Tutorial bietet ein Beispiel dafür, wie die einfach verknüpfte Listenimplementierung einer Warteschlange funktionieren kann, und erläutert außerdem die Implementierung verschiedener Warteschlangenmethoden wie Peak, Poll und Offer mithilfe der Programmiersprache Java. Das Tutorial enthält außerdem einen Link zum Quellcode der Warteschlangenimplementierung auf github.com.
- 01:30:00 In diesem Abschnitt des Tutorials erklärt der Google Engineer das Konzept und die Implementierung von Datenstrukturen, insbesondere Warteschlangen und Prioritätswarteschlangen. Er erläutert, wie eine Prioritätswarteschlange ähnlich wie eine normale Warteschlange funktioniert, mit dem einzigen Unterschied, dass jedes Element eine bestimmte Priorität hat und Elemente mit einer höheren Priorität zuerst aus der Warteschlange herauskommen. Er betont auch, dass Prioritätswarteschlangen nur vergleichbare Elemente unterstützen, was bedeutet, dass die Daten, die wir in die Prioritätswarteschlange einfügen, geordnet sein müssen. Darüber hinaus liefert er ein Beispiel, um die Vorgänge des Abfragens und Hinzufügens von Elementen zu einer Prioritätswarteschlange zu erläutern. In den nächsten Abschnitten des Tutorials wird er ausführlicher auf die allgemeinen Vorgänge eingehen, die an Prioritätswarteschlangen durchgeführt werden, auf die Umwandlung von Warteschlangen mit minimaler Priorität in Warteschlangen mit maximaler Priorität, auf die Komplexitätsanalyse und auf Möglichkeiten zur Implementierung von Prioritätswarteschlangen.
- 01:35:00 Der Google Engineer erklärt, wie Prioritätswarteschlangen mithilfe von Heaps implementiert werden. Ein Heap ist eine baumbasierte Datenstruktur, die die Heap-Invariante erfüllt, was bedeutet, dass der Wert des übergeordneten Knotens für alle Knoten immer größer oder gleich dem Wert des untergeordneten Knotens ist, was zu zwei Arten von Heaps führt: Max. Heaps und min Haufen. Heaps sind wichtig, da sie die kanonische zugrunde liegende Datenstruktur für Prioritätswarteschlangen bilden. Anschließend zeigt der Google Engineer Beispiele für Strukturen und fragt das Publikum, ob es sich um Heaps handelt oder nicht. Dabei wird demonstriert, dass alle Heaps Bäume sein und die Heap-Invariante erfüllen müssen.
- 01:40:00 Die Bedeutung von Prioritätswarteschlangen in Algorithmen wie dem Kürzeste-Pfad-Algorithmus von Dijkstra und der Huffman-Kodierung wird diskutiert. Prioritätswarteschlangen sind in Situationen nützlich, in denen das nächstbeste oder -schlechteste Element dynamisch abgerufen werden muss. Der Schwerpunkt liegt auf Prioritätswarteschlangen, die als binäre Heaps implementiert sind, und auf den Vorgängen, einschließlich des Hinzufügens eines Elements, des Entfernens eines Elements, der Überprüfung der Eindämmung und der Änderung von Warteschlangen mit minimaler Priorität in Warteschlangen mit maximaler Priorität. Hash-Tabellen können verwendet werden, um die Entfernungszeitkomplexität logarithmisch zu verbessern, während für die naive Methode ein linearer Scan für alle Elemente durchgeführt wird. Der Abschnitt endet mit einem Hack, um Warteschlangen mit minimaler Priorität in Warteschlangen mit maximaler Priorität umzuwandeln.
- 01:45:00 Der Google-Ingenieur erklärt, wie man Negation als einfache Möglichkeit zur Implementierung von Reverse-Heaps in Prioritätswarteschlangen verwendet. Er liefert Beispiele sowohl für die numerische als auch für die String-Manipulation unter Verwendung einer Min-Prioritäts-Warteschlange mit dem standardmäßigen lexikografischen Komparator sowie einem negierten Komparator. Der Ingenieur stellt außerdem das Konzept binärer Heaps vor und erläutert, wie man ihnen Elemente hinzufügt.
- 01:50:00 Der Kursleiter erklärt die wichtige Terminologie und Konzepte, die zum Verständnis erforderlich sind, wie Elemente mithilfe eines binären Heaps effektiv zu einer Prioritätswarteschlange hinzugefügt werden. Er stellt klar, dass eine Prioritätswarteschlange kein Heap ist, sondern ein abstrakter Datentyp, der das Verhalten definiert, das eine Prioritätswarteschlange haben sollte, und dass Heaps nur die Datenstruktur sind, die es uns ermöglicht, dieses Verhalten tatsächlich zu implementieren. Er bespricht auch die Arten von Heaps, einschließlich binärer Heaps, und erklärt die vollständige Binärbaumeigenschaft und wie man einen binären Heap mithilfe eines Array-Konstrukts darstellt.
- 01:55:00 Der Google Engineer erklärt, wie man Knoten zu einem binären Heap hinzufügt und die Heap-Invariante beibehält, indem er eine Technik verwendet, um einfach auf die untergeordneten und übergeordneten Knoten eines Knotens zuzugreifen. Sie veranschaulichen dies am Beispiel des Einfügens von Werten in einen Min-Heap und demonstrieren, wie man die Knoten aufbläht, um die Heap-Invariante zu erfüllen. Im nächsten Abschnitt befasst sich der Ingenieur mit dem Entfernen von Elementen aus einem binären Heap und betont, wie wichtig es ist, den Stammwert zu entfernen, bei dem es sich um den interessierenden Knoten mit der höchsten Priorität handelt.
Teil 3
- 02:00:00 Der Google-Ingenieur erklärt den Prozess des Entfernens von Knoten aus einer binären Heap-Datenstruktur mithilfe der Pull-Methode. Das Ziehen erfolgt in zwei Fällen: beim Entfernen des Wurzelknotens und beim Entfernen eines bestimmten Knotens. Beim Entfernen des Wurzelknotens wird der Knoten mit dem letzten Knoten im Array ausgetauscht und die Heap-Invariante wird durch Bubbling-Down sichergestellt. Beim Entfernen eines bestimmten Knotens wird der Knoten linear gesucht, mit dem letzten Knoten im Heap getauscht und dann wird die Heap-Invariante durch Auf- oder Abblasen abhängig vom Wert des getauschten Knotens sichergestellt. Der Ingenieur kommt zu dem Schluss, dass das Ziehen logarithmische Zeit für den Wurzelknoten und lineare Zeit für einen bestimmten Knoten benötigt.
- 02:05:00 In diesem Abschnitt des Tutorials erklärt der Google Engineer, wie man mithilfe einer Hash-Tabelle Knoten in einem Heap mit verbesserter Zeitkomplexität entfernt. Anstatt einen linearen Scan durchzuführen, um den Index des zu entfernenden Knotens zu finden, wird jeder Knoten dem Index zugeordnet, an dem er gefunden wird. Wenn wir einen bestimmten Knoten entfernen möchten, suchen wir einfach nach seinem Index, um mit dem Entfernen zu beginnen. Das Video behandelt außerdem, wie man mit dem Problem mehrerer Werte im Heap umgeht und wie man die Positionen der Werte im Baum im Auge behält. Der Ingenieur erklärt, dass es keine Rolle spielt, welchen Knoten wir entfernen, solange wir die Heap-Invariante erfüllen. Das Tutorial enthält Beispiele für das Hinzufügen, Ziehen und Entfernen von Elementen mit dem vorgeschlagenen neuen Schema.
- 02:10:00 Der Referent erklärt, wie man mithilfe einer Heap-Datenstruktur die Heap-Invariante in eine Prioritätswarteschlange einfügt, entfernt und verwaltet. Dann taucht er in den Quellcode ein und hebt einige wichtige Instanzvariablen und Konstruktoren hervor, die für die Implementierung der Prioritätswarteschlange erforderlich sind. Er erklärt, dass die in der Prioritätswarteschlange zugelassenen Elemente die vergleichbare Schnittstelle implementieren müssen und dass Protokollierung und Entfernung mithilfe einer Karte verfolgt werden können, die ein Element einem Satz von Ganzzahlen zuordnet, die die Positionen des Elements im Heap darstellen.
- 02:15:00 In diesem Abschnitt des Tutorials erläutert der Google Engineer verschiedene Möglichkeiten zum Erstellen einer Prioritätswarteschlange, einschließlich der Erstellung einer anfänglich leeren Warteschlange mit einer festgelegten Kapazität, der Erstellung einer Warteschlange mit einer definierten Anfangskapazität und der linearen Erstellung einer Warteschlange Zeit mit der Heapify-Operation. Der Techniker geht außerdem auf einige einfache Methoden einer Prioritätswarteschlange ein, darunter „Leeren“, „Löschen“, „Größe“, „Peek“, „Umfrage“ und „Enthält“. Außerdem wird die Add-Methode besprochen, mit Einzelheiten zum Hinzufügen von Elementen zur Warteschlange und zur Wichtigkeit, den Überblick über die Elemente in einer Karte zu behalten. Die Schwimmfunktion wird auch als notwendiger Schritt hervorgehoben, nachdem ein Element am Ende der Liste hinzugefügt wurde.
- 02:20:00 In diesem Abschnitt des Videos erklärt der Google-Ingenieur die Methoden zum Schwimmen und Senken von Knoten in einer binären Heap-Datenstruktur. Bei der Schwimmmethode werden Knoten mit ihrem übergeordneten Knoten ausgetauscht und nach oben bewegt, bis sich der Knoten basierend auf seinem Wert an der richtigen Position befindet. Die Absenkmethode ist ähnlich, beinhaltet jedoch den Vergleich des Knotens mit seinen untergeordneten Knoten und den Austausch mit dem kleineren, bis er die richtige Position erreicht. Der Techniker erläutert außerdem die im Binärheap implementierten Methoden „Swap“, „Remove“ und „Remove Add“. Bei der Remove-Add-Methode wird der entfernte Knoten mit dem letzten Element im Heap ausgetauscht und der neue Knoten an die entsprechende Position versenkt oder schwimmt.
- 02:25:00 In diesem Abschnitt des Tutorials erklärt der Kursleiter, wie man einen Knoten aus einer Heap-Datenstruktur entfernt und sicherstellt, dass die Integrität des minimalen Heaps gewahrt bleibt, indem er eine Methode zum Sinken oder Schwimmen von Knoten verwendet, je nachdem, ob sich der Austausch auf den Heap auswirkt Befehl. Der Abschnitt stellt außerdem die Union-Find-Datenstruktur und ihre beiden Hauptoperationen „find“ und „union“ vor, die zum Verfolgen von Elementen, die in disjunkte Mengen unterteilt sind, bzw. zum Zusammenführen zweier Gruppen verwendet werden.
- 02:30:00 Der Referent erklärt am Beispiel von Magneten, wie die Union-Find-Datenstruktur funktioniert. Der Union Find führt Elemente oder Elementgruppen effizient zusammen und weist ihnen eine beliebige Farbe zu. Die Union-Find-Datenstruktur wird in verschiedenen Algorithmen verwendet, beispielsweise im Minimum-Spanning-Tree-Algorithmus und bei der Grid-Perkolation. Der Vereinigungsfund weist eine ausgezeichnete Komplexität auf und seine Konstruktion basiert auf linearer Zeit, während seine Funktion „Komponenten zählen“ die Anzahl der Komponenten in konstanter Zeit bestimmen kann, was ihn zu einer großartigen Datenstruktur macht.
- 02:35:00 In diesem Abschnitt des Tutorials erklärt der Google-Ingenieur Kruskals Algorithmus zum Finden eines minimalen Spannbaums in einem Diagramm. Der Algorithmus umfasst das Sortieren von Kanten nach aufsteigendem Kantengewicht und das anschließende Vereinigen von Knoten, die nicht zur selben Gruppe gehören, bis alle Scheitelpunkte in einer Gruppe vereint sind. Die Union-Find-Datenstruktur wird verwendet, um Gruppen effizient zusammenzuführen und Zyklen zu verhindern. Der Ingenieur stellt ein Beispieldiagramm bereit und geht die Schritte des Algorithmus durch, um seine Funktionsweise zu veranschaulichen.
- 02:40:00 Das Tutorial erklärt die Union-Find-Datenstruktur und wie sie intern funktioniert. Der erste Schritt besteht darin, eine Zuordnung zwischen den Objekten und den ganzen Zahlen im Bereich von Null bis N (nicht inklusive) zu erstellen, wobei N die Anzahl der Elemente ist. Dann wird ein Array erstellt, und jedem Index ist ein Objekt zugeordnet, was durch die Zuordnung erfolgt. Der Wert an der Position des Arrays ist zunächst der Index, an dem es sich befindet, und jeder Knoten ist ein Wurzelknoten, der sich selbst zugeordnet ist. Da Anweisungen zum Zusammenfassen von Objekten in Gruppen ausgeführt werden, haben sich die Werte im Array geändert, um sie anderen Objekten zuzuordnen. Kleinere Komponenten werden zu größeren zusammengeführt und die Wurzelknoten werden zur Vereinigung von Gruppen verwendet.
- 02:45:00 Der Redner spricht darüber, wie man mithilfe der Union-Find-Datenstruktur Elemente in verschiedene Gruppen zusammenführen kann. Indem wir die übergeordneten Knoten des Wurzelknotens jeder Komponente finden und verfolgen, können wir bestimmen, zu welcher Komponente ein Element gehört. Um zwei Komponenten zu vereinen, lassen wir einen der Wurzelknoten darauf zeigen, dass er zum übergeordneten Knoten der anderen Wurzel wird. Die Anzahl der Komponenten ist gleich der Anzahl der verbleibenden Wurzelknoten, und die Anzahl der Wurzelknoten nimmt nur ab, wenn wir Komponenten vereinheitlichen. Der Sprecher weist außerdem darauf hin, dass die Implementierung dieser Struktur ohne den Einsatz von Pfadkomprimierung derzeit keine amortisierte Zeitkomplexität aufweist, eine Optimierung, die im nächsten Video besprochen wird.
- 02:50:00 Das Konzept der Pfadkomprimierung wird eingeführt, um zu zeigen, wie es die Union effizienter macht, Datenstrukturen zu finden. Bei der Pfadkomprimierung werden alle Knoten entlang des Pfads zum Wurzelknoten komprimiert, wodurch eine konstante Suche des Wurzelknotens nach einer bestimmten Komponente ermöglicht wird. Am Beispiel der Vereinigung von Gruppen mit und ohne Pfadkomprimierung werden die beiden Methoden verglichen und gegenübergestellt und die durch die Pfadkomprimierung erzielte Effizienz demonstriert.
- 02:55:00 Der Kursleiter erläutert, wie Pfadkomprimierung und Vereinigungssuche zusammenarbeiten, um eine effiziente Datenstruktur zu erstellen. Er demonstriert, wie die Pfadkomprimierung Pfade auf dem Weg dynamisch komprimiert, bis sie einen Endzustand erreichen. Der Union-Find-Code wird im Video vorgestellt, mit Erläuterungen zur Verwendung von Arrays zum Indizieren und Verfolgen von Eltern-Kind-Beziehungen. Darüber hinaus enthält der Code Methoden zum Überprüfen des Stammknotens und zum Komprimieren des Pfads dorthin. Der Dozent betont, wie wichtig es ist, sich andere Videos zu Union Find anzusehen, um ein umfassendes Verständnis des Themas zu erlangen.
Teil 4
- 03:00:00 Der Kursleiter stellt eine Union-Find-Datenstruktur und ihre Methoden vor, einschließlich Find, Connected, Parent, Size und Unify. Er zeigt, wie die Wurzelknoten der Struktur die Größe jeder verbundenen Komponente enthalten und die Unify-Methode kleinere Gruppen zu größeren zusammenführt. Weiter geht es mit Bäumen. Der Kursleiter gibt einen kurzen Überblick über Bäume als ungerichtete Graphen und stellt Binärbäume und binäre Suchbäume vor. Er verspricht, in späteren Tutorials zu behandeln, wie man Knoten in binäre Suchbäume einfügt und entfernt, Baumdurchläufe und wie sie auf allgemeine Bäume angewendet werden können.
- 03:05:00 Das Konzept der Bäume wird mit mehreren Definitionen vorgestellt. Ein Baum kann als ungerichteter Graph definiert werden, der verbunden und azyklisch ist, als Graph mit n Knoten und n-1 Kanten oder als Graph, bei dem es nur einen Pfad zwischen zwei beliebigen Eckpunkten gibt. Außerdem wird ein Wurzelbaum eingeführt, in dem jeder Knoten zum Stammknoten werden kann und untergeordnete und übergeordnete Knoten definiert werden. Der übergeordnete Knoten des Wurzelknotens ist er selbst, und Blattknoten werden als Knoten ohne untergeordnete Knoten definiert. Außerdem wird das Konzept eines Teilbaums eingeführt, der durch Dreiecke innerhalb eines Baums gekennzeichnet ist. Darüber hinaus wird die Definition eines Binärbaums als ein Baum erklärt, in dem jeder Knoten höchstens zwei Kinder hat.
- 03:10:00 Das Video behandelt binäre Suchbäume, also binäre Bäume, die die Invariante des binären Suchbaums erfüllen. Das bedeutet, dass der linke Teilbaum immer kleinere Werte als der aktuelle Knoten hat und der rechte Teilbaum größere Werte hat. Das Video stellt verschiedene Beispiele für binäre Suchbäume vor und fordert die Zuschauer auf, festzustellen, ob sie die Invariante erfüllen. Binäre Suchbäume sind in vielen Implementierungen abstrakter Datentypen nützlich und werden in ausgewogenen binären Suchbäumen und Syntaxbäumen verwendet. Außerdem haben sie im Durchschnitt eine logarithmische Zeitkomplexität für Operationen wie Einfügen und Suchen in Zufallsdaten.
- 03:15:00 In diesem Abschnitt des Tutorials bespricht der Google-Ingenieur binäre Suchbäume und wie man Elemente in sie einfügt. Binäre Suchbäume weisen im Durchschnitt ein logarithmisches Verhalten auf, wodurch sie in den meisten Fällen einfach zu implementieren und effizient sind. Im schlimmsten Fall kann ein Binärbaum jedoch zu einer linearen Datenstruktur werden, was nicht ideal ist. Um ein Element in einen binären Suchbaum einzufügen, muss das Element vergleichbar sein, und einer von vier Fällen kann eintreten: Rekursion nach unten im linken Teilbaum, Rekursion nach unten im rechten Teilbaum, Verarbeitung doppelter Werte oder Einfügen eines neuen Knotens. Abschließend demonstriert der Ingenieur anhand von Animationen das Einfügen von Werten in einen binären Suchbaum.
- 03:20:00 Der Google-Ingenieur erklärt das Worst-Case-Szenario beim Einfügen von Werten in einen binären Suchbaum, der dazu führt, dass dieser zu einer linearen Struktur wird. Dieses Verhalten ist unerwünscht, da es Vorgänge wie die Suche nach Knoten oder das Löschen von Werten verlangsamt. Der Ingenieur erklärt dann, wie man in zwei Schritten Elemente aus einem binären Suchbaum entfernt: Zuerst wird der zu entfernende Knoten gefunden und dann wird er durch seinen Nachfolger ersetzt, um die Invariante des binären Suchbaums beizubehalten. Das Video bietet ein Beispiel für die Suche nach Werten in einem binären Suchbaum, um den Prozess besser zu verstehen.
- 03:25:00 Der Google-Ingenieur erklärt die vier Fälle der Remove-Phase beim Umgang mit einem binären Suchbaum. Der erste Fall liegt vor, wenn der zu entfernende Knoten ein Blattknoten ist, der zweite und dritte Fall treten auf, wenn links oder rechts nur ein Unterbaum vorhanden ist. Der vierte Fall tritt auf, wenn der Knoten sowohl einen linken als auch einen rechten Teilbaum hat und die Frage ist, in welchem Teilbaum der Nachfolger des Knotens sein wird. Die Antwort ist, dass der Nachfolger entweder der größte Wert im linken Teilbaum oder der kleinste Wert im rechten Teilbaum sein kann und es zwei mögliche Nachfolger geben kann.
- 03:30:00 In diesem Abschnitt des Kurses erklärt der Kursleiter, wie man mithilfe des Konzepts eines Nachfolgeknotens Knoten aus binären Suchbäumen entfernt. Der Nachfolger ist entweder der kleinste Knoten im rechten Teilbaum oder der größte Knoten im linken Teilbaum. Der Kursleiter demonstriert das Entfernen von Knoten anhand mehrerer Beispiele und betont, wie wichtig es ist, den Baum nach dem Entfernen wieder ins Gleichgewicht zu bringen. Der Abschnitt schließt mit einem Überblick über verschiedene Baumdurchquerungen, einschließlich Vorbestellung, In-Reihenfolge, Nachbestellung und Ebenenreihenfolge.
- 03:35:00 Der Dozent erklärt die Konzepte von Pre-Order-, In-Order- und Post-Order-Traversals in Binärbäumen. Er erklärt, dass die Vorbestellung den Wert des aktuellen Knotens ausgibt, gefolgt von seinen linken und rechten Teilbäumen, und liefert dann ein Beispiel dafür, wie die Vorbestellungsdurchquerung in einem Binärbaum funktioniert, indem ein Aufrufstapel verwaltet wird, um zu verfolgen, welche Knoten besucht werden. Ebenso erklärt er, wie das Durchlaufen in der richtigen Reihenfolge funktioniert, was das Durchlaufen des linken Teilbaums, das Drucken des Werts und das anschließende Durchlaufen des rechten Teilbaums beinhaltet. Der Kursleiter verwendet als Beispiel einen binären Suchbaum und hebt die Reihenfolge hervor, in der die Knoten während der Durchquerung besucht und gedruckt werden.
- 03:40:00 Das Tutorial diskutiert verschiedene Traversal-Algorithmen für Binärbäume. Erstens die Inorder-Traversierung, bei der die Werte der Knoten in aufsteigender Reihenfolge gedruckt werden. Als nächstes folgt die Post-Order-Traversierung, die den linken Teilbaum durchläuft, dann den rechten Teilbaum und erst nachdem beide durchlaufen wurden, den Wert des Knotens ausgibt. Das Tutorial erläutert anschließend die Breitensuche und erläutert, wie sie für die Durchquerung der Ebenenreihenfolge verwendet werden kann, bei der die Knoten Schicht für Schicht gedruckt werden. Eine Warteschlange wird verwendet, um den Überblick über die zu erkundenden Knoten zu behalten, und Knoten werden der Warteschlange hinzugefügt, wenn ihre übergeordneten Knoten besucht werden.
- 03:45:00 In diesem Abschnitt des Videos erklärt der Kursleiter, wie eine Breitensuche mithilfe einer Warteschlangendatenstruktur durchgeführt wird. Er demonstriert den Prozess des Erkundens von Knoten und des Hinzufügens ihrer untergeordneten Knoten entsprechend ihrer Reihenfolge zur Warteschlange. Er betont, wie wichtig es ist, bei der Durchquerung der Ebenenreihenfolge eine Warteschlange anstelle eines Stapels zu verwenden. Das Video konzentriert sich dann auf die Implementierung eines binären Suchbaums in Java, wobei der Kursleiter die Klassenstruktur, Instanzvariablen und Methoden zum Hinzufügen von Elementen zum Baum erläutert. Er betont auch, wie wichtig es ist, bei der Arbeit mit binären Suchbäumen einen vergleichbaren Typ zu wählen.
- 03:50:00 Der Kursleiter erklärt den Prozess des Entfernens von Knoten aus einem binären Suchbaum. Sie diskutieren zunächst die öffentliche Methode zum Entfernen von Knoten und erklären, dass sie den Knoten nur entfernen, wenn er im Baum vorhanden ist, was zuerst überprüft wird. Anschließend befassen sie sich mit der rekursiven Methode zum Entfernen des Knotens. Dabei geht es darum, den zu entfernenden Knoten zu finden und ihn dann tatsächlich zu entfernen, je nachdem, ob er linke und/oder rechte Teilbäume hat. Der Dozent erläutert drei verschiedene Fälle zum Entfernen, bei denen es sich entweder um einen linken oder rechten Teilbaum oder sowohl einen linken als auch einen rechten Teilbaum handelt. Sie bieten auch Hilfsmethoden zum Durchlaufen des Baums, um den Nachfolgerknoten zu finden.
- 03:55:00 Der Google-Ingenieur erklärt, wie man einen binären Suchbaum in Python implementiert, einschließlich des Einfügens eines neuen Knotens, der Suche nach einem bestimmten Element und der Berechnung der Höhe des Baums. Er zeigt außerdem, wie man binäre Baumdurchläufe iterativ mithilfe einer benutzerdefinierten Methode namens „traverse“ implementiert, die eine Baumdurchlaufreihenfolge als Eingabe verwendet und einen Iterator für diese Reihenfolge zurückgibt. Als nächstes stellt er Hash-Tabellen vor und erörtert die Bedeutung von Hash-Funktionen sowie beliebte Methoden zur Kollisionsauflösung wie separate Verkettung und offene Adressierung.
Einfacher bis fortgeschrittener Kurs „Datenstrukturen“ – Vollständiges Tutorial von einem Google-Ingenieur (Teile 5–8)
Teil 5
- 04:00:00 Der Dozent stellt das Konzept von Hash-Tabellen und deren Implementierung mithilfe von Hashing-Techniken vor. Hash-Tabellen werden verwendet, um eine Zuordnung von Schlüsseln zu Werten zu erstellen, wobei jeder Schlüssel eindeutig ist und einem Wert zugeordnet ist. Um die Schlüssel auf Werte abzubilden, wird eine Hash-Funktion verwendet, die die Schlüssel auf eine ganze Zahl in einem festen Bereich abbildet. Der Kursleiter zeigt, wie man Hash-Funktionen für beliebige Objekte, wie z. B. Zeichenfolgen, mithilfe der ASCII-Werte der Zeichen in der Zeichenfolge definiert. Hash-Tabellen werden häufig verwendet, um die Häufigkeit von Werten zu verfolgen und Zuordnungen zwischen Schlüssel-Wert-Paaren zu erstellen, sofern die Schlüssel hashbar sind. Der Abschnitt endet mit einer kleinen Herausforderung, bei der es darum geht, eine Hash-Funktion für eine Datenbank mit Personen mit drei Feldern zu definieren.
- 04:05:00 Der Dozent bespricht Hash-Funktionen und ihre Eigenschaften. Die Hash-Funktion ist beliebig definiert und kann unendlich viele Möglichkeiten haben. Der Dozent betont, dass Hash-Funktionen deterministisch sein müssen, um die Hash-Tabelle nicht zu vermasseln. Die Einheitlichkeit der Hash-Funktionen ist auch wichtig, um Hash-Kollisionen zu minimieren, die auftreten, wenn zwei Objekte auf denselben Wert hashen. Der Dozent veranschaulicht außerdem, wie Hash-Werte Objektvergleiche beschleunigen können, und erklärt weiter, dass anstelle der Hash-Funktionen für Hash-Tabellen anspruchsvolle Hash-Funktionen wie kryptografische Hash-Funktionen und Prüfsummen für Dateien verwendet werden.
- 04:10:00 Das Tutorial erklärt, was einen Schlüssel vom Typ „t“ hashbar macht und wie eine Hash-Tabelle funktioniert, indem eine einheitliche Hash-Funktion für die Indizierung verwendet wird. Darin wird erwähnt, dass Hash-Funktionen deterministisch sein und unveränderliche Schlüssel erzwingen müssen, die fest und konstant sind, wie z. B. unveränderliche Zeichenfolgen und ganze Zahlen. Durch die Verwendung der Hash-Funktion als Möglichkeit zur Indizierung in einer Hash-Tabelle können wir schnelle Einfügungs-, Such- und Entfernungszeiten in konstanter Zeit erreichen. Das Tutorial bietet außerdem ein Beispiel für das Einfügen von Schlüssel-Wert-Paaren in eine Tabelle, das schließlich zu einer Hash-Kollision führt, und erklärt, wie mit Kollisionen umgegangen wird.
- 04:15:00 Der Redner diskutiert Techniken zur Hash-Kollisionsauflösung, insbesondere separate Verkettung. Separate Verkettung ist eine Möglichkeit, mit Hash-Kollisionen umzugehen, indem eine Hilfsdatenstruktur, normalerweise eine verknüpfte Liste, verwaltet wird, um alle verschiedenen Schlüssel-Wert-Paare zu speichern, die einen Hash auf einen bestimmten Wert durchführen. Die zeitliche Komplexität einer Hash-Tabelle kann im Durchschnitt eine konstante Zeit für das Einfügen, Entfernen und Suchen erreichen, aber bei einer schrecklichen Hash-Funktion, die nicht einheitlich ist, könnte es sich um eine lineare Zeit handeln. Der Redner liefert auch ein Beispiel dafür, wie separate Verkettung funktioniert und wie wir damit Kollisionen innerhalb unserer Hash-Tabelle behandeln können, indem wir für jeden Index im Array eine verknüpfte Listendatenstruktur verwalten.
- 04:20:00 Der Referent erklärt, wie Lookups in einer Hash-Tabelle mit separater Verkettung funktionieren, die verknüpfte Listen zur Handhabung von Kollisionen verwendet. Mit einem bestimmten Schlüssel demonstriert der Sprecher, wie er den entsprechenden Wert findet, indem er den Schlüssel hasht und die verknüpfte Liste im entsprechenden Bucket der Hash-Tabelle durchsucht. Der Redner geht auch auf einige häufig gestellte Fragen zur Aufrechterhaltung einer konstanten Zeitkomplexität, zum Entfernen von Schlüssel-Wert-Paaren und zur Verwendung unterschiedlicher Datenstrukturen zur Verarbeitung von Buckets in der Hash-Tabelle ein. Abschließend teilt der Redner etwas Quellcode für eine Hash-Tabellen-Implementierung mit separater Verkettung.
- 04:25:00 Das Video stellt Hash-Tabellen und deren Implementierung in Java vor. Zunächst wird die Eintragsklasse besprochen, wobei der Schwerpunkt auf Generika, Hash-Codes und der Methode „equals“ liegt. Anschließend wird die Hash-Tabelle selbst erklärt, einschließlich Instanzvariablen wie maximaler Auslastungsfaktor, Kapazität, Schwellenwert und der Tabelle selbst, die ein Array verknüpfter Listen ist. Verschiedene Methoden wie „Size“, „Empty“, „Clear“, „Contains Key“ und „Hash“ werden ebenfalls zusammen mit ihren Implementierungsdetails besprochen. Abschließend wird die Methode des normalisierten Index erläutert, mit der ein Hash-Wert in einen Index zum Nachschlagen in der Hash-Tabelle umgewandelt wird.
- 04:30:00 In diesem Abschnitt des Videos erläutert der Sprecher die Methoden zur Implementierung einer Hash-Tabelle, z. B. Einfügen, Abrufen, Entfernen, Eintrag suchen und Tabellengröße ändern. Die insert-Methode fügt der Hash-Tabelle einen neuen Eintrag hinzu oder aktualisiert einen vorhandenen, während get den mit einem bestimmten Schlüssel verknüpften Wert abruft. Remove entfernt das Schlüssel-Wert-Paar aus der Hash-Tabelle und die Sucheingabemethode hilft beim Auffinden des Eintrags in einem bestimmten Bucket-Index. Zuletzt ändert die Funktion „Tabellengröße ändern“ die Größe der Tabelle, indem ihre Kapazität verdoppelt wird. Anschließend wird eine neue Tabelle mit der neuen Kapazität erstellt, die Daten aus der alten Tabelle in die neue Tabelle verschoben und die alten Daten entfernt.
- 04:35:00 Der Dozent bespricht die offene Adressierungstechnik zum Auflösen von Kollisionen in Hash-Tabellen. Diese Methode speichert die Schlüssel-Wert-Paare in der Tabelle selbst statt in einer Hilfsdatenstruktur. Daher ist es wichtig, die Größe der Hash-Tabelle und die Anzahl der darin enthaltenen Elemente zu verwalten. Der Auslastungsfaktor, der das Verhältnis der Elemente zur Größe der Tabelle darstellt, muss unter einem bestimmten Schwellenwert gehalten werden, um zu verhindern, dass er exponentiell schlechter wird. Beim Einfügen eines neuen Schlüssels gibt die Hash-Funktion eine ursprüngliche Position für den Schlüssel an, aber wenn es zu einer Kollision kommt, wird eine Sondierungssequenz verwendet, um die nächste offene Stelle zu finden. Die lineare Sondierungssequenz ist eine von vielen, aus denen Sie wählen können.
- 04:40:00 Der Dozent bespricht die offene Adressierung, eine Methode zur Behandlung von Kollisionen in Hash-Tabellen, bei der das Element an einer anderen Stelle platziert wird, wenn der ursprüngliche Hash-Index bereits belegt ist. Es werden verschiedene Sondierungsfunktionen eingeführt, wie z. B. lineare Sondierung, quadratische Sondierung, Doppel-Hashing und Pseudozufallszahlengenerator-Sondierungsfunktionen, die jeweils eine andere mathematische Formel verwenden, um den nächsten Steckplatz zu finden. Die Hauptschwierigkeit bei der offenen Adressierung besteht jedoch darin, dass möglicherweise Zyklen entstehen, die kürzer als die Größe der Hash-Tabelle sind, was zu einer Endlosschleife führen kann. Zur Veranschaulichung dieser Problematik wird ein praktisches Beispiel gegeben.
- 04:45:00 Der Redner erörtert das Problem der Zyklen bei Prüffunktionen, die in Hash-Tabellen verwendet werden, und wie man damit umgeht. Der Sprecher erklärt, dass Techniken wie lineares Sondieren, quadratisches Sondieren und doppeltes Hashing alle diesem Zyklenproblem unterliegen, aber neu definiert werden können, um einen Längenzyklus zu erzeugen, um zu vermeiden, dass man beim Einfügen eines Elements in einer Endlosschleife steckt. Die Konstante „b“ in der linearen Sondierung gilt als veraltet, und der Sprecher erwähnt, dass einige lineare Funktionen möglicherweise nicht in der Lage sind, einen vollständigen Zyklus der Ordnung „n“ zu erzeugen. Die Lösung dieses Problems besteht darin, Sondierungsfunktionen zu wählen, die einen Zyklus von genau „n“ erzeugen, indem sichergestellt wird, dass die Konstante „a“ und die Tabellengröße „n“ zueinander relativ teilerfremd sind.
- 04:50:00 Der Kursleiter bespricht Hash-Tabellen und deren Funktionsweise, einschließlich Prüffunktionen, Tabellengröße, Auslastungsfaktor und Größenänderung. Anhand eines Beispiels mit linearem Sondieren demonstriert er, wie man Schlüssel-Wert-Paare in eine Hash-Tabelle einfügt und durch Hash-Kollisionen verursachte Endlosschleifen vermeidet. Er weist jedoch darauf hin, dass die Wahl der Sondierungsfunktion und der Tabellengröße erhebliche Auswirkungen auf die Leistung haben kann und die Auswahl einer Funktion, deren größter gemeinsamer Nenner mit der Tabellengröße nicht eins ist, zu Zyklen führen und Probleme verursachen kann.
- 04:55:00 Wir sehen ein Beispiel für die Verwendung einer Sondierungsfunktion zum Einfügen von Schlüssel-Wert-Paaren in eine Hash-Tabelle ohne Kollisionen. Sollte es dennoch zu einer Kollision kommen, führt die Sondierungsfunktion die Sondierung fort, bis eine leere Stelle gefunden wird, um das Auftreten eines Zyklus zu vermeiden. Sobald die Anzahl der Elemente den Schwellenwert der Tabelle überschreitet, wird die Tabellengröße verdoppelt, während der GCD von N beibehalten wird. Die alten Elemente werden dann unter Verwendung der neuen Tabellengröße in der neuen Tabelle platziert, während die gleiche Sondierungsfunktion beibehalten wird. Schließlich wird ein neues Schlüssel-Wert-Paar eingefügt, und wenn der Platz frei ist, gibt es keine Probleme.
Teil 6
- 05:00:00 Der Dozent bespricht quadratisches Sondieren in Hash-Tabellen, das zur Behebung von Kollisionen bei der offenen Adressierung verwendet wird. Dabei wird nach einer quadratischen Formel unter Verwendung einer zufälligen Sondierungsfunktion abgetastet. Der Dozent erklärt, dass nicht alle quadratischen Funktionen realisierbar sind, da sie keinen Ordnungszyklus erzeugen, was dazu führt, dass man in einer Endlosschleife stecken bleibt, die meisten zufällig ausgewählten quadratischen Funktionen jedoch am Ende einen Zyklus erzeugen. Der Dozent stellt drei gängige Methoden zur Auswahl einer Sondierungsfunktion vor und konzentriert sich auf die zweite Methode, bei der p von x gleich x im Quadrat plus x dividiert durch zwei ist und die Tabellengröße eine Zweierpotenz ist.
- 05:05:00 Der Redner diskutiert den Prozess des Einfügens von Elementen in Hash-Tabellen mithilfe der Doppel-Hashing- und Open-Adressing-Kollisionsauflösungstechnik. Sie erklären, wie wichtig es ist, dass die Tabellengröße eine Zweierpotenz ist, und wie Kollisionen mithilfe von Sondierungen behandelt werden. Der Referent demonstriert auch den Prozess der Größenänderung der Tabelle, wenn der Auslastungsfaktor einen bestimmten Schwellenwert überschreitet. Anschließend diskutieren sie, wie vorhandene Elemente aktualisiert und neue in die Tabelle eingefügt werden.
- 05:10:00 Der Dozent erklärt das Konzept des Double Hashing, einer Prüfmethode zur Behandlung von Kollisionen in Hash-Tabellen. Das Doppel-Hashing-Schema beinhaltet die Prüfung anhand eines konstanten Vielfachen einer anderen Hash-Funktion, der sogenannten sekundären Hash-Funktion. Der Dozent warnt vor dem Problem der unendlichen Zyklen, die beim doppelten Hashing auftreten können, und stellt eine Strategie zur Behebung des Problems vor, bei der eine Primzahl für die Tabellengröße ausgewählt und ein Wert namens Delta erstellt wird. Er diskutiert auch die systematische Methode zur Generierung neuer Hash-Funktionen für verschiedene Datentypen unter Verwendung desselben Grundbausteins.
- 05:15:00 Der Referent erklärt das Konzept von Hash-Funktionen und wie diese kombiniert werden können, um eine neue Hash-Funktion zu erstellen. Sie erwähnen die Verwendung universeller Hash-Funktionen und geben ein Beispiel für die Verwendung von doppeltem Hashing. Sie diskutieren den Prozess des Einfügens von Schlüssel-Wert-Paaren in eine Hash-Tabelle und behandeln gleichzeitig Hash-Kollisionen und -Updates. Das Beispiel verwendet eine Tabellengröße von sieben und einen maximalen Lastfaktor von 0,75, und die Hashing-Funktion verwendet ganze Zahlen und reelle Zahlen als Bausteine.
- 05:20:00 Das Tutorial erklärt den Prozess der Größenänderung und Vergrößerung einer Hash-Tabelle mit doppeltem Hashing. Dazu gehört das Verdoppeln der Tabellengröße, das Finden der nächsten Primzahl über diesem Wert, das Zuweisen einer neuen Tabelle und das Einfügen der alten Elemente in die neue Tisch. Das Tutorial enthält ein Beispiel, bei dem die ursprüngliche Tabelle nach dem Einfügen von fünf Elementen ihren maximalen Schwellenwert erreicht hat und die Größe der Tabelle auf die neue Größe 17 geändert wird. Das Tutorial untersucht auch die Probleme, die beim Entfernen von Elementen aus einer Hash-Tabelle mithilfe der offenen Adressierung auftreten Schema und die Bedeutung der Vermeidung von Kollisionen bei Einfüge- und Löschvorgängen.
- 05:25:00 Das Video erklärt, wie mit Hash-Kollisionen und Löschungen in einer Hash-Tabelle umgegangen wird. Die naive Löschmethode, bei der lediglich der Inhalt des Buckets gelöscht wird, erweist sich als fehlerhaft, da sie die Fähigkeit beeinträchtigt, Elemente in der Hash-Tabelle ordnungsgemäß zu finden. Stattdessen empfiehlt das Video, anstelle des gelöschten Elements eine eindeutige Markierung, einen sogenannten Tombstone, zu platzieren. Diese Markierung kann später durch ein neues Schlüssel-Wert-Paar ersetzt oder bei der Größenänderung der Hash-Tabelle entfernt werden. Das Video bietet ein Beispiel für die Verwendung quadratischer Sondierung, um zu zeigen, wie Tombstones bei der Hash-Tabellensuche verwendet werden.
- 05:30:00 Der Google-Ingenieur bietet einen Überblick über Hash-Tabellen, die offene zwei Adressen als Kollisionsauflösungsschema verwenden. Der Ingenieur diskutiert Lazy Deletion oder Lazy Relocation, was die Verschiebung von Schlüssel-Wert-Paaren beinhaltet, um zu vermeiden, dass beim Sondieren auf eine Reihe von Tombstones gestoßen wird. Der Ingenieur stellt außerdem eine exemplarische Vorgehensweise für den Code für eine Hash-Tabelle bereit, die quadratisches Prüfen verwendet. Dabei werden Schlüsselwertpaare direkt in einem Array gespeichert, anstatt ein Array mit einer Wrapper-Klasse für einen Eintrag zu haben. Der Ingenieur untersucht den Konstruktor und die Standardkonstanten für die Hash-Tabelle, die es Benutzern ermöglicht, sie ohne Parameter zu initialisieren.
- 05:35:00 In diesem Abschnitt des Kurses erklärt der Dozent die Implementierung der Hash-Tabelle mithilfe quadratischer Sondierung. Die Methode umfasst die Berechnung des Schwellenwerts, die Normalisierung des Index und die Initialisierung der Tabellen. Die Informationen zur Einfügemethode werden bereitgestellt, wenn Schlüssel-Wert-Paare in die Hash-Tabelle eingefügt oder aktualisiert werden, wenn der Schlüssel bereits vorhanden ist. Der Dozent bespricht auch die Schlüsselanzahl, die Leerprüfung der Hash-Tabelle und die Put-Addition, bevor er zur Einfügemethode übergeht. Die do-while-Schleife zum Einfügen eines Schlüssels wird ausführlich erklärt.
- 05:40:00 Der Dozent erklärt die Methoden „Contains Key“, „Has Key“, „Get“ und „Remove“ einer Hash-Tabellenimplementierung. Die Methoden „Contains Key“ und „Hats Key“ prüfen, ob ein Schlüssel in der Hash-Tabelle vorhanden ist, indem sie die Methode „get“ aufrufen, die einen wahren oder falschen Wert für das Flag „Contains“ zurückgibt. Die get-Methode findet den Hash-Index und sucht nach dem Schlüssel. Wenn der Schlüssel vorhanden ist, wird das Flag „enthält“ auf „true“ gesetzt und der Wert wird zurückgegeben. Die Entfernungsmethode ist einfacher, bei der ein Schlüssel zuerst in der Hash-Tabelle gefunden, dann dekrementiert und an seiner Stelle ein Tombstone abgelegt wird. Die Methode zur Größenänderung der Tabelle wird aufgerufen, wenn neue Elemente eingefügt werden, um die Tabellengröße zu vergrößern, wobei eine neue Tabelle zugewiesen wird und die aktuelle Tabelle mit der neuen Tabelle ausgetauscht wird, um die Einfügemethode aufzurufen.
- 05:45:00 Der Fenwick-Baum, auch als binärer Indexbaum bekannt, wird als Datenstruktur eingeführt, um Bereichsabfragen für ein Array effizient zu berechnen und Punktaktualisierungen durchzuführen. Die Motivation hinter dem Fenwick-Baum ist die Ineffizienz linearer Abfragen bei der Berechnung von Bereichen in einem Array. Durch die Berechnung aller Präfixsummen für das Array können Bereichsabfragen in konstanter Zeit berechnet werden. Aktualisierungen des Arrays erfordern jedoch eine Neuberechnung aller Präfixsummen, was den Prozess ineffizient macht. Der Fenwick-Baum wurde erstellt, um dieses Problem zu lösen, indem er Bereichsabfragen und Punktaktualisierungen in logarithmischer Zeit mit linearer Konstruktionszeit unterstützt. Der Fenwick-Baum funktioniert so, dass jede Zelle für eine Reihe anderer Zellen verantwortlich ist, basierend auf dem Wert ihres niedrigstwertigen Bits.
- 05:50:00 In diesem Abschnitt des Videos bespricht der Kursleiter Fenwick-Bäume und wie sie für Bereichsabfragen funktionieren. Er zeigt ein Diagramm mit einem einsbasierten Array und der binären Darstellung jeder Zahl. Das Diagramm zeigt die niedrigstwertigen Bits, die für sich selbst verantwortlich sind, und alle anderen Zellen, die für einen Bereich von 2, 4, 8 oder 16 Zellen verantwortlich sind. Um eine Bereichsabfrage durchzuführen, erklärt der Kursleiter, wie die Präfixsumme bis zu einem bestimmten Index durch Kaskadierung nach unten bis zum Erreichen von Null berechnet wird. Er zeigt, wie man die Präfixsumme für einen bestimmten Index ermittelt und wie man eine Intervallsumme zwischen zwei gegebenen Indizes berechnet.
- 05:55:00 Wir lernen, wie man Präfixsummen mithilfe eines kaskadierenden Abwärtseffekts berechnet und wie man einen Bereichsabfragealgorithmus mithilfe von Fenwick-Bäumen durchführt. Bei der Präfixsummenberechnung wird bei einem gegebenen Index begonnen und das niedrigstwertige Bit vom Wert subtrahiert, bis dieser Null erreicht. Anschließend werden bei jeder Subtraktion alle Werte addiert. Der Bereichsabfragealgorithmus verwendet Fenwick-Bäume, bei denen wir die Differenz zwischen Präfixsummen für Bereichsabfragen ermitteln. Der Algorithmus erfordert Bitmanipulation und bietet einen hübschen kleinen Algorithmus für schnellere Berechnungen. Der Videoautor empfiehlt, sich das vorherige Video zur Bereichsabfrage des Fenwick-Baums anzusehen, um mehr Kontext darüber zu erhalten, wie der Baum eingerichtet ist und wie Vorgänge daran ausgeführt werden.
Teil 7
- 06:00:00 Das Konzept der Punktaktualisierungen und der Fenwick-Baumkonstruktion wird vom Google Engineer erklärt. Punktaktualisierungen umfassen das Hinzufügen von Werten zum Baum an einem bestimmten Index und das Suchen der Zellen, die für diesen Verantwortungsbereich verantwortlich sind. Der lineare Aufbau des Fenwick-Baums beinhaltet die Aktualisierung der unmittelbaren Zelle, die für einen Wert verantwortlich ist, indem die Werte an Ort und Stelle im gesamten Baum verteilt werden, was zu einem voll funktionsfähigen Fenwick-Baum führt. Der Weitergabeprozess basiert auf der kaskadierenden Idee, das übergeordnete Element zu aktualisieren, das für einen bestimmten Wert verantwortlich ist.
- 06:05:00 In diesem Abschnitt des Tutorials wird das Konzept eines Fenwick-Baums ausführlich erklärt. Ein Fenwick-Baum ist eine Datenstruktur, die zur schnellen Durchführung von Bereichsabfragen und Punktaktualisierungen für ein Array von Werten verwendet wird. Die Datenstruktur nutzt eine Art binäre Indizierung, bei der jede Zelle für die Weitergabe ihres Werts an ihre übergeordnete Zelle usw. verantwortlich ist. Außerdem wird der Konstruktionsalgorithmus für einen Fenwick-Baum besprochen, bei dem ein Array von Werten in einen Fenwick-Baum umgewandelt wird, indem das ursprüngliche Array geklont und die übergeordnete Zelle für jedes Element in der neuen Baumstruktur berechnet wird. Der Quellcode für eine Fenwick-Baum-Implementierung in Java wird gezeigt und ist in einem GitHub-Repository verfügbar.
- 06:10:00 Der Kursleiter erklärt, wie man eine Fenwick-Baumklasse und ihre verschiedenen Konstruktoren erstellt. Er erklärt auch die Präfixsummen, die es ermöglichen, die Präfixsumme von eins bis i zu berechnen. Das Video behandelt außerdem das Hinzufügen aus einer Punktaktualisierung und eine zusätzliche Methode zum Festlegen des Index auf k. Der Dozent betont die Bedeutung der binären Manipulation und der Suffix-Array-Datenstruktur, die bei der String-Verarbeitung sehr nützlich ist.
- 06:15:00 Das Konzept von Suffixen und Suffix-Arrays wird vorgestellt, mit einem Beispiel für die Erstellung eines Suffix-Arrays für das Wort „camel“. Das Suffix-Array ist ein Array sortierter Indizes, das eine komprimierte Darstellung der sortierten Suffixe ermöglicht, ohne die Suffixe selbst zu speichern, was es zu einer platzsparenden Alternative zu einem Suffixbaum macht. Das Longest Common Prefix (LCP)-Array, das speichert, wie viele Zeichen zwei sortierte Suffixe gemeinsam haben, wird ebenfalls als wichtige Information im Zusammenhang mit dem Suffix-Array vorgestellt, mit einem Beispiel für den Aufbau des LCP-Arrays für einen gegebenen Wert Zeichenfolge.
- 06:20:00 Das Video diskutiert die Anwendung von Suffix-Arrays und LCP-Arrays beim Finden und Zählen eindeutiger Teilzeichenfolgen auf effizientere Weise als der naive Algorithmus, der viel Platz benötigt. Durch die Nutzung der im LCP-Array gespeicherten Informationen bietet es nicht nur eine schnelle, sondern auch platzsparende Lösung. Das LCP-Array stellt die gemeinsame Anzahl von Zeichen zwischen zwei benachbarten Suffixen der ursprünglichen Zeichenfolge dar. Durch die Untersuchung der LCP-Werte kann man bestimmen, welche Teilzeichenfolgen wiederholt werden, und sie eliminieren, um alle eindeutigen Teilzeichenfolgen effektiv zu zählen.
- 06:25:00 Der Redner diskutiert das Problem, den längsten gemeinsamen Teilstring zu finden, der von mindestens k aus n gegebenen Strings geteilt wird. Ein Ansatz zur Lösung dieses Problems ist die dynamische Programmierung, die jedoch schnell unhandlich werden kann. Ein besserer Ansatz ist die Verwendung eines Suffix-Arrays, das die Lösung in linearer Zeit finden kann. Zu diesem Zweck erklärt der Sprecher, dass wir zunächst alle Zeichenfolgen zu einer größeren Zeichenfolge verketten und zwischen jeder Zeichenfolge eindeutige Sentinel-Werte hinzufügen, um eine Vermischung von Suffixen zu vermeiden. Anschließend erstellen wir das Suffix-Array für diese verkettete Zeichenfolge, das es uns ermöglicht, die längste gemeinsame Teilzeichenfolge von K Zeichenfolgen zu finden, indem wir nach K Zeichenfolgen mit unterschiedlichen Farben suchen, die den größten LCP-Wert gemeinsam haben.
- 06:30:00 Das Video-Tutorial erläutert, wie man mithilfe einer Schiebefenstertechnik den längsten gemeinsamen Teilstring von k verschiedenen Farben innerhalb eines Strings findet. Der Ansatz besteht darin, die Fenstergröße so anzupassen, dass sie k Suffixe unterschiedlicher Farbe enthält, und den minimalen LCP-Wert innerhalb dieses Bereichs abzufragen. Die Mindestbereichsabfrage kann mithilfe einer linearen Lösung oder einer Mindestbereichsabfragedatenstruktur wie einem Segmentbaum gelöst werden. Das Tutorial empfiehlt außerdem die Verwendung einer Hash-Tabelle, um den Überblick über die Farben im Fenster zu behalten. Das Schiebefenster wird nach unten erweitert, um fehlende Farben zu erfassen, und verkleinert sich, wenn die Kriterien erfüllt sind.
- 06:35:00 In diesem Abschnitt des Videos zeigt der Kursleiter ein Beispiel für die Lösung des Problems mit der längsten gemeinsamen Teilzeichenfolge mit einem Suffix-Array. Die Fenster-LCP- und Fenster-LCS-Werte helfen dabei, die längsten gemeinsamen Präfix- und längsten gemeinsamen Teilzeichenfolgenwerte für das aktuelle Fenster zu verfolgen, während die LCS-Länge und der LCS-Satz die bisher besten Werte verfolgen. Das Beispiel verwendet vier Strings und mindestens zwei Strings aus dem Vierer-Pool, um den längsten gemeinsamen Teilstring zu teilen. Der Dozent zeigt, wie man das Fenster vergrößert und verkleinert, während man nach dem längsten gemeinsamen Teilstring sucht, und weist auf eine Herausforderung hin, die sich die Zuschauer auf der Besetzungswebsite ansehen können, und stellt einen Link zu einer Implementierung des Algorithmus auf GitHub bereit.
- 06:40:00 Das Video erklärt den Prozess der Lösung des längsten gemeinsamen Teilstringproblems mithilfe der Schiebefenstertechnik. Durch Erweitern und Verkleinern der Fenstergröße und die Verwendung des längsten gemeinsamen Präfix-Arrays zur Identifizierung der gemeinsamen Teilzeichenfolgen findet der Algorithmus eine Lösung mit linearer Zeitkomplexität. Das Video stellt dann das Problem der längsten wiederholten Teilzeichenfolge vor und erklärt, wie man das längste gemeinsame Präfix-Array verwendet, um die längste wiederholte Teilzeichenfolge in einer bestimmten Zeichenfolge effizient zu finden, im Vergleich zum naiven Ansatz, der N-Quadrat-Zeit und viel Speicher erfordert.
- 06:45:00 Der Google-Ingenieur lehrt die Verwendung eines Suffix-Arrays und eines LCP-Arrays, um den am längsten wiederholten Teilstring zu finden. Der LCP-Wert an einem Index gibt die Länge des längsten gemeinsamen Präfixes zwischen zwei benachbarten Suffixen an. Der Maximalwert im LCP-Array gibt die Länge des längsten wiederholten Teilstrings an. Bei Gleichständen müssen alle möglichen längsten Werte gefunden werden. Anschließend erklärt der Ingenieur die Bedeutung ausgeglichener binärer Suchbäume und wie sie sich von herkömmlichen binären Suchbäumen dadurch unterscheiden, dass sie sich selbst anpassen, um eine logarithmische Höhe relativ zur Anzahl der von ihnen gehaltenen Knoten beizubehalten, was das Einfügen und Löschen extrem schnell macht. Das Schlüsselkonzept, um dies zu erreichen, sind Baumrotationen, die im Video näher erläutert werden.
- 06:50:00 Das Konzept der Bauminvariante und Baumrotationen in ausgeglichenen binären Suchbäumen wird erklärt. Eine Bauminvariante ist eine einem Baum auferlegte Regel, die am Ende jeder Operation eingehalten werden muss und durch die Anwendung einer Reihe von Baumrotationen sichergestellt wird. Baumrotationen sind legitime Transformationen, die sich um Knoten in einem Baum bewegen, ohne die binäre Suchbauminvariante zu zerstören, wenn die Reihenfolge und Platzierung der Knoten beibehalten wird. Der Prozess der Rechtsdrehung wird ausführlich erläutert und die Schritte zum Aktualisieren von Zeigern besprochen, wenn Knoten sowohl auf den untergeordneten als auch auf den übergeordneten Knoten verweisen.
- 06:55:00 Das Video-Tutorial konzentriert sich darauf, zu demonstrieren, wie Knoten mithilfe der Baumrotationstechnik in einen AVL-Baum eingefügt werden, und erklärt gleichzeitig die Eigenschaften, die AVL-Bäume im Gleichgewicht halten. Zunächst erklärt das Video, was ein AVL-Baum ist und welche Bedeutung er als erster Typ eines ausgeglichenen binären Suchbaums hat. Anschließend stellt das Video den Ausgleichsfaktor vor, der die Differenz zwischen der Höhe des rechten Teilbaums und der linken Teilbaumhöhe darstellt. Das Video betont, dass der Gleichgewichtsfaktor jedes Knotens entweder minus eins, null oder plus eins sein sollte, um das Gleichgewicht des AVL-Baums aufrechtzuerhalten. Anschließend wird im Tutorial erläutert, wie mit Fällen umgegangen werden soll, in denen dies nicht zutrifft, was mit Baumrotationen gelöst werden kann.
Teil 8
- 07:00:00 Der Kursleiter erklärt die vier verschiedenen Rotationsfälle, die zum Ausbalancieren eines linkslastigen Baums in einem AVL-Baum erforderlich sind. Der Dozent stellt außerdem Pseudocode zum Einfügen eines Knotens in einen AVL-Baum bereit und erläutert die Aktualisierungs- und Ausgleichsmethoden. Die Aktualisierungsmethode berechnet die Höhe und den Ausgleichsfaktor eines Knotens, während die Ausgleichsmethode prüft, ob der Ausgleichsfaktor eines Knotens die AVL-Baumeigenschaft verletzt, und die geeignete Drehung bestimmt, um den Baum neu auszugleichen. Die Links-Rechts- und Rechts-Links-Fälle werden ebenfalls erläutert, da sie sich nach der ersten Drehung auf Links-Links- und Rechts-Rechts-Fälle reduzieren.
- 07:05:00 Das Video erklärt, wie man Elemente aus einem Avielle-Baum entfernt, was dem Entfernen von Elementen aus einem regulären binären Suchbaum sehr ähnlich ist. Der Entfernungsprozess kann in zwei Schritte unterteilt werden: Suchen des Elements und Ersetzen durch einen Nachfolgeknoten, um die Invariante des binären Suchbaums beizubehalten. Um den Knoten zu finden, muss das Zielelement mit Knoten im Baum verglichen werden, bis eine Übereinstimmung gefunden wird oder die Suche das Ende des Baums erreicht. Der Ersetzungsprozess hängt davon ab, ob der zu entfernende Knoten ein Blattknoten ist oder nur einen linken oder rechten Teilbaum hat, wobei der Nachfolgerknoten in den beiden letztgenannten Fällen der unmittelbar untergeordnete Knoten ist.
- 07:10:00 Der Dozent erklärt, wie man einen Knoten aus einem binären Suchbaum entfernt und liefert Beispiele für die drei Fälle des Löschens. Der erste Fall liegt vor, wenn der zu entfernende Knoten keine untergeordneten Knoten hat, der zweite, wenn er ein untergeordnetes Element hat, und der letzte, wenn er zwei untergeordnete Knoten hat. Der Kursleiter erklärt außerdem, wie man die Methode zum Entfernen binärer Suchbäume für AVL-Bäume durch einfaches Hinzufügen von zwei Codezeilen erweitert, um sicherzustellen, dass der Baum ausgeglichen bleibt und die Werte für Ausgleichsfaktor und Höhe auf dem neuesten Stand bleiben. Abschließend stellt der Dozent einen Link zu seinem GitHub-Repository bereit, wo Zuschauer den Quellcode für den AVL-Baum und eine Live-Demonstration des AVL-Baums in Aktion finden können.
- 07:15:00 Der Dozent erläutert den Quellcode für eine rekursive AVL-Baum-Implementierung in Java. Der AVL-Baum akzeptiert ein generisches Typargument und speichert den Wert innerhalb des Knotens, der vergleichbar sein muss. Die Knotenunterklasse speichert die linken und rechten untergeordneten Zeiger sowie die Höhe und den Gleichgewichtsfaktor des Knotens. Der Baum kann über die Baumdruckerschnittstelle auf dem Terminal angezeigt werden, und im Code werden öffentliche Methoden wie „Size“, „Is Empty“ und „Set Includes“ bereitgestellt. Die Einfügungsmethode wird außerdem anhand von Basisfällen und Vergleichswerten erläutert, um festzustellen, ob eine Einfügung erfolgreich war oder nicht.
- 07:20:00 Die private Einfügemethode im AVL-Baum wird erklärt, die neue Knoten entweder in den linken oder rechten Teilbaum einfügt und dabei den Ausgleichsfaktor und die Höhe der Knoten entsprechend aktualisiert. Die Aktualisierungsmethode aktualisiert die Höhe und den Gleichgewichtsfaktor eines Knotens, und die Gleichgewichtsmethode ruft die erforderlichen Rotationsmethoden auf, um das Gleichgewicht des Baums aufrechtzuerhalten. Die Links-Links-, Links-Rechts-, Rechts-Rechts- und Rechts-Links-Fälle werden erläutert und die Reihenfolge der Aktualisierungsmethoden nach der Rotation wird als entscheidend für die Aufrechterhaltung des Gleichgewichts des AVL-Baums hervorgehoben.
- 07:25:00 Der Dozent bespricht die Remove-Methode der Datenstruktur des binären Suchbaums. Er erklärt, dass die Methode zum Entfernen eines Elements zunächst prüft, ob das Element im Baum vorhanden ist, und anschließend die private Methode „remove“ aufruft. Der Dozent beschreibt die vier Fälle, die beim Entfernen auftreten können, und schlägt eine Heuristik vor, um zu bestimmen, aus welchem Teilbaum entfernt werden soll, wenn versucht wird, einen Knoten mit beiden Teilbäumen zu entfernen. Abschließend erinnert er die Zuschauer daran, die Update- und Rebalance-Methode beim Rückruf der Remove-Methode aufzurufen, um sicherzustellen, dass der Baum trotz Knotenentfernungen ausgeglichen bleibt.
- 07:30:00 Der Google-Ingenieur stellt die indizierte Prioritätswarteschlange vor, eine Datenstruktur, die schnelle Aktualisierungen und Löschungen von Schlüssel-Wert-Paaren unterstützt. Es löst das Problem, die Werte in einer Prioritätswarteschlange schnell nachschlagen und dynamisch ändern zu können, was in verschiedenen Situationen nützlich sein kann, beispielsweise im Wartezimmer eines Krankenhauses, in dem Patienten zuerst von der Person mit der höchsten Priorität bedient werden müssen. Der Ingenieur liefert ein Beispiel für Patienten mit unterschiedlichen Prioritäten und wie die indizierte Prioritätswarteschlange dabei helfen kann, Prioritäten im laufenden Betrieb zu aktualisieren.
- 07:35:00 Das Video erläutert Indexprioritätswarteschlangen, die eine effiziente dynamische Aktualisierung der Prioritäten für bestimmte Elemente ermöglichen. Der erste Schritt bei der Verwendung einer Indexprioritätswarteschlange besteht darin, allen Schlüsseln Indexwerte zuzuweisen und so eine bidirektionale Zuordnung zu erstellen. Diese Zuordnung sollte bidirektional sein und kann mit einer bidirektionalen Hash-Tabelle erleichtert werden. Der Grund für die Verwendung von Indexwerten für Schlüssel besteht darin, die Indizierung in Arrays zu ermöglichen. Dies ist häufig die Art und Weise, wie Prioritätswarteschlangen implementiert werden.
- 07:40:00 Der Sprecher stellt das Konzept einer Indexprioritätswarteschlange vor und erklärt die Vorgänge, die sie unterstützen sollte, einschließlich Löschen von Schlüsseln, Abrufen des mit einem Schlüssel verknüpften Werts, Überprüfen, ob ein Schlüssel in der Prioritätswarteschlange vorhanden ist, Abrufen des Schlüsselindex mit der kleinste Wert, das Abrufen des kleinsten Werts im Index, die Möglichkeit, Schlüssel-Wert-Paare einzufügen und zu aktualisieren, und die speziellen Aktualisierungsvorgänge erhöhen und verringern den Schlüssel. Die Zeitkomplexität für alle diese Operationen ist entweder konstant oder logarithmisch. Der Redner bietet außerdem eine Auffrischung der traditionellen Datenstruktur der Prioritätswarteschlange, einschließlich der Funktionsweise des Binärheaps, des Einfügens eines neuen Werts in die Prioritätswarteschlange und des Entfernens von Elementen daraus.
- 07:45:00 Wie implementieren wir eine indizierte Prioritätswarteschlange mit einem binären Heap? Der erste Schritt besteht darin, jedem Element einen eindeutigen Indexwert und einen Anfangswert für die Indexprioritätswarteschlange zuzuweisen. Dann verwenden wir eine Warteschlange mit minimal indizierter Priorität, um zuerst nach dem niedrigsten Wert zu sortieren, und wir verwalten eine Positionskarte, um uns den Index eines Knotens im Heap für einen bestimmten Schlüsselindex mitzuteilen. Darüber hinaus pflegen wir eine inverse Nachschlagetabelle, um den Schlüssel für einen bestimmten Knoten zu finden. Mithilfe dieser Informationen können wir für verschiedene Anwendungen effizient auf die Prioritätswarteschlange zugreifen und diese bearbeiten, beispielsweise um Patienten in einem Krankenhaus oder Kunden in einem Restaurant zu priorisieren.
- 07:50:00 In dem Video wird erläutert, wie nützliche Vorgänge ausgeführt werden, z. B. das Einfügen, Aktualisieren und Entfernen von Schlüssel-Wert-Paaren in einer Indexprioritätswarteschlange. Der Vorgang zum Einfügen ähnelt einer regulären Prioritätswarteschlange, verfügt jedoch über den zusätzlichen Schritt der Aktualisierung der Position und der inversen Karten. Das Video stellt Pseudocode für den Einfügungsprozess bereit und zeigt, wie der Knoten durch den Heap nach oben verschoben wird, bis die Heap-Invariante erfüllt ist. Der Austauschvorgang umfasst die Aktualisierung der Positions- und Umkehrkarten, nicht jedoch des Wertearrays, das weiterhin durch den Schlüsselindex und nicht durch den Knotenindex indiziert wird. Das Video geht auch kurz auf das Abfragen und Entfernen von Schlüssel-Wert-Paaren ein, die ähnliche Schritte wie das Einfügen umfassen, jedoch in umgekehrter Reihenfolge.
- 07:55:00 Das Video erklärt, wie das Entfernen von Elementen aus einer indizierten Prioritätswarteschlange von linearer Zeitkomplexität zu logarithmischer Zeitkomplexität verbessert wird, indem Knotenpositionssuchen verwendet werden, die jetzt zeitkonstante sind. Das Video enthält ein schrittweises Beispiel für das Entfernen von Knoten, einschließlich des Austauschens von Knoten, des Speicherns von Schlüsselwertpaaren vor dem Entfernen, des Bereinigens entfernter Knoten und des Wiederherstellens der Heap-Invariante durch Verschieben des ausgetauschten Knotens nach oben oder unten. Darüber hinaus wird Pseudocode zum Entfernen von Schlüssel-Wert-Paaren bereitgestellt, der eine kurze fünfzeilige Implementierung und einen dreizeiligen Bereinigungsprozess zeigt. Abschließend beschreibt das Video die Synchronisierungsmethode und ihre Funktionsweise sowie Aktualisierungen von Schlüssel-Wert-Paaren, deren Entfernung ähnlich ist, aber ebenfalls logarithmische Zeit in Anspruch nimmt.
Kompletter Kurs zur C-Programmierung kostenlos
Kompletter Kurs zur C-Programmierung kostenlos
00:00:00 - 01:00:00 Das Video „Kostenloser vollständiger C-Programmierkurs“ zeigt den Zuschauern, wie sie den gcc-Compiler installieren, eine IDE einrichten und C-Code schreiben. Das Video behandelt die Grundlagen der C-Programmierung, einschließlich der Verwendung von printf-Anweisungen, Kommentaren, Escape-Sequenzen und Formatspezifizierern zur Anzeige verschiedener Datentypen. Der Kursleiter erklärt, wie man Variablen erstellt und initialisiert und wie man arithmetische und Inkrementierungs-/Dekrementierungsoperatoren verwendet. Darüber hinaus behandelt das Video das Akzeptieren von Benutzereingaben mit scanf und das Formatieren der Ausgabe mit printf. Der Dozent erläutert außerdem nützliche mathematische Funktionen in C und wie man sie zur Berechnung des Umfangs und der Fläche eines Kreises basierend auf Benutzereingaben für den Radius verwendet. Das Video betont, dass C zwar eine schwierige Sprache ist, sie aber jeder mit Beharrlichkeit und Mühe erlernen kann.
01:00:00 - 02:00:00 Das YouTube-Video „C Programming Full Course for Free“ vermittelt Programmierkonzepte in der Sprache C. In diesem Videoabschnitt behandelt der Kursleiter Themen wie if/else-Anweisungen, switch-Anweisungen, logische Operatoren, Funktionen und Schleifen. Der Kursleiter erklärt bedingte Anweisungen, die es dem Programm ermöglichen, auf der Grundlage von Bedingungen Entscheidungen zu treffen, und erläutert, wie die switch-Anweisung eine effizientere Version der else if-Anweisung ist. Darüber hinaus zeigt der Dozent ausführlich, wie man Temperatureinheiten umrechnet, ein einfaches Taschenrechnerprogramm erstellt, logische Operatoren zur Verbesserung der Programmeffizienz verwendet und wie man Funktionen zur Minimierung von Coderedundanz verwendet. Abschließend erklärt der Dozent den ternären Operator und wie String-Funktionen die Programmerstellung unterstützen können.
02:00:00 - 03:00:00 Dieser vollständige C-Programmierkurs deckt ein breites Themenspektrum ab, beginnend mit der Erklärung des Unterschieds zwischen einer While- und einer Do-While-Schleife und der Verwendung verschachtelter Schleifen zum Erstellen von Formen. Anschließend behandelt das Video die Grundlagen von Arrays und wie man Elemente in einem eindimensionalen Array durchläuft und anzeigt, bevor es zu zweidimensionalen Arrays geht und wie man ein 2D-Gitter oder eine Datentabelle erstellt. Anschließend stellt der Kursleiter das Konzept des Variablenaustauschs und Sortieralgorithmen wie die Blasensortierung vor und unterrichtet über Strukturen und Typdefinitionen in C sowie über die Generierung von Zufallszahlen und die Erstellung eines Zahlenratespiels. Insgesamt vermittelt dieser Kurs ein umfassendes und tiefgreifendes Verständnis der C-Programmierkonzepte.
03:00:00 - 04:00:00 Dieses YouTube-Video mit dem Titel „C Programming Full Course for Free“ deckt ein umfassendes Spektrum an C-Programmierthemen ab, einschließlich der Erstellung von Spielen wie Zahlenraten und Quizspielen, und behandelt Konzepte wie Gedächtnis, Zeiger, bitweise Operatoren und Datei-E/A. Darüber hinaus erklärt das Video, wie man ein Tic Tac Toe-Spiel erstellt, das verschachtelte for-Schleifen und if-Anweisungen verwendet, um nach einem Gewinner zu suchen und zufällige Züge für den Computerspieler zu generieren. Der Kursleiter liefert im gesamten Video klare Erklärungen und Demonstrationen, was es zu einer wertvollen Ressource für alle macht, die sich für das Erlernen der C-Programmierung interessieren.
04:00:00 - 04:00:00 Der Kursleiter baut das Tic-Tac-Toe-Spiel in C weiter auf, fügt eine Prüfung hinzu, um sicherzustellen, dass die ausgewählte Stelle leer ist, bevor er einen Zug platziert, und erstellt eine Funktion zum Drucken des Gewinners. Anschließend fügen sie mithilfe einer Do-While-Schleife eine Option zum erneuten Abspielen hinzu und setzen die Variablen zu Beginn jeder Schleife zurück. Der Code wird im Kommentarbereich zur Verwendung durch Benutzer freigegeben.
Teil 1
- 00:00:00 Der Autor erklärt, wie wichtig es ist, C zu lernen, eine Sprache mittlerer Ebene, die als Brücke zwischen High-Level-Software und Low-Level-Hardware fungiert. C entstand in den 1970er Jahren und wird häufig für verschiedene Zwecke verwendet, darunter zum Schreiben von Compilern, Betriebssystemen und Datenbanken. Der YouTuber bietet außerdem Anweisungen zum Einrichten einer IDE und zum Installieren der erforderlichen Erweiterungen und des Compilers, um mit dem Schreiben von C-Code zu beginnen. Der YouTuber warnt jedoch davor, dass C eine schwierige Sprache für Anfänger sei, aber mit Beharrlichkeit und Mühe könne jeder sie lernen.
- 00:05:00 Das Video erklärt, wie man gcc auf einem Mac- oder Linux-System installiert und wie man den Pfad zum gcc-Compiler unter Umgebungsvariablen hinzufügt. Sobald gcc installiert ist, wird im Video erläutert, wie die Standard-Build-Aufgabe konfiguriert wird, damit VS Code weiß, wie das Programm kompiliert wird. Das Video empfiehlt, die Schriftgröße zu erhöhen und die automatische Speicherung zu aktivieren, um später Kopfschmerzen zu vermeiden. Das Video geht auch auf die Grundlagen der C-Programmierung ein und beinhaltet wichtige Funktionen wie Hashtag-Include, std für Standard-IO-Eingabe/Ausgabe und das Drucken von F-Klammern. Abschließend wird im Video die Notwendigkeit hervorgehoben, die Anweisung „return 0“ am Ende der Hauptfunktion hinzuzufügen, um nach Fehlern zu suchen.
- 00:10:00 In diesem Abschnitt des C-Programmier-Tutorials zeigt der Kursleiter, wie man printf-Anweisungen zum Ausdrucken von Text verwendet und wie man mithilfe einer Escape-Sequenz ein neues Zeilenzeichen hinzufügt. Außerdem zeigt er, wie man eine C-Datei über die Eingabeaufforderung kompiliert und ausführt, und erklärt den Zweck von Kommentaren in der C-Programmierung. Das Video behandelt die Grundlagen der Programmierung in C und gibt hilfreiche Tipps für Einsteiger.
- 00:15:00 In diesem Abschnitt des Video-Tutorials zur C-Programmierung erklärt der Kursleiter, wie Sie Kommentare und Escape-Sequenzen in Ihrem Code verwenden. Kommentare werden zur Erläuterung, Beschreibung oder als Notiz für jeden verwendet, der den Code liest. Einzeilige Kommentare werden mit zwei Schrägstrichen erstellt, während mehrzeilige Kommentare mit einem Schrägstrich gefolgt von einem Sternchen und am Ende mit einem Sternchen gefolgt von einem Schrägstrich erstellt werden. Escape-Sequenzen hingegen sind Zeichenkombinationen, die Aktionen innerhalb einer Textzeile oder einer Zeichenfolge angeben. Die am häufigsten verwendeten Escape-Sequenzen dienen zum Erstellen neuer Zeilen und Tabulatoren innerhalb von Textzeichenfolgen. Der Kursleiter zeigt außerdem, wie Anführungszeichen, einfache Anführungszeichen und Backslashes mithilfe von Escape-Sequenzen angezeigt werden.
- 00:20:00 Im Video wird erläutert, wie Variablen in der C-Programmierung erstellt werden. Zunächst müssen Sie eine Variable deklarieren und dieser Variable einen Namen und einen Datentyp zuweisen. Als nächstes müssen Sie diese Variable initialisieren, indem Sie sie auf einen Wert setzen. Das Video enthält Beispiele für verschiedene Datentypen, einschließlich Ganzzahlen, Gleitkommazahlen, Zeichen und Arrays. Das Video erklärt außerdem, wie der in einer Variablen gespeicherte Wert mithilfe einer printf-Anweisung und eines Formatbezeichners angezeigt wird.
- 00:25:00 In diesem Abschnitt des Videos erklärt der Kursleiter, wie man Formatspezifizierer verwendet, um verschiedene Datentypen in der C-Programmierung anzuzeigen. Um beispielsweise ein Zeichenarray anzuzeigen, verwenden Sie als Zeichenfolge das Prozentzeichen gefolgt von einem „s“. Um eine Zeichenvariable anzuzeigen, verwenden Sie Prozent c, und um eine Gleitkommazahl anzuzeigen, verwenden Sie Prozent f. Der Kursleiter bespricht auch Datentypen wie Zeichen, Gleitkommazahlen, Ganzzahlen und Doppelzahlen, wobei Doppelzahlen eine Genauigkeit von 64 Bit haben und höherwertige Ziffern behalten als Gleitkommazahlen. Es werden auch boolesche Werte eingeführt, die „wahr“ oder „falsch“ speichern und ein Byte Speicher belegen. Im nächsten Video werden verschiedene Formatspezifizierer und Möglichkeiten zu deren Anpassung erläutert.
- 00:30:00 Wir erfahren, dass Boolesche Werte mit Prozent d angezeigt werden können, wobei sich eins auf wahr und null auf falsch bezieht. Zeichen können Ganzzahlen im Bereich von minus 128 bis plus 127 speichern, wobei ihre Darstellungen mithilfe der Formatspezifizierer „Prozent d“ oder „Prozent c“ angezeigt werden. Vorzeichenlose Variablen verdoppeln unseren Bereich positiver Zahlen sowohl für Zeichen als auch für Shorts, sodass char Zahlen zwischen 0 und 255 speichern kann, während Shorts Ziffern von minus 32.768 bis plus 32.767 speichern können, wenn sie mit Vorzeichen versehen sind, und von 0 bis 65.535, wenn sie ohne Vorzeichen sind. Wir erfahren, dass Sie short anstelle von short int als Abkürzung verwenden können. Ganzzahlen können ganze Zahlen speichern, die entweder positive oder negative Werte sein können.
- 00:35:00 Es ist wichtig zu beachten, dass es unterschiedliche Formatbezeichner für verschiedene Datentypen gibt und die Verwendung des falschen Formatbezeichners zu Fehlern oder unerwarteter Ausgabe führen kann. Obwohl in der C-Programmierung viele Datentypen verfügbar sind, konzentrieren wir uns in diesem Kurs hauptsächlich auf Zeichen, Zeichenarrays, Doppelwerte, Boolesche Werte und Ganzzahlen.
- 00:40:00 Der Kursleiter erklärt Formatbezeichner, die Datentypen definieren und formatieren, die auf eine bestimmte Weise angezeigt werden sollen. Um eine Mindestfeldbreite für die Anzeige der Ausgabe festzulegen, wird nach dem Prozentzeichen eine Zahl hinzugefügt, um bestimmte Leerzeichen zuzuweisen. Durch die Verwendung eines negativen Vorzeichens nach dem linken Prozentzeichen werden die Daten ausgerichtet. Das Video behandelt auch Konstanten, bei denen es sich um feste Werte handelt, die vom Programm während seiner Ausführung nicht geändert werden können. Um eine Variable in eine Konstante umzuwandeln, wird dem Datentyp das Schlüsselwort „const“ vorangestellt und bei der Benennung der Konstante wird die Großbuchstabenkonvention befolgt. Arithmetische Operatoren wie Addition, Subtraktion, Multiplikation und Division werden ebenfalls behandelt, wobei bei der Division mit ganzen Zahlen Dezimalteile abgeschnitten werden können, was die Verwendung von Float oder Double zum Speichern des Ergebnisses erfordert, und der Modulus-Operator wird verwendet, um den Rest einer Division zu erhalten.
- 00:45:00 Der Dozent erklärt arithmetische Operatoren in der C-Programmierung, einschließlich des Moduls, mit dem man schnell bestimmen kann, ob eine Zahl gerade oder ungerade ist, indem man den Rest bei Division durch 2 ermittelt. Das Video behandelt auch Inkrement- und Dekrementoperatoren können verwendet werden, um eine Variable um 1 zu erhöhen oder zu verringern, und erweiterte Zuweisungsoperatoren, die es Benutzern ermöglichen, eine arithmetische Operation an einer Variablen durchzuführen und das Ergebnis mithilfe einer Verknüpfung wieder derselben Variablen zuzuweisen. Abschließend gibt der Kursleiter einen Überblick über die Annahme von Benutzereingaben mit der Scanf-Funktion und Eingabeaufforderungen in der C-Programmierung.
- 00:50:00 Der Kursleiter erklärt, wie Benutzereingaben in der C-Programmierung mithilfe der Scanf-Funktion mit dem entsprechenden Formatbezeichner für den verwendeten Variablentyp akzeptiert werden. Der Abschnitt behandelt das Akzeptieren von Ganzzahlen und Strings, mit der Einschränkung, dass das Akzeptieren von Strings mit Leerzeichen aufgrund von Leerzeichen die Funktion fgets anstelle von scanf erfordert. Der Kursleiter erklärt außerdem, wie die Zeichenfolge nach der Verwendung von fgets formatiert wird, um neue Zeilenzeichen zu entfernen. Der Abschnitt endet mit einem Überblick über die Formatierung von printf-Anweisungen zur Verbesserung der Lesbarkeit.
- 00:55:00 In diesem Abschnitt des Videos erläutert der Kursleiter nützliche mathematische Funktionen in C beim Einbinden der Mathe-Header-Datei. Quadratwurzel-, Potenz-, Rundungs- (mit Decken- und Boden-), Absolutwert-, Logarithmen- und Trigonometriefunktionen werden anhand von Beispielen für deren Verwendung im Code erläutert. Später demonstriert der Kursleiter, wie man ein Programm schreibt, das den Umfang eines Kreises basierend auf Benutzereingaben für den Radius berechnet, und geht dann noch weiter, um die Fläche des Kreises zu berechnen und anzuzeigen, indem man Pi mal die Formel zum Quadrat des Radius verwendet.
Teil 2
- 01:00:00 In diesem Abschnitt des Videos zeigt der Kursleiter, wie man den Umfang und die Fläche eines Kreises mit der Programmiersprache C berechnet und wie man die Hypotenuse eines rechtwinkligen Dreiecks findet, was die Verwendung der Quadratwurzelfunktion erfordert aus der Header-Datei math.h. Der Kursleiter führt außerdem in if-Anweisungen ein und erklärt, wie sie verwendet werden, um einem Programm Auswahlmöglichkeiten hinzuzufügen, indem Bedingungen überprüft und Code entsprechend ausgeführt wird. Er demonstriert, wie man die Größer-als-gleich-Bedingung und den Vergleichsoperator für doppelte Gleichheitszeichen verwendet und wie man else-Anweisungen verwendet, um eine andere Ausgabe bereitzustellen, wenn eine Bedingung falsch ist.
- 01:05:00 Das Video behandelt if-Anweisungen und else if-Anweisungen in der C-Programmierung. Mit diesen Anweisungen kann das Programm prüfen, ob eine Bedingung wahr ist, und ggf. eine bestimmte Teilmenge des Codes ausführen. Ist dies nicht der Fall, geht das Programm zum nächsten Block über, um eine andere Bedingung zu prüfen. Wenn alle Bedingungen als falsch ausgewertet werden, führt das Programm den Code aus, der sich im else-Block befindet. Darüber hinaus stellt das Video die Verwendung einer Switch-Anweisung als effizientere Alternative zur Verwendung mehrerer else if-Anweisungen vor. Mit der switch-Anweisung kann ein Wert mithilfe des Schlüsselworts case in vielen Fällen auf Gleichheit getestet werden. Abschließend wird im Video betont, wie wichtig es ist, nach jedem Fall in einer Switch-Anweisung eine Break-Anweisung einzufügen, um den Schalter zu verlassen, sobald ein passender Fall gefunden wurde.
- 01:10:00 In diesem Abschnitt des Videos zeigt der Kursleiter, wie man ein Programm erstellt, das die Temperatur von Celsius in Fahrenheit oder umgekehrt umrechnet. Das Programm akzeptiert Benutzereingaben für die Maßeinheit (Celsius oder Fahrenheit) und die aktuelle Temperatur und verwendet dann if/else-Anweisungen und die entsprechenden Formeln, um die Konvertierung durchzuführen. Der Kursleiter zeigt außerdem, wie man mit der Funktion to_upper die Groß-/Kleinschreibung beachtet und wie man mit scanf Gleitkommazahlen akzeptiert. Das Programm fordert den Benutzer zur Eingabe auf und zeigt die umgerechnete Temperatur an.
- 01:15:00 In diesem Abschnitt des Kurses zeigt der Kursleiter, wie man ein Programm in C erstellt, das Temperatureinheiten (Celsius in Fahrenheit und umgekehrt) basierend auf Benutzereingaben umrechnet. Das Programm fordert den Benutzer auf, die Temperatur und die Maßeinheit einzugeben, akzeptiert die Eingabe mit scanf und verwendet dann eine Reihe von bedingten Anweisungen, um die Temperatureinheiten nach Bedarf umzurechnen. Der Kursleiter erklärt die Verwendung von Formatspezifizierern, die Umrechnungsformel von Celsius in Fahrenheit und die Switch-Anweisung zur Verarbeitung verschiedener Arten von Vorgängen im Programmablauf. Das endgültige Programm wird im Kommentarbereich zum Herunterladen und Überprüfen veröffentlicht.
- 01:20:00 In diesem Abschnitt des Videos zeigt der Kursleiter, wie man ein einfaches Taschenrechnerprogramm in C erstellt, das Addition, Subtraktion, Multiplikation und Division durchführen kann. Das Programm verwendet eine Switch-Anweisung, um anhand der Benutzereingaben zu bestimmen, welcher Vorgang ausgeführt werden soll. Darüber hinaus wird die Verwendung logischer Operatoren erklärt, insbesondere des „und“-Operators, der prüft, ob eine Reihe von Bedingungen wahr sind. Der Kursleiter stellt Beispiele dafür vor, wie man mit logischen Operatoren prüft, ob eine Temperatur in einen bestimmten Bereich fällt, und wie man boolesche Variablen in die Bedingungsprüfungen einbezieht.
- 01:25:00 Der logische Operator „Oder“ und der nicht-logische Operator werden besprochen. Der logische Operator or prüft, ob mindestens eine Bedingung wahr ist, während der nicht logische Operator den Zustand einer Bedingung umkehrt. Mit dem Operator „Oder“ können mehrere Bedingungen überprüft werden, indem weitere vertikale Balken hinzugefügt werden. Andererseits kann der Not-Operator mehr Optionen für die Art und Weise bieten, wie ein Programm geschrieben wird. Diese logischen Operatoren können dazu beitragen, komplexere Bedingungen zu erstellen und die Effizienz eines Programms zu verbessern.
- 01:30:00 Der Dozent lehrt die Verwendung von Funktionen in der C-Programmierung, um die Wiederholung desselben Codes zu vermeiden. Durch das Erstellen einer neuen Funktion kann Code einmal geschrieben und dann durch einfachen Aufruf der Funktion mehrmals wiederverwendet werden. Anschließend geht der Kursleiter auf die Diskussion von Argumenten und Parametern ein, anhand eines Beispiels für die Übergabe von Zeichenarrays und Ganzzahlen als Argumente an eine Funktion. Die Parameter müssen in der Funktionsdeklaration deklariert werden, um die Funktion über die ihr übergebenen Variablen zu informieren. Ohne einen passenden Parametersatz kann die Funktion nicht aufgerufen werden.
- 01:35:00 In diesem Abschnitt des Transkripts erklärt der Sprecher das Konzept der Return-Anweisung und wie sie einen Wert an die aufrufende Funktion zurückgeben kann. Sie demonstrieren ein Beispiel einer Funktion namens „Quadrat“, die ein Argument akzeptiert, dieses Argument quadriert und das Ergebnis dann an die aufrufende Funktion zurückgibt. Sie besprechen außerdem die Syntax des trinären Operators, einer Abkürzung zur Verwendung einer if-else-Anweisung beim Zuweisen oder Zurückgeben eines Werts, und zeigen ein Beispiel dafür, wie er zum Ermitteln des Maximums von zwei ganzen Zahlen verwendet werden kann. Der Redner betont auch die Wichtigkeit der Übereinstimmung des Datentyps bei der Verwendung des Schlüsselworts return innerhalb der Funktionsdeklaration.
- 01:40:00 Wir lernen den ternären Operator kennen, der als Abkürzung für die Verwendung einer if-else-Anweisung beim Zuweisen oder Zurückgeben eines Werts dient. Der Operator besteht aus einer Bedingung, gefolgt von einem Fragezeichen, einem Wert, der zurückgegeben werden soll, wenn die Bedingung wahr ist, einem Doppelpunkt und dem Wert, der zurückgegeben werden soll, wenn die Bedingung falsch ist. Wir diskutieren auch Funktionsprototypen, die sicherstellen, dass Aufrufe einer Funktion mit der richtigen Anzahl und Art von Argumenten erfolgen. Durch das Hinzufügen eines Funktionsprototyps vor der Hauptfunktion können wir unerwartetes Verhalten vermeiden und Fehler erhalten, wenn falsche Argumente verwendet werden.
- 01:45:00 In diesem Abschnitt des Videos erklärt der Dozent Funktionsprototypen in C und ihre Vorteile und stellt einige nützliche String-Funktionen vor, die bereits in C geschrieben sind, wie z. B. String-Länge, String-Vergleich, String-Lower, String Obermaterial und String-Katze. Der Dozent gibt Beispiele für die Funktionsweise jeder dieser Funktionen und demonstriert deren Ergebnisse. Die String-Vergleichsfunktion gibt Null zurück, wenn die beiden verglichenen Strings gleich sind, und andere Zahlen, wenn dies nicht der Fall ist. Der Kursleiter beendet den Abschnitt, indem er einen Codeausschnitt einfügt, der diese Zeichenfolgenfunktionen verwendet.
- 01:50:00 Der Kursleiter behandelt For-Schleifen, die einen Codeabschnitt eine begrenzte Anzahl von Malen wiederholen. Er liefert ein Beispiel für das Zählen von 1 bis 10 mithilfe einer for-Schleife und erklärt die drei Anweisungen, die für eine for-Schleife erforderlich sind: Deklaration eines Index, Definition einer Bedingung für die Wiederholungsdauer des Codes und eine Möglichkeit, den Index zu erhöhen oder zu dekrementieren. Er demonstriert auch verschiedene Möglichkeiten, den Index zu erhöhen und zu verringern. Anschließend erklärt der Kursleiter While-Schleifen, die einen Codeabschnitt möglicherweise unbegrenzt oft wiederholen, solange eine bestimmte Bedingung erfüllt bleibt, und gibt ein Beispiel dafür, wie Benutzer zur Eingabe ihres Namens aufgefordert werden, bis der Benutzer eine gültige Antwort eingibt.
- 01:55:00 In diesem Abschnitt des Videos zeigt der Kursleiter, wie man fgets anstelle von scanf für Benutzereingaben in der C-Programmierung verwendet. Anschließend verwenden sie eine While-Schleife, um den Benutzer zur Eingabe seines Namens aufzufordern und ihn anzuschreien, wenn er seinen Namen nicht richtig eingegeben hat. Anschließend bespricht der Kursleiter die Do-While-Schleife und demonstriert ein Programm, das den Benutzer auffordert, so viele Zahlen einzugeben, wie er möchte, sofern diese größer als Null sind, und die Summe dieser Zahlen berechnet.
Teil 3
- 02:00:00 In diesem Abschnitt des vollständigen C-Programmierkurses erklärt der Kursleiter den Unterschied zwischen einer While-Schleife und einer Do-While-Schleife in C. Eine While-Schleife prüft zuerst die Bedingung und führt dann den Code aus, wenn die Bedingung erfüllt ist true, eine do-while-Schleife führt den Code einmal aus und überprüft dann die Bedingung, um zu sehen, ob sie wahr ist, bevor sie fortfährt. Der Dozent demonstriert dies anhand eines Beispielcodes und erklärt, wie man eine While-Schleife in eine Do-While-Schleife umwandelt. Der Abschnitt behandelt auch verschachtelte Schleifen, also eine Schleife innerhalb einer anderen Schleife, und demonstriert ein Beispiel für die Verwendung verschachtelter Schleifen zum Drucken eines Rechtecks mit Symbolen basierend auf Benutzereingabewerten für Zeilen, Spalten und Symbole.
- 02:05:00 In diesem Abschnitt des Videos zeigt der Kursleiter, wie man mithilfe verschachtelter Schleifen in C Rechteckformen erstellt. Er erlaubt dem Benutzer, ein Symbol und die Anzahl der Zeilen und Spalten für das Rechteck einzugeben, zeigt aber auch, wie um den Eingabepuffer zu löschen, um eine korrekte Benutzereingabe zu ermöglichen. Der Dozent erklärt außerdem den Unterschied zwischen den Anweisungen continue und break im Kontext von C-Schleifen, wobei continue den Rest eines Codeabschnitts überspringt und die nächste Iteration einer Schleife erzwingt, während break eine Schleife vollständig verlässt. Abschließend definiert der Kursleiter das Konzept von Arrays als Datenstruktur, die viele Werte desselben Datentyps speichern kann, und zeigt, wie eine Variable in ein Array umgewandelt wird.
- 02:10:00 Das Video behandelt das Konzept von Arrays in der Programmiersprache C. Arrays sind eine Möglichkeit, mehrere Werte desselben Datentyps in einer Datenstruktur fester Größe zu speichern. Das Video zeigt, wie man ein Array initialisiert und mithilfe von Indexnummern auf bestimmte Elemente zugreift. Es gibt verschiedene Möglichkeiten, ein Array zu initialisieren, z. B. die sofortige Zuweisung von Werten oder die spätere Zuweisung von Werten im Programm. Das Video erklärt außerdem, wie man mithilfe einer for-Schleife alle Elemente eines Arrays durchläuft und ausgibt.
- 02:15:00 Das Video zeigt, wie man die Elemente eines Arrays in der C-Programmierung durchläuft und anzeigt. Der Kursleiter demonstriert die Verwendung einer for-Schleife und einer printf-Anweisung, wobei der Index der for-Schleife für den Zugriff auf die Elemente des Arrays verwendet wird. Sie zeigen auch, wie man mithilfe der Größe des Operators berechnet, wie oft die Schleife iterieren sollte. Dieser Operator aktualisiert sich automatisch, wenn Elemente zum Array hinzugefügt oder daraus entfernt werden. Anschließend erstellt der Kursleiter ein zweidimensionales Array, bei dem jedes Element selbst ein Array ist. Sie demonstrieren am Beispiel eines einfachen Rasters oder einer Datentabelle, wie ein zweidimensionales Array initialisiert und organisiert wird.
- 02:20:00 Der Kursleiter erklärt, wie man in der C-Programmierung einem zweidimensionalen Array Werte deklariert und ihm Werte zuweist. Sie erklären außerdem, wie die Elemente eines zweidimensionalen Arrays mithilfe verschachtelter Schleifen und des Formatbezeichners „d“ angezeigt werden. Der Kursleiter zeigt dann, wie man die Anzahl der Zeilen und Spalten eines zweidimensionalen Arrays berechnet, indem man die Größe des Operators und die Größe einer der Zeilen sowie die Größe eines der in der ersten Zeile gefundenen Elemente verwendet. Der Abschnitt endet mit einem Beispiel, wie der Code mit einer neuen Zeile getestet wird, die dem 2D-Array hinzugefügt wird.
- 02:25:00 In diesem Abschnitt des Videos erklärt der Kursleiter, wie man in C ein zweidimensionales Array erstellt, bei dem es sich um ein Array von Arrays handelt, bei dem jedes Element ein ganzes Array ist. Für den Zugriff auf eines der Elemente werden zwei Indizes verwendet – einer für die Zeile und einer für die Spalte. Der Kursleiter zeigt auch, wie man ein Array aus Strings erstellt, bei dem es sich um ein 2D-Array aus einzelnen Zeichen handelt, mit der Ausnahme, dass jedes Element ein String ist. Um ein Array von Strings anzuzeigen, kann eine for-Schleife verwendet werden. Abschließend erklärt der Dozent, wie Variablen in C ausgetauscht werden können, indem eine dritte Variable als temporärer Speicher für den Wert eingeführt wird. Der Austausch von Variablen ist in Sortieralgorithmen wichtig, was im nächsten Thema behandelt wird.
- 02:30:00 Der Dozent lehrt, wie man die Werte zweier Variablen in C austauscht, sowohl für Ganzzahl- als auch für Zeichenarrays. Mithilfe temporärer Variablen und der Funktion zum Kopieren von Zeichenfolgen zeigt der Kursleiter, wie Werte ausgetauscht und unerwartetes Verhalten bei Zeichenarrays vermieden werden, wenn die Länge des zweiten Arguments kürzer als die des ersten ist. Der Dozent schlägt außerdem vor, sich Variablen als Gläser mit Flüssigkeit vorzustellen, um das Vertauschen von Werten besser zu verstehen, und stellt im Kommentarbereich Beispielcode bereit. Anschließend erklärt der Dozent, wie man ein Programm schreibt, um Elemente innerhalb eines Arrays zu sortieren, zuerst mit einem Array aus Ganzzahlen und dann mit einem Array aus Zeichen. Der Kursleiter deklariert eine separate Funktion zum Sortieren und verwendet verschachtelte for-Schleifen, um das Array zu durchlaufen und Werte zum Sortieren zu vergleichen.
- 02:35:00 Der Referent erläutert, wie Elemente eines Arrays in C mithilfe des Bubble-Sort-Algorithmus sortiert werden. Sie erklären die Verwendung temporärer Variablen und if-Anweisungen und wie sich die Größe der zu sortierenden Zahl auf ihre endgültige Position im Array auswirkt. Der Referent demonstriert außerdem, wie man eine Reihe von Zeichen sortiert, indem man den Datentyp und die Druckfunktion ändert. Anschließend stellen sie das Konzept von Strukturen vor, um verwandte Elemente in einem Speicherblock zu organisieren und reale Objekte nachzuahmen. Eine Struktur wird mit dem Schlüsselwort struct definiert, gefolgt von einem Tag-Namen und einer Reihe geschweifter Klammern zur Darstellung ihrer Mitglieder.
- 02:40:00 In diesem Abschnitt des Videos unterrichtet der Kursleiter Strukturen und Typdefinitionen in der Programmiersprache C. Mithilfe von Strukturen kann ein Programmierer verwandte Werte unter einem Namen in einem Speicherblock gruppieren und diese dazu verwenden, Mitgliedern mit unterschiedlichen Datentypen Werte zuzuweisen. Das Schlüsselwort typedef gibt einem vorhandenen Datentyp einen Spitznamen, der die Verwendung des Datentyps im Code erleichtert. Der Kursleiter zeigt außerdem ein Beispiel für die Erstellung einer Struktur mit drei Mitgliedern und die Zuweisung von Werten zu diesen. Das Video stellt einen Beispielcode für Benutzer bereit, die ihn verwenden möchten.
- 02:45:00 Die Struktur wird außerhalb der Hauptfunktion erstellt und erhält einen Tag-Namen, „student“, und enthält ein Zeichenarray für den Namen und eine Float-Variable für den GPA. Ein Array von vier Studenten wird initialisiert und dann in einem Array namens „Studenten“ platziert. Mithilfe einer for-Schleife durchläuft das Programm das Array und gibt den Namen und die Notendurchschnittsnote jedes Schülers aus, indem es den Member-Zugriffsoperator „dot“ verwendet. Abschließend erklärt das Video, dass wir, wenn wir das Schlüsselwort „typedef“ mit einer Struktur verwenden, nicht mehr das Schlüsselwort struct zum Erstellen der Struktur verwenden müssen und stattdessen den Spitznamen verwenden können, den wir ihr zugewiesen haben.
- 02:50:00 Der Dozent lehrt das Erstellen von Arrays aus Strukturen in C, wobei jedes Element im Array eine Struktur ist, die Daten für jeden Schüler enthält, wie z. B. Name und Notendurchschnitt. Der Kursleiter geht auch auf die Verwendung von Enumerationen ein, bei denen es sich um benutzerdefinierte Typen von benannten Ganzzahlbezeichnern handelt, die ein Programm lesbarer machen können, indem Ganzzahlwerte durch zugehörige Namen ersetzt werden, wodurch der Code für den Programmierer und jeden, der den Code überprüft, leichter verständlich wird. Die Struktur von Aufzählungen wird erläutert, und der Kursleiter zeigt, wie Aufzählungen in if-else-Anweisungen verwendet werden, um basierend auf dem Wert einer Aufzählungsvariablen unterschiedliche Ausgaben zu drucken.
- 02:55:00 In diesem Abschnitt des Videos zeigt der Kursleiter, wie man Zufallszahlen in der C-Programmierung generiert. Die aktuelle Zeit wird verwendet, um einen Startwert für die Rand-Funktion zu generieren, der eine Zufallszahl zwischen 0 und 32767 generiert. Um eine Zufallszahl innerhalb eines bestimmten Bereichs zu erhalten, kann der Moduloperator verwendet werden. Der Kursleiter gibt ein Beispiel für die Generierung einer Zufallszahl zwischen 1 und 6 (für das Würfeln) und für das Würfeln von drei Würfeln. Außerdem wird ein Zahlen-Ratespiel vorgestellt, bei dem das Wissen über die Generierung von Zufallszahlen zum Einsatz kommt. Es werden Konstanten für den minimalen und maximalen Bereich festgelegt und der Benutzer wird aufgefordert, die Zahl zu erraten. Das Programm verwendet die Rand-Funktion, um eine Zufallszahl innerhalb des angegebenen Bereichs zu generieren, und der Benutzer erhält Feedback, um seine Schätzung anzupassen, bis die richtige Zahl eingegeben wird.
Teil 4
- 03:00:00 Der Dozent zeigt, wie man in C ein Zahlen-Schätzspiel erstellt, bei dem das Programm eine Zufallszahl zwischen zwei angegebenen Werten generiert, den Benutzer zum Erraten der Zahl auffordert und eine Rückmeldung gibt, wenn die Schätzung zu hoch oder zu niedrig ist , oder richtig. Das Programm verwendet eine Do-While-Schleife, um sicherzustellen, dass mindestens eine Vermutung durchgeführt wird, und zählt die Anzahl der Vermutungen des Benutzers. Der Kursleiter fügt außerdem einige Textdekorationen hinzu, um die Ausgabe optisch ansprechender zu gestalten. Dieses Beispiel demonstriert die Verwendung von Bedingungen, Schleifen, Benutzereingaben und der Generierung von Zufallszahlen in C.
- 03:05:00 Der Kursleiter zeigt, wie man ein Quizspiel in C erstellt. Das Spiel verwendet ein zweidimensionales Zeichenarray zum Speichern der Fragen und ein separates zweidimensionales Zeichenarray zum Speichern der Optionen. Die richtigen Antworten werden in einem eindimensionalen Zeichenarray gespeichert. Das Spiel berechnet die Anzahl der Fragen, die es hat, und verwendet eine for-Schleife, um sie eine nach der anderen durchzugehen und sie zusammen mit ihren möglichen Optionen anzuzeigen. Dazu verwendet der Kursleiter eine verschachtelte for-Schleife, die mit jeder vierten Zeichenfolge innerhalb des Optionsarrays beginnt. Diese for-Schleife durchläuft viermal und zeigt die vier möglichen Optionen für jede Frage an.
- 03:10:00 Der Kursleiter erklärt, wie man ein einfaches Quizspiel in C erstellt, das dem Benutzer Fragen stellt und seine Antworten überprüft. Der Code verwendet eine verschachtelte for-Schleife, um die Fragen und Optionen anzuzeigen, akzeptiert Benutzereingaben mit scanf und wandelt Kleinbuchstaben mithilfe der Funktion „toupper“ in Großbuchstaben um. Das Programm prüft dann, ob die Vermutung des Benutzers mit der richtigen Antwort übereinstimmt und erhöht die Punktzahl entsprechend. Sind alle Fragen beantwortet, zeigt das Programm das Endergebnis an. Der Dozent erklärt außerdem kurz die bitweisen Operatoren und demonstriert die Verwendung von fünf verschiedenen bitweisen Operatoren in C.
- 03:15:00 Wir lernen etwas über bitweise Operationen in der C-Programmierung. Wir beginnen mit dem UND-Operator, der bei Anwendung auf zwei Binärzahlen unserem Ergebnis nur dann eine Eins zuweist, wenn beide entsprechenden Bits Eins sind. Anschließend gehen wir zum ODER-Operator über, der unserem Ergebnis eine Eins zuweist, wenn eines der entsprechenden Bits Eins ist. Der Exklusiv-ODER-Operator weist dem Ergebnis eine Eins zu, wenn nur ein entsprechendes Bit eins ist. Wir lernen auch Links- und Rechtsverschiebungsoperatoren kennen, die Bits in einer Binärzahl nach links oder rechts verschieben. Das Verschieben der Bits nach links verdoppelt effektiv die Zahl, während das Verschieben nach rechts den gegenteiligen Effekt hat.
- 03:20:00 Das Video erklärt den Speicher in der C-Programmierung, bei dem es sich um ein Array von Bytes im RAM handelt, wobei jede Einheit ein Speicherblock ist, der einen Wert speichern kann. Eine Speicheradresse zeigt an, wo sich ein Speicherblock im RAM befindet, und ähnelt einer Straßenadresse. Beim Deklarieren einer Variablen werden einige Speicherblöcke reserviert, um einen Wert zu speichern, der einer Speicheradresse zugeordnet ist. Jede Variable verwendet einen Speicherblock von einem Byte, und das Video zeigt als Beispiele die Speicheradressen und Größen verschiedener Zeichen. Das Video erklärt auch kurz Hexadezimalwerte, die Zahlen von 0 bis 9 und Buchstaben von a bis f verwenden, um 16 mögliche Werte für jede Ziffer zu erstellen. Abschließend behandelt das Video kurze Datentypen, die zwei Byte Speicher beanspruchen.
- 03:25:00 Der Dozent erklärt die Grundlagen des Speichers in der C-Programmierung, einschließlich der Frage, wie Variablen Speicherblöcke verbrauchen und wie Arrays je nach Größe und Datentyp mehrere Speicherblöcke verbrauchen. Er stellt außerdem das Konzept von Zeigern vor, die eine Speicheradresse als Wert für eine andere Variable speichern, und erklärt, wie sie zur einfacheren Ausführung bestimmter Aufgaben verwendet werden können. Der Kursleiter zeigt, wie der Wert und die Adresse einer Variablen angezeigt werden und wie ein Zeiger desselben Datentyps wie die Variable erstellt wird, auf die er zeigt.
- 03:30:00 Wir lernen etwas über Zeiger in der C-Programmierung. Zeiger werden mit einem Sternchen als Indirektionsoperator deklariert und eine übliche Namenskonvention besteht darin, ein kleines „p“ zu verwenden, gefolgt vom Variablennamen, wobei der erste Buchstabe groß geschrieben wird. Der Wert eines Zeigers ist eine Adresse, und wir können mithilfe des Indirektionsoperators auf den an dieser Adresse gespeicherten Wert zugreifen. Es ist wichtig sicherzustellen, dass die Datentypen des Zeigers und der Variablen, auf die er zeigt, konsistent sind. Zeiger können auch als Argumente an Funktionen übergeben werden, sodass die Funktion auf den in der Variablen, auf die verwiesen wird, gespeicherten Wert zugreifen und ihn ändern kann. Darüber hinaus können Zeiger in zwei Schritten deklariert und initialisiert werden, es empfiehlt sich jedoch, sofort einen Wert zuzuweisen.
- 03:35:00 Der Dozent erklärt Hinweise zur C-Programmierung. Ein Zeiger ist eine Variable, die eine Speicheradresse für eine andere Variable, ein Array usw. enthält. Um einen Zeiger zu deklarieren, verwenden Sie den Indirektionsoperator. Um einem Zeiger einen Wert zuzuweisen, verwenden Sie denselben Operator. Der Kursleiter zeigt, wie man in C mithilfe von Zeigern, fopen, fwrite und fclose in eine Datei schreibt. Um in eine Datei zu schreiben, müssen Sie einen Zeiger auf eine Datei erstellen und „fprintf“ verwenden, um in die Datei zu schreiben. Der Kursleiter demonstriert auch die Datei-E/A, indem er eine Datei löscht und in eine Datei an einem bestimmten Speicherort im Verzeichnis eines Computers schreibt.
- 03:40:00 Der Dozent zeigt, wie man den Inhalt einer Datei in der C-Programmierung liest, indem man einen Zeiger mit dem Datentyp „file“ erstellt und die Datei mit der Funktion fopen öffnet. Der Kursleiter zeigt, wie man einen Puffer verwendet, um ein Array von Zeichen aufzunehmen, um jeweils eine Zeile des Textdokuments aufzunehmen, und wie man mit der Funktion fgets eine einzelne Zeile aus der Datei liest. In diesem Abschnitt erfahren Sie außerdem, wie Sie mithilfe einer While-Schleife alle Zeilen einer Datei anzeigen und eine Dateierkennung hinzufügen, um zu prüfen, ob die Datei vorhanden ist, bevor Sie versuchen, sie zu lesen.
- 03:45:00 In diesem Abschnitt des Videos geht der Kursleiter auf die Funktionsprototypen ein, die im Programm verwendet werden, einschließlich der Funktionen zum Zurücksetzen des Spielbretts, zum Drucken des Spielbretts, zum Überprüfen freier Felder, zum Spielerzug, zum Computerzug und zum Überprüfen des Gewinners , und Drucksieger. Nach der Deklaration dieser Funktionen bespricht der Kursleiter einige zu verwendende globale Variablen, darunter ein 2D-Array von Charakteren mit dem Namen „board“ sowie Konstanten für die Spieler- und Computercharaktere. Als nächstes wird die Hauptfunktion besprochen, bei der sie eine lokale Variable für den Gewinner deklariert, sie auf einen leeren Raum setzt, die Tafel zurücksetzt und sie ausgibt. Das Video enthält außerdem Details zu verschachtelten for-Schleifen, die in der Reset-Board-Funktion verwendet werden, und einer printf-Anweisung, die im Print-Board verwendet wird.
- 03:50:00 In diesem Abschnitt des vollständigen C-Programmierkurses erklärt der Kursleiter, wie man eine While-Schleife in der Hauptfunktion erstellt, die die Leiterplattenfunktion umgibt. Die While-Schleifenbedingung besagt, dass die Schleife fortgesetzt wird, wenn der Gewinner ein Leerzeichen ist und der vom Aufruf der Funktion „Freie Stellen prüfen“ zurückgegebene Wert nicht Null ist. Die Funktion „Freie Leerzeichen prüfen“ wird ebenfalls mithilfe von zwei verschachtelten for-Schleifen erstellt, um das 2D-Array von Zeichen zu durchlaufen und die lokale Variable für freie Leerzeichen zu dekrementieren, wenn eine Stelle belegt ist. Es wird die Funktion „Spieler bewegen“ erklärt, die den Benutzer auffordert, Zeilen- und Spaltennummern einzugeben, um einen Zug auszuführen, und prüft, ob der Platz besetzt ist oder nicht. Die Funktion „Gewinner prüfen“ wird außerdem erstellt, um jede Zeile auf eine Gewinnbedingung und jede Spalte auf eine Gewinnbedingung zu überprüfen.
- 03:55:00 Der Kursleiter geht den Code zum Überprüfen der Zeilen, Spalten und Diagonalen durch, um einen Gewinner in einem Tic Tac Toe-Spiel zu ermitteln. Sie erklären die Verwendung von for-Schleifen und if-Anweisungen, um die Elemente auf dem Spielbrett zu durchlaufen und auf Übereinstimmungen zu prüfen. Wenn es einen Gewinner gibt, gibt die Funktion den Zeichenwert des Gewinnerelements zurück. Wenn nicht, wird ein Leerzeichen zurückgegeben. Der Ausbilder stellt dann den Code für die Bewegung des Computers bereit, bei dem zufällige Koordinaten generiert werden, um sein Symbol auf der Tafel zu platzieren. Bevor Zufallszahlen generiert werden, prüft das Programm, ob noch freie Plätze auf der Tafel vorhanden sind.
- 04:00:00 Der Ausbilder baut das Tic Tac Toe-Spiel in C weiter auf. Er fügt eine Prüfung hinzu, um sicherzustellen, dass die generierte Stelle ein leeres Feld ist, bevor er einen Zug platziert. Sind keine Felder mehr verfügbar, wird die Funktion „Gewinner drucken“ mit einem leeren Feld aufgerufen, das Spiel endet also unentschieden. Sie erklären, dass diese Funktion ziemlich einfach ist, da sie „Sie gewinnen“ ausgibt, wenn der Gewinner der Spieler ist, „Sie verlieren“, wenn der Gewinner der Computer ist, und „Es ist ein Unentschieden“, wenn es keinen Gewinner gibt. Der Kursleiter implementiert mithilfe einer Do-While-Schleife eine Option zum erneuten Abspielen und setzt die Gewinner- und Antwortvariablen zu Beginn jeder Schleife zurück. Das Spiel wird mehrmals ausgeführt und getestet, wobei der Lehrer jeden Schritt erklärt. Abschließend erwähnen sie, dass der Code im Kommentarbereich veröffentlicht wird, damit Benutzer ihn verwenden können.
Grundlegende Konzepte der objektorientierten Programmierung
Grundlegende Konzepte der objektorientierten Programmierung
Die vier Grundkonzepte der objektorientierten Programmierung sind Abstraktion, Kapselung, Vererbung und Polymorphismus. Bevor wir uns mit ihrer Bedeutung befassen, ist es wichtig zu verstehen, was ein Objekt ist. Ein Objekt stellt etwas aus der realen Welt dar, das physisch sein kann, wie ein Auto oder ein Buch, oder nicht-physisch, wie ein Zahnarzttermin oder ein Bankkonto.
Im Kontext der objektorientierten Programmierung bezieht sich ein Objekt auf alles, was für die zu entwickelnde Softwareanwendung von Interesse ist und wo Daten gespeichert und verarbeitet werden müssen. Objekte werden auch als Entitäten bezeichnet.
Abstraktion ist das erste Grundkonzept, bei dem es darum geht, die Realität zu vereinfachen, indem man sich nur auf die relevanten Daten und Aufgaben im Zusammenhang mit einem Objekt konzentriert. Bei der Gestaltung einer Anwendung zur Verarbeitung von Daten über eine Person werden beispielsweise nur die notwendigen Daten und Vorgänge berücksichtigt.
Um Objekte programmgesteuert zu erstellen, ist eine Klasse erforderlich. Eine Klasse dient als Vorlage zum Erstellen von Objekten und wird von einem Programmierer geschrieben, um die Attribute (auch als Felder oder Eigenschaften bezeichnet) und Operationen (auch als Verhalten oder Methoden bezeichnet) eines Objekts zu definieren. Attribute beschreiben die Daten des Objekts, während Operationen die Aktionen darstellen, die vom Objekt ausgeführt werden können.
Kapselung ist das zweite Grundkonzept und beinhaltet das Verbergen der Komplexität des Innenlebens eines Objekts vor anderen Programmen und Programmierern. Es wird oft als Information Hiding bezeichnet, da die Daten und Funktionen innerhalb eines Objekts miteinander verbunden und vor externen Eingriffen geschützt sind. Erfahrene Programmierer erstellen häufig Klassen, die von Nachwuchsprogrammierern verwendet werden, und kompilierte Klassenbibliotheken schützen geistiges Eigentum.
Vererbung ist das dritte grundlegende Konzept, das es einer Klasse ermöglicht, ihre Methoden und Eigenschaften von einer anderen Klasse abzuleiten. Dies führt zu einer Klassenhierarchie, in der Unterklassen von einer Oberklasse erben. Beispielsweise erbt eine Mitarbeiterklasse von einer Personenklasse, und eine Kundenklasse erbt ebenfalls von der Personenklasse. Dadurch entsteht eine Art Beziehung, wobei Unterklassen die Eigenschaften und Methoden ihrer Oberklasse erweitern.
Polymorphismus, das letzte grundlegende Konzept, ermöglicht es einer Klasse, geerbte Methoden auf ihre eigene Weise zu implementieren. Verschiedene Unterklassen derselben Oberklasse können unterschiedliche Implementierungen für die geerbten Methoden haben. Polymorphismus ermöglicht es, dass sich verschiedene Formen von Objekten mit derselben Schnittstelle je nach ihrer spezifischen Unterklassenimplementierung unterschiedlich verhalten.
Zusammenfassend lässt sich sagen, dass Abstraktion die Realität vereinfacht, Kapselung Komplexität verbirgt, Vererbung Klassenhierarchien etabliert und Polymorphismus vielfältige Implementierungen geerbter Methoden ermöglicht. Diese grundlegenden Konzepte bilden die Grundlage der objektorientierten Programmierung.
Kurs „Objektorientierte Programmierung (OOP) in C++“.
Kurs „Objektorientierte Programmierung (OOP) in C++“.
Dieses Video bietet einen Überblick über die objektorientierte Programmierung (OOP) in C++. Es erklärt die grundlegenden Konzepte von OOP, wie Klassen, Objekte und Methoden. Der Kursleiter demonstriert die Erstellung einer C++-Klasse und ihrer Mitglieder und betont dabei die Bedeutung der Deklaration von Variablen als benutzerdefinierte Datentypen. Zugriffsmodifikatoren wie „private“, „public“ und „protected“ werden in Bezug auf den Zugriff auf Objektmitglieder erläutert.
Das Video behandelt auch die Implementierung von OOP-Prinzipien, einschließlich Kapselung, Abstraktion, Vererbung und Polymorphismus. Es zeigt Beispiele dafür, wie diese Prinzipien im Code angewendet werden, beispielsweise das Erstellen von Konstruktoren und abstrakten Klassen. Der Dozent hebt die Vorteile von OOP hervor, wie z. B. die Vereinfachung der Softwareentwicklung und das Verbergen der Komplexität vor Benutzern.
Darüber hinaus untersucht das Video das Konzept der Vererbung, bei dem eine abgeleitete Klasse Eigenschaften von einer Basisklasse erbt. Der Kursleiter demonstriert den Prozess der Erstellung abgeleiteter Klassen und erklärt, wie diese zusätzlich zu den geerbten über eigene einzigartige Eigenschaften verfügen können.
Das Video endet mit Diskussionen über virtuelle Funktionen und Polymorphismus. Es erklärt, wie Polymorphismus es Objekten und Methoden ermöglicht, mehrere Formen anzunehmen, sodass eine übergeordnete Klassenreferenz mit untergeordneten Klassenobjekten verwendet werden kann. Das Konzept virtueller Funktionen wird eingeführt, wobei betont wird, dass beim Aufruf die am stärksten abgeleitete Version einer Funktion ausgeführt wird.
Insgesamt soll dieses Video ein umfassendes Verständnis von OOP in C++ vermitteln und wesentliche Konzepte, Prinzipien und praktische Implementierungen abdecken. Die Dozentin ermutigt die Zuschauer, ihrem Kanal Code Beauty zu folgen, und freut sich über Feedback zu den Videos.
- 00:00:00 Dieses Video erklärt die Grundlagen der objektorientierten Programmierung und wie sie in der Praxis funktioniert. Klassen sind ein Schlüsselkonzept in der objektorientierten Programmierung und Variablen müssen als benutzerdefinierte Datentypen deklariert werden, um sie verwenden zu können.
- 00:05:00 In diesem Video wird eine C++-Klasse erstellt und Mitglieder hinzugefügt. Die Klasse verfügt über drei Attribute: Name, Firma und Alter. Eine Instanz der Klasse wird erstellt und ihr wird die Variablennummer zugewiesen.
- 00:10:00 In diesem Video erklärt der Kursleiter, wie man in C++ auf die Mitglieder eines Objekts zugreift. Zugriffsmodifikatoren wie „private“, „public“ und „protected“ bestimmen, wie auf Mitglieder eines Objekts zugegriffen werden kann. Mit einer Klassenmethode kann das Verhalten eines Objekts beschrieben werden.
- 00:15:00 Dieses Video erklärt, wie objektorientierte Programmierung (OOP) in C++ funktioniert. Eine Funktion wird mit dem Rückgabetyp void erstellt und die Funktion wird mit derselben Syntax wie die eingeführte Funktion aufgerufen. Die Funktion wird dann fünfmal aufgerufen, jedes Mal mit einem anderen Mitarbeiternamen und einer anderen Firma. Die Mitarbeiternamen und Unternehmenswerte werden dann in ein neues Mitarbeiterobjekt kopiert und die Attribute des Mitarbeiterobjekts werden auf die Werte der neu kopierten Werte gesetzt.
- 00:20:00 In diesem Video geht der Kursleiter durch die drei Regeln zum Erstellen von Konstruktoren in C++. Die erste Regel besagt, dass ein Konstruktor denselben Namen hat wie die Klasse, zu der er gehört, die zweite besagt, dass ein Konstruktor öffentlich sein muss, und die dritte besagt, dass auf einen Konstruktor zugegriffen werden muss. Beim Erstellen eines Konstruktors ist es wichtig, die in diesem Video beschriebenen Regeln zu beachten. Wenn ein Konstruktor eine dieser Regeln nicht befolgt, wird ein Fehler generiert.
- 00:25:00 In diesem Video erklärt der Dozent die Grundlagen der objektorientierten Programmierung, einschließlich der Konzepte von Klassen, Objekten und Methoden. Anschließend beschreibt er vier Schlüsselprinzipien der objektorientierten Programmierung: Kapselung, Abstraktion, Vererbung und Polymorphismus. Abschließend erklärt er anhand eines Codebeispiels, wie diese Konzepte umgesetzt werden.
- 00:30:00 Dieses Video stellt die objektorientierte Programmierung (OOP) in C++ vor. Eine Klasse ist eine Struktur, die Daten und öffentliche Methoden kapselt, die andere Klassen aufrufen können, um auf die Daten zuzugreifen und sie zu ändern. Zur Kapselung sind die Klassenfelder privat und die Getter und Setter öffentlich.
- 00:35:00 In diesem Video diskutiert ein C++-Kursleiter die Prinzipien der objektorientierten Programmierung (OOP). Der Dozent erläutert, wie Kapselung und Abstraktion dabei helfen, komplexe Daten hinter einer vereinfachten Schnittstelle zu verbergen. Der Dozent erläutert außerdem, wie Validierungsregeln auf die Setter-Methoden privater Eigenschaften angewendet werden können.
- 00:40:00 In diesem Video erklärt der Moderator, wie objektorientierte Programmierung (OOP) die Softwareentwicklung einfacher machen kann, indem sie die Komplexität vor Benutzern verbirgt. Am Beispiel eines Smartphones veranschaulichen sie, wie OOP einen komplexen Prozess einfach aussehen lassen kann. Anschließend zeigen sie, wie man einen Vertrag erstellt, der eine Seite eines Systems einfach erscheinen lässt und gleichzeitig die Komplexität des Systems vor dem Benutzer verbirgt.
- 00:45:00 Dieses Video erklärt das Konzept der objektorientierten Programmierung (OOP) in C++. In dem Video wird erläutert, wie eine abstrakte Klasse erstellt wird, die für eine virtuelle Funktion implementiert werden muss, und wie die Funktion getestet wird, um festzustellen, ob ein bestimmter Mitarbeiter befördert werden kann.
- 00:50:00 In diesem Video wird der Autor befördert. Wenn diese Person dann jünger als 30 ist, wird sie nicht befördert. Dadurch können wir einen Vertrag implementieren, der eigentlich eine abstrakte Klasse ist, und diese abstrakte Klasse oder dieser Vertrag hat nur eine Regel und diese Regel ist hier diese rein virtuelle Funktion, die „Um Beförderung bitten“ genannt wird. Also, welche Klasse auch immer diesen Vertrag unterzeichnet, welche Klasse auch immer von diesem abstrakten Mitarbeiter erbt, was hier diese Klasse ist, muss hier eine Implementierung für diese Methode bereitstellen. Wir haben es getestet und wie Sie sehen konnten, wurde ich nicht befördert und John bekam eine Beförderung. Das ist also die Idee der Abstraktion. Und bei dieser Methode zur Anfrage nach Werbung handelt es sich genau um die Schaltfläche, die wir zu Beginn dieses Kapitels als Schaltfläche auf Ihrem Smartphone erwähnt haben. Das dritte Prinzip der objektorientierten Programmierung, über das ich sprechen möchte, heißt Vererbung. Die Idee der Vererbung ist die folgende: Es gibt diese Basisklasse, die auch als Superklasse oder Elternklasse bekannt ist, und dann gibt es eine abgeleitete Klasse, die auch als Kinderklasse oder Unterklasse bekannt ist.
- 00:55:00 In diesem Video demonstriert ein C++-Kursleiter, wie objektorientierte Programmierung funktioniert, indem er eine abgeleitete Klasse aus einer vorhandenen Basisklasse erstellt. Die Eigenschaften der Basisklasse werden dann von der abgeleiteten Klasse geerbt, die auch ihre eigenen Eigenschaften erhält, die für die Entwicklerklasse spezifisch sind.
- 01:00:00 In diesem Video erläutert der Dozent, wie objektorientierte Programmierung in C++ funktioniert. Er erklärt, wie eine Entwicklerklasse von einer Mitarbeiterklasse erbt und wie der Konstruktor der Mitarbeiterklasse verwendet werden kann, um bestimmte Eigenschaften der Entwicklerklasse zu initialisieren. Anschließend zeigt der Dozent, wie in der Entwicklerklasse eine Methode erstellt werden kann, um zu testen, ob die Eigenschaften korrekt festgelegt wurden. Abschließend demonstriert er, wie man die Entwicklerklasse schließt.
- 01:05:00 In diesem Video bespricht der Dozent die Konzepte der objektorientierten Programmierung (OOP) von Vererbung und Polymorphismus. Anhand eines Codebeispiels demonstriert er, wie diese Konzepte zur Lösung eines Problems verwendet werden können. Abschließend zeigt der Kursleiter, wie man eine Klasse erstellt, die von einer anderen Klasse erbt.
- 01:10:00 Dieses Video bietet einen kurzen Überblick über die objektorientierte Programmierung (OOP) in C++. Das Video erklärt, wie man eine Lehrerklasse erstellt, die von einer Mitarbeiterklasse erbt und eine Funktion zur Unterrichtsvorbereitung implementiert. Das Video bespricht auch einige der Probleme, die beim Erstellen und Verwenden von OOP-Klassen auftreten können, und wie man sie löst.
- 01:15:00 In diesem Video erklärt der Dozent das Konzept der objektorientierten Programmierung (OOP) in C++. Polymorphismus bezieht sich auf die Fähigkeit eines Objekts oder einer Methode, viele Formen anzunehmen. Eine häufige Verwendung von Polymorphismus in der Programmierung besteht darin, dass eine Referenz auf eine übergeordnete Klasse verwendet wird, um auf ein Objekt einer untergeordneten Klasse zu verweisen. Dieses Beispiel zeigt, wie Polymorphismus funktioniert, indem zur Hauptfunktion zurückgekehrt wird und die neue Arbeitsmethode für die Entwickler- und Lehrerklassen aufgerufen wird, die beide von der Mitarbeiterklasse erben.
- 01:20:00 Dieses Video behandelt die Grundlagen der objektorientierten Programmierung in C++. Der erste Teil des Videos behandelt die Geschichte der objektorientierten Programmierung und wie sie sich von anderen Programmierparadigmen unterscheidet. Im zweiten Teil des Videos wird erklärt, wie man einen Zeiger auf eine Basisklasse erstellt und wie man eine Arbeitsmethode in einer Mitarbeiterklasse virtuell macht. Abschließend zeigt das Video, wie der Zeiger funktioniert und wie das Programm dadurch funktioniert.
- 01:25:00 In diesem Video diskutiert der Dozent das Konzept virtueller Funktionen und Polymorphismus in C++. Er erklärt, dass beim Aufruf einer virtuellen Funktion die am stärksten abgeleitete Version der Funktion ausgeführt wird. Dies bedeutet, dass, wenn eine Funktion nicht in den abgeleiteten Klassen einer Klasse implementiert ist, stattdessen die Entwicklerklasse der Klasse aufgerufen wird. Er stellt außerdem fest, dass mit Polymorphismus verschiedene Arten von Mitarbeitern so behandelt werden können, als wären sie ein großes Objekt, sodass sie mit einem Basisklassenzeiger referenziert werden können.
- 01:30:00 Dieses Video stellt die objektorientierte Programmierung (OOP) in C++ vor. Es wird erläutert, wie OOP die Programmierung organisierter und verständlicher macht. Die Moderatorin empfiehlt den Zuschauern außerdem, ihrem Kanal zu folgen, Beauty zu codieren und sich dort zu abonnieren. Abschließend ermutigt die Moderatorin die Zuschauer, Feedback zu ihren Videos zu hinterlassen.
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
In unserer technologisch fortschrittlichen Welt sind Programmierung und Informatik zu transformativen Disziplinen geworden, die Innovationen vorantreiben und die Gesellschaft prägen.
Programmieren als Kunstform kombiniert Kreativität, Logik und Problemlösung, um elegante und effiziente Lösungen zu schaffen.
Die Informatik dient als wissenschaftliche Grundlage für die Programmierung und umfasst Theorien, Algorithmen und Methoden für die Entwicklung und Implementierung von Computerprogrammen. Allerdings erfordert das Programmieren selbst Vorstellungskraft und Einfallsreichtum. Wie ein Künstler auf einer leeren Leinwand verwebt ein Programmierer Codezeilen zu komplexen Algorithmen und schafft so digitale Meisterwerke, die Branchen revolutionieren, Aufgaben vereinfachen und das Benutzererlebnis verbessern. Objektorientierte Programmierung (OOP) ist ein Schlüsselparadigma in der Informatik, das es Programmierern ermöglicht, Komplexität zu bewältigen, indem sie Code in wiederverwendbaren und modularen Objekten organisieren. Durch die Kapselung von Daten und Verhalten in Objekten können Programmierer auf kreative Weise Lösungen entwerfen, die einfacher zu verstehen, zu warten und zu erweitern sind.
Das Programmieren geht über das Lösen von Problemen hinaus und umfasst die Gestaltung benutzerfreundlicher Schnittstellen und ansprechender Benutzererlebnisse. Dieser Aspekt verbindet künstlerische Sensibilität mit technischem Wissen. Programmierer entwerfen Benutzeroberflächen (UI) und Benutzererlebnisse (UX) mithilfe von Ästhetik, intuitiver Navigation und auffälligen visuellen Elementen, um Software zu erstellen, die Benutzer begeistert und fesselt. Die Kunst liegt darin, Funktionalität und Ästhetik nahtlos zu verbinden und komplexe Merkmale in intuitive und optisch ansprechende Designs zu übersetzen. Mit OOP können Programmierer Aufgaben trennen und separate Objekte erstellen, die für verschiedene Aspekte der Software verantwortlich sind. Dieser modulare Ansatz fördert die Kreativität im Design, indem er es Programmierern ermöglicht, sich auf einzelne Objekte, ihre Interaktionen und das Gesamtverhalten des Systems zu konzentrieren. Mithilfe von OOP-Prinzipien wie Vererbung und Polymorphismus können Programmierer Software mit einer intuitiven Benutzeroberfläche, einer benutzerfreundlichen Oberfläche und einer optisch ansprechenden Ästhetik entwickeln.
Software Engineering, eine Disziplin der Informatik, betont den künstlerischen Aspekt der Programmierung. Es deckt den gesamten Softwareentwicklungslebenszyklus ab, von der Anforderungserfassung bis hin zur Bereitstellung und Wartung. Softwareentwickler gehen beim Programmieren wie Architekten vor und entwerfen Systeme und Plattformen, die zuverlässig, skalierbar und wartbar sind. Sie berücksichtigen Faktoren wie Codemodularität, Wiederverwendbarkeit und Architekturmuster, um Softwarelösungen zu erstellen, die Funktionalität und Eleganz vereinen. Die Kunst der Softwareentwicklung besteht darin, technische Einschränkungen, Benutzerbedürfnisse und Designziele in Einklang zu bringen, um Software zu schaffen, die sowohl funktional als auch ästhetisch ansprechend ist. OOP spielt eine Schlüsselrolle in der Softwareentwicklung, indem es einen strukturierten Ansatz zur Bewältigung der Komplexität bietet. Die Aufteilung des Codes in Klassen und Objekte ermöglicht es Softwareentwicklern, Systeme zu entwerfen, die modular, wiederverwendbar und wartbar sind. Mit der richtigen Abstraktion und Kapselung können Softwareentwickler eine Balance finden, die zu einer Software führt, die sowohl funktional als auch elegant ist.
Die Kunst des Programmierens und der Informatik geht über den Technologiesektor hinaus und betrifft Industrien und die Gesellschaft als Ganzes. Vom Gesundheitswesen bis zum Finanzwesen, von Bildung bis Unterhaltung: Programmierung und Informatik revolutionieren die Art und Weise, wie wir arbeiten, kommunizieren und leben. Innovationen wie künstliche Intelligenz, virtuelle Realität und Blockchain-Technologie verändern Branchen und eröffnen neue Horizonte. Programmierer und Informatiker spielen bei diesen transformativen Fortschritten eine Schlüsselrolle, indem sie die Grenzen des Möglichen erweitern und Ideen in die Realität umsetzen. OOP ermöglicht es Programmierern, innovative Lösungen zu entwickeln, die verschiedene Bereiche revolutionieren. Durch die Bewältigung der Komplexität mit der modularen und erweiterbaren Natur von OOP können Programmierer komplexe Systeme wie Algorithmen der künstlichen Intelligenz, immersive Virtual-Reality-Erlebnisse und sichere Blockchain-Anwendungen entwickeln. Diese Fortschritte verändern Branchen, steigern die Produktivität und verbessern die Lebensqualität von Menschen auf der ganzen Welt.
Komplexitätsmanagement ist ein zentraler Aspekt der Softwareentwicklung. Da Systeme immer komplexer werden, ist es notwendig, wirksame Ansätze zu verwenden, um die Komplexität zu verwalten und Wartbarkeit und Skalierbarkeit sicherzustellen.
Das objektorientierte Paradigma ist ein leistungsstarker Ansatz, der erhebliche Vorteile bei der Bewältigung der Komplexität bietet. Durch die Kapselung von Daten und Verhalten in Objekten und die Verwendung von Konzepten wie Kapselung, Vererbung und Polymorphismus bietet das objektorientierte Paradigma eine solide Grundlage für die Verwaltung von Komplexität.
Kapselung ist ein Grundprinzip des objektorientierten Paradigmas, das die Assoziation von Daten und Methoden innerhalb von Objekten fördert. Diese Kapselung verbirgt die interne Komplexität eines Objekts und legt nur die notwendigen Schnittstellen offen, um mit ihm zu interagieren. Durch das Ausblenden von Implementierungsdetails verringert die Kapselung die Komplexität anderer Teile des Systems, sodass sich Entwickler auf Abstraktionen auf höherer Ebene konzentrieren können. Dies fördert die Modularität und verbessert die Lesbarkeit des Codes, wodurch komplexe Systeme leichter zu verstehen und zu warten sind.
Abstraktion ist ein weiteres Schlüsselkonzept im objektorientierten Paradigma zur Bewältigung der Komplexität. Dadurch können Entwickler komplexe reale Objekte als Klassen darstellen und unnötige Details abstrahieren. Durch die Erstellung abstrakter Klassen und Schnittstellen können Entwickler allgemeine Verhaltensweisen und Attribute definieren, die von mehreren Unterklassen geerbt und implementiert werden können. Diese hierarchische Organisation von Klassen ermöglicht es Entwicklern, die Komplexität zu bewältigen, indem sie komplexe Systeme in kleinere, besser verwaltbare Komponenten zerlegen. Jede Klasse konzentriert sich auf ihre spezifischen Verantwortlichkeiten, was zu einer modulareren und verständlicheren Codebasis führt.
Vererbung ist ein leistungsstarker Mechanismus des objektorientierten Paradigmas, der die Wiederverwendung von Code fördert und Redundanz reduziert. Dies ermöglicht es neuen Klassen, Eigenschaften und Verhalten von vorhandenen Klassen zu erben, indem eine „ist“-Beziehung zwischen ihnen hergestellt wird. Vererbung hilft bei der Bewältigung der Komplexität, indem sie es Entwicklern ermöglicht, eine Basisklasse mit gemeinsamen Attributen und Verhaltensweisen zu definieren und dann spezielle Klassen zu erstellen, die davon erben. Diese hierarchische Organisation von Klassen eliminiert Codeduplizierung, reduziert die Komplexität und verbessert die Wartbarkeit.
Polymorphismus ist ein Schlüsselmerkmal des objektorientierten Paradigmas, das es ermöglicht, Objekte unterschiedlichen Typs auf der Grundlage ihrer gemeinsamen Schnittstellen austauschbar zu behandeln. Polymorphismus vereinfacht das Komplexitätsmanagement, indem er es Entwicklern ermöglicht, Code zu schreiben, der mit einer Abstraktion auf höherer Ebene arbeitet, ohne sich mit den spezifischen Implementierungsdetails jedes Objekts befassen zu müssen. Mithilfe von Polymorphismus können Entwickler flexiblere und erweiterbare Systeme erstellen, da neue Klassen hinzugefügt werden können, ohne dass sich dies auf vorhandenen Code auswirkt. Dies fördert eine modulare und skalierbare Entwicklung und reduziert langfristig die Komplexität.
Komplexitätsmanagement ist ein entscheidender Aspekt der Softwareentwicklung, und das objektorientierte Paradigma bietet einen leistungsstarken Rahmen für diese Aufgabe.
Durch Prinzipien wie Kapselung, Abstraktion, Vererbung und Polymorphismus ermöglicht das objektorientierte Paradigma Entwicklern, Komplexität effektiv zu verwalten und wartbare, skalierbare und modulare Systeme zu erstellen. Durch die Kapselung von Daten und Verhalten in Objekten, die Abstrahierung unnötiger Details, die Wiederverwendung von Code durch Vererbung und die Verwendung von Polymorphismus bietet das objektorientierte Paradigma einen umfassenden Ansatz zur Verwaltung von Komplexität. Die Verwendung des objektorientierten Paradigmas verbessert den Softwareentwicklungsprozess erheblich und trägt zur Schaffung zuverlässiger und verwaltbarer Softwaresysteme bei.
Die Kunst des Programmierens verbindet wissenschaftliche Prinzipien mit Kreativität, Problemlösung und Innovation. Es ist eine Disziplin, die sowohl technisches Können als auch künstlerische Vision erfordert. Die Bewältigung der Komplexität mit einem objektorientierten Ansatz ist bei der Programmierung von wesentlicher Bedeutung und ermöglicht es Programmierern, elegante und effiziente Lösungen zu entwickeln und die Benutzererfahrung zu verbessern.
Mit fortschreitender Technologie wird Software weiterhin unsere digitale Welt prägen und zukünftige Innovationen vorantreiben.