In sailing, a course is the lowermost sail on a mast.
This term is used predominantly in the plural to describe the lowest sails on a square rigged vessel, i.e., a ship's courses would be the foresail, mainsail, and, on the rare occasions in which one is shipped, mizzen.Gaff-rigged vessels may use the term (for the lowest sail rigged aft of each mast), but are more likely to refer simply to a mainsail, foresail, etc. A Bermuda- or lateen-rigged yacht, whether sloop, cutter, ketch or yawl, would not usually be described as having a course.
References
↑ "The Mainsail, Foresail, and Mizen, are also called Courses." Lever, Darcy. The Young Sea Officer's Sheet Anchor. 2nd Edition first published 1819. (c) 1998 by Dover Publications, Inc., Mineola, NY 11501: p. 121. N.B. The "mizen" to which Lever refers is a fore-and-aft sail more commonly called "spanker" or "driver" today as, indeed, he did on occasion, q.v., p. 66. The lowest yard on a ship's mizzenmast is the "cross-jack yard" and a squaresail bent thereon is typically referred to as a cross-jack. The true "mizzen yard" evolved into or was replaced by the gaff by the turn of the 19th century, q.v., page 42.
In navigation, an object's course is the direction over the ground along which the object is currently moving.
Course, track, route and heading
The line connecting the object's consecutive positions on the ground is referred to as the ground track. The track the object was intended to follow is called the route. For ships and aircraft, the route is represented by the great circle line that connects the previous waypoint with the next waypoint. The responsibility of a navigator is to make the track coincide as much as possible with the route. The direction of the route is called the route course. "Course" exceptionally, and arguably erroneously, may also refer to the route, such as in a course deviation indicator, in which case it no longer constitutes an angle but rather a line. The direction of the great circle line that runs from the current position to the next waypoint is called the course to steer, or the bearing to that waypoint. The tracking angle is the angle between the course to steer and the course. The heading is the direction to which the "nose" of the object is pointing, its orientation.
An orienteeringcourse is composed of a start point, a series of control points, and a finish point. Controls are marked with a white and orange flag in the terrain, and corresponding purple symbols on an orienteering map. The challenge is to complete the course by visiting all control points in the shortest possible time, aided only by the map and a compass.
Course types and lengths
Courses can have varying degrees of difficulty, both technical and physical. Courses for children and novices are made easy, while experienced competitors may face extremely challenging courses. Technical difficulty is determined primarily by the terrain and the navigational problems of crossing that terrain to locate the feature on which the control is placed. Linear features such as fences, walls, and paths generally offer low difficulty; natural features such as forest or open moor can offer high difficulty. Physical difficulty is determined by the length of the course, the amount of climb, and the kinds of terrain (rocky, boggy, undergrowth etc.). General guidelines for orienteering courses are available from the International Orienteering Federation and national orienteering sport bodies.
The first book of Structures was begun in early 1951, as Boulez was completing his orchestral work Polyphonie X, and finished in 1952. It consists of three movements, or "chapters", labelled Ia, Ib, and Ic, composed in the order a, c, b. The first of the second book's two "chapters" was composed in 1956, but chapter 2 was not written until 1961. The second chapter includes three sets of variable elements, which are to be arranged to make a performing version (Häusler 1965, 5). A partial premiere of book 2 was performed by the composer and Yvonne Loriod at the Wigmore Hall, London, in March 1957. This was Boulez's first appearance in the UK as a performer (Griffiths 1973). The same performers gave the premiere of the complete second book, with two different versions of chapter 2, in a chamber-music concert of the Donaueschinger Musiktage on Saturday, 21 October 1961 (Südwestrundfunk n.d.).
DATA were an electronic music band created in the late 1970s by Georg Kajanus, creator of such bands as Eclection, Sailor and Noir (with Tim Dry of the robotic/music duo Tik and Tok). After the break-up of Sailor in the late 1970s, Kajanus decided to experiment with electronic music and formed DATA, together with vocalists Francesca ("Frankie") and Phillipa ("Phil") Boulter, daughters of British singer John Boulter.
The classically orientated title track of DATA’s first album, Opera Electronica, was used as the theme music to the short film, Towers of Babel (1981), which was directed by Jonathan Lewis and starred Anna Quayle and Ken Campbell. Towers of Babel was nominated for a BAFTA award in 1982 and won the Silver Hugo Award for Best Short Film at the Chicago International Film Festival of the same year.
DATA released two more albums, the experimental 2-Time (1983) and the Country & Western-inspired electronica album Elegant Machinery (1985). The title of the last album was the inspiration for the name of Swedish pop synth group, elegant MACHINERY, formerly known as Pole Position.
The word data has generated considerable controversy on if it is a singular, uncountable noun, or should be treated as the plural of the now-rarely-used datum.
Usage in English
In one sense, data is the plural form of datum. Datum actually can also be a count noun with the plural datums (see usage in datum article) that can be used with cardinal numbers (e.g. "80 datums"); data (originally a Latin plural) is not used like a normal count noun with cardinal numbers and can be plural with such plural determiners as these and many or as a singular abstract mass noun with a verb in the singular form.
Even when a very small quantity of data is referenced (one number, for example) the phrase piece of data is often used, as opposed to datum. The debate over appropriate usage continues, but "data" as a singular form is far more common.
In English, the word datum is still used in the general sense of "an item given". In cartography, geography, nuclear magnetic resonance and technical drawing it is often used to refer to a single specific reference datum from which distances to all other data are measured. Any measurement or result is a datum, though data point is now far more common.
Algorithms and Data Structures Tutorial - Full Course for Beginners
In this course you will learn about algorithms and data structures, two of the fundamental topics in computer science. There are three main parts to this course: algorithms, data structures, and a deep dive into sorting and searching algorithms.
By the end, you will understand what algorithms and data structures are, how they are measured and evaluated, and how they are used to solve problems.
This course was developed by Pasan Premaratne and Jay McGavren. It was made possible by a grant from teamtreehouse.com
⭐️ Course Contents ⭐️
⌨️ (0:00:00) Introduction to Algorithms
⌨️ (1:57:44) Introduction to Data Structures
⌨️ (4:11:02) Algorithms: Sorting and Searching
⭐️ Code Snippets for Course ⭐️
💻 Introduction to Algorithms:
⌨️ Algorithms in Code:
🔗 Linear Search Implementations: https://t...
published: 18 Mar 2021
Data Structures and Algorithms in Python - Full Course for Beginners
A beginner-friendly introduction to common data structures (linked lists, stacks, queues, graphs) and algorithms (search, sorting, recursion, dynamic programming) in Python. This course will help you prepare for coding interviews and assessments.
🔗 Course website: https://jovian.ai/learn/data-structures-and-algorithms-in-python
✏️ Created by Aakash N S, founder and CEO of Jovian.
⭐️ Course Lessons with Code ⭐️
🟢 Lesson 1 - Binary Search, Linked Lists and Complexity
💻 Linear and Binary Search: https://jovian.ai/aakashns/python-binary-search
💻 Problem Solving Template: https://jovian.ai/aakashns/python-problem-solving-template
💻 Linked Lists in Python: https://jovian.ai/aakashns/python-classes-and-linked-lists
🟢 Assignment 1 - Binary Search Practice
💻 Starter Notebook: https:/...
published: 08 Sep 2021
Data Structures Easy to Advanced Course - Full Tutorial from a Google Engineer
Learn and master the most common data structures in this full course from Google engineer William Fiset. This course teaches data structures to beginners using high quality animations to represent the data structures visually.
You will learn how to code various data structures together with simple to follow step-by-step instructions. Every data structure presented will be accompanied by some working source code (in Java) to solidify your understanding.
💻 Code: https://github.com/williamfiset/data-structures
🎥 Course created by William Fiset. Check out his YouTube channel: https://www.youtube.com/channel/UCD8yeTczadqdARzQUp29PJw
⭐️ Course Contents ⭐️
⌨️ (0:00:00) Abstract data types
⌨️ (0:04:28) Introduction to Big-O
⌨️ (0:17:00) Dynamic and Static Arrays
⌨️ (0:27:40) Dynamic Array Code...
published: 19 Sep 2019
Data Structures and Algorithms for Beginners
Data Structures and algorithms for beginners. Ace your coding interview. Watch this tutorial to learn all about Big O, arrays and linked lists!
🚀 Get interview-ready with my full course: https://mosh.link/dsa-course
👍 Subscribe for more awesome content: https://goo.gl/6PYaGF
Need Java foundations first? Check out my tutorial: https://youtu.be/eIrMbAQSU34
✋ Stay connected:
- Twitter: https://twitter.com/moshhamedani
- Facebook: https://www.facebook.com/programmingwithmosh/
- Instagram: https://www.instagram.com/codewithmosh.official/
- LinkedIn: https://www.linkedin.com/school/codewithmosh/
💡 What you'll learn:
- Big O notation for analyzing code efficiency.
- How to implement and use arrays.
- The basics of linked lists.
👉 This tutorial is perfect for you if:
- You're preparing for te...
published: 10 Dec 2019
Data Structures for Beginners Full Course Tutorial
Hello everyone and welcome to an Introduction to Data Structures. My name is Steven and in this lecture-style course, I’ll be taking you through the topic of #Data_Structures in relation to Computer Science. We’ll go over what Data Structures are, how we measure a Data Structures efficiency, and then hop into talking about 12 of the most common Data Structures which will come up throughout your Computer Science journey.
-------------------=+| NullPointerExceptions Channel |+=-------------------
https://www.youtube.com/channel/UCmWDlvMYYEbW42B8JyxFBcA
-------------------=+| Links as They Appear|+=-------------------
An Introduction to Programming: https://www.youtube.com/watch?v=tVftenlYw44
Binary Search Explanation: https://youtu.be/tVftenlYw44?t=5567
Linear Search Explanation: https://y...
published: 22 Aug 2020
Data Structures and Algorithms in JavaScript - Full Course for Beginners
Learn common data structures and algorithms in this tutorial course. You will learn the theory behind them, as well as how to program them in JavaScript.
⭐️ Contents (link to code after title) ⭐️
⌨️ Stacks (00:21) https://codepen.io/beaucarnes/pen/yMBGbR?editors=0012
⌨️ Sets (09:03) https://codepen.io/beaucarnes/pen/dvGeeq?editors=0012
⌨️ Queues & Priority Queues (19:24) https://codepen.io/beaucarnes/pen/QpaQRG?editors=0012
⌨️ Binary Search Tree (26:03) https://codepen.io/beaucarnes/pen/ryKvEQ?editors=0011
⌨️ Binary Search Tree: Traversal & Height (39:34) https://codepen.io/beaucarnes/pen/ryKvEQ?editors=0011
⌨️ Hash Tables (53:19) https://codepen.io/beaucarnes/pen/VbYGMb?editors=0012
⌨️ Linked List (1:03:04) https://codepen.io/beaucarnes/pen/ybOvBq?editors=0011
⌨️ Trie (1:14:59) https://c...
published: 04 Sep 2018
Algorithms & Data Structures Full Crash Course
This is a full four-and-a-half hour crash course on algorithms and data structures. It is a compilation of all the individual episodes from the playlist.
Timestamps
(00:00:00) Intro
(00:01:42) Fundamentals
(00:30:17) Runtime Complexity
(00:58:08) Big-O Notation
(01:11:55) Important Runtimes
(01:31:54) Analyzing Algorithms
(01:57:04) Greedy Algorithms
(02:02:42) Sorting Algorithms
(02:58:11) Graph Theory
(03:25:00) Basic Data Structures
(04:09:05) Self-Balancing Trees
◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾
📚 Programming Books & Merch 📚
💻 The Algorithm Bible Book: https://www.neuralnine.com/books/
🐍 The Python Bible Book: https://www.neuralnine.com/books/
👕 Programming Merch: https://www.neuralnine.com/shop
🌐 Social Media & Contact 🌐
📱 Website: https://www.neuralnine.com/
📷 Instagram: https://www.instagram....
In this course you will learn about algorithms and data structures, two of the fundamental topics in computer science. There are three main parts to this course...
In this course you will learn about algorithms and data structures, two of the fundamental topics in computer science. There are three main parts to this course: algorithms, data structures, and a deep dive into sorting and searching algorithms.
By the end, you will understand what algorithms and data structures are, how they are measured and evaluated, and how they are used to solve problems.
This course was developed by Pasan Premaratne and Jay McGavren. It was made possible by a grant from teamtreehouse.com
⭐️ Course Contents ⭐️
⌨️ (0:00:00) Introduction to Algorithms
⌨️ (1:57:44) Introduction to Data Structures
⌨️ (4:11:02) Algorithms: Sorting and Searching
⭐️ Code Snippets for Course ⭐️
💻 Introduction to Algorithms:
⌨️ Algorithms in Code:
🔗 Linear Search Implementations: https://teamtreehouse.com/library/introduction-to-algorithms/algorithms-in-code/linear-search-implementations
🔗 Binary Search Implementations: https://teamtreehouse.com/library/introduction-to-algorithms/algorithms-in-code/binary-search-implementations
💻 Introduction to Data Structures
⌨️ Exploring Arrays:
🔗 Array Characteristics and Storage: https://teamtreehouse.com/library/introduction-to-data-structures/exploring-arrays/array-characteristics-and-storage
🔗 Operations on Arrays: https://teamtreehouse.com/library/introduction-to-data-structures/exploring-arrays/operations-on-arrays
⌨️ Building a Linked List:
🔗 Singly and Doubly Linked Lists: https://teamtreehouse.com/library/introduction-to-data-structures/building-a-linked-list/singly-and-doubly-linked-lists-2
🔗 Linked List Operations: https://teamtreehouse.com/library/introduction-to-data-structures/building-a-linked-list/linked-lists-operations
⌨️ The Merge Sort Algorithm:
🔗 Merge Sort Implementations: https://teamtreehouse.com/library/introduction-to-data-structures/the-merge-sort-algorithm/merge-sort-implementations
🔗 Alternate Versions of Merge Sort: https://teamtreehouse.com/library/introduction-to-data-structures/the-merge-sort-algorithm/alternate-versions-of-merge-sort
⌨️ Merge Sort and Linked Lists:
🔗 Implementing Merge Sort on Linked Lists: https://teamtreehouse.com/library/introduction-to-data-structures/merge-sort-and-linked-lists/implementing-merge-sort-on-linked-lists
💻 Algorithms: Sorting and Searching
⌨️ Sorting Algorithms:
🔗 Code for Bogosort: https://teamtreehouse.com/library/algorithms-sorting-and-searching/sorting-algorithms/code-for-bogosort
🔗 Code for Selection Sort: https://teamtreehouse.com/library/algorithms-sorting-and-searching/sorting-algorithms/code-for-selection-sort
🔗 Code for Quicksort: https://teamtreehouse.com/library/algorithms-sorting-and-searching/sorting-algorithms/code-for-quicksort
🔗 Code for Merge Sort: https://teamtreehouse.com/library/algorithms-sorting-and-searching/sorting-algorithms/code-for-merge-sort
⌨️ Searching Names:
🔗 Code for Linear Search: https://teamtreehouse.com/library/algorithms-sorting-and-searching/searching-names/code-for-linear-search
🔗 Code for Binary Search: https://teamtreehouse.com/library/algorithms-sorting-and-searching/searching-names/code-for-binary-search
--
Learn to code for free and get a developer job: https://www.freecodecamp.org
Read hundreds of articles on programming: https://freecodecamp.org/news
In this course you will learn about algorithms and data structures, two of the fundamental topics in computer science. There are three main parts to this course: algorithms, data structures, and a deep dive into sorting and searching algorithms.
By the end, you will understand what algorithms and data structures are, how they are measured and evaluated, and how they are used to solve problems.
This course was developed by Pasan Premaratne and Jay McGavren. It was made possible by a grant from teamtreehouse.com
⭐️ Course Contents ⭐️
⌨️ (0:00:00) Introduction to Algorithms
⌨️ (1:57:44) Introduction to Data Structures
⌨️ (4:11:02) Algorithms: Sorting and Searching
⭐️ Code Snippets for Course ⭐️
💻 Introduction to Algorithms:
⌨️ Algorithms in Code:
🔗 Linear Search Implementations: https://teamtreehouse.com/library/introduction-to-algorithms/algorithms-in-code/linear-search-implementations
🔗 Binary Search Implementations: https://teamtreehouse.com/library/introduction-to-algorithms/algorithms-in-code/binary-search-implementations
💻 Introduction to Data Structures
⌨️ Exploring Arrays:
🔗 Array Characteristics and Storage: https://teamtreehouse.com/library/introduction-to-data-structures/exploring-arrays/array-characteristics-and-storage
🔗 Operations on Arrays: https://teamtreehouse.com/library/introduction-to-data-structures/exploring-arrays/operations-on-arrays
⌨️ Building a Linked List:
🔗 Singly and Doubly Linked Lists: https://teamtreehouse.com/library/introduction-to-data-structures/building-a-linked-list/singly-and-doubly-linked-lists-2
🔗 Linked List Operations: https://teamtreehouse.com/library/introduction-to-data-structures/building-a-linked-list/linked-lists-operations
⌨️ The Merge Sort Algorithm:
🔗 Merge Sort Implementations: https://teamtreehouse.com/library/introduction-to-data-structures/the-merge-sort-algorithm/merge-sort-implementations
🔗 Alternate Versions of Merge Sort: https://teamtreehouse.com/library/introduction-to-data-structures/the-merge-sort-algorithm/alternate-versions-of-merge-sort
⌨️ Merge Sort and Linked Lists:
🔗 Implementing Merge Sort on Linked Lists: https://teamtreehouse.com/library/introduction-to-data-structures/merge-sort-and-linked-lists/implementing-merge-sort-on-linked-lists
💻 Algorithms: Sorting and Searching
⌨️ Sorting Algorithms:
🔗 Code for Bogosort: https://teamtreehouse.com/library/algorithms-sorting-and-searching/sorting-algorithms/code-for-bogosort
🔗 Code for Selection Sort: https://teamtreehouse.com/library/algorithms-sorting-and-searching/sorting-algorithms/code-for-selection-sort
🔗 Code for Quicksort: https://teamtreehouse.com/library/algorithms-sorting-and-searching/sorting-algorithms/code-for-quicksort
🔗 Code for Merge Sort: https://teamtreehouse.com/library/algorithms-sorting-and-searching/sorting-algorithms/code-for-merge-sort
⌨️ Searching Names:
🔗 Code for Linear Search: https://teamtreehouse.com/library/algorithms-sorting-and-searching/searching-names/code-for-linear-search
🔗 Code for Binary Search: https://teamtreehouse.com/library/algorithms-sorting-and-searching/searching-names/code-for-binary-search
--
Learn to code for free and get a developer job: https://www.freecodecamp.org
Read hundreds of articles on programming: https://freecodecamp.org/news
A beginner-friendly introduction to common data structures (linked lists, stacks, queues, graphs) and algorithms (search, sorting, recursion, dynamic programmin...
A beginner-friendly introduction to common data structures (linked lists, stacks, queues, graphs) and algorithms (search, sorting, recursion, dynamic programming) in Python. This course will help you prepare for coding interviews and assessments.
🔗 Course website: https://jovian.ai/learn/data-structures-and-algorithms-in-python
✏️ Created by Aakash N S, founder and CEO of Jovian.
⭐️ Course Lessons with Code ⭐️
🟢 Lesson 1 - Binary Search, Linked Lists and Complexity
💻 Linear and Binary Search: https://jovian.ai/aakashns/python-binary-search
💻 Problem Solving Template: https://jovian.ai/aakashns/python-problem-solving-template
💻 Linked Lists in Python: https://jovian.ai/aakashns/python-classes-and-linked-lists
🟢 Assignment 1 - Binary Search Practice
💻 Starter Notebook: https://jovian.ai/aakashns/python-binary-search-assignment
🟢 Lesson 2 - Binary Search Trees, Traversals and Recursion
💻 Binary Search Trees in Python: https://jovian.ai/aakashns/python-binary-search-trees
💻 Problem Solving Template: https://jovian.ai/aakashns/python-problem-solving-template
💻 Linked Lists in Python: https://jovian.ai/aakashns/python-classes-and-linked-lists
🟢 Assignment 2 - Hash Tables and Python Dictionaries
💻 Starter Notebook: https://jovian.ai/aakashns/python-hash-tables-assignment
🟢 Lesson 3 - Sorting Algorithms and Divide & Conquer
💻 Sorting and Divide & Conquer: https://jovian.ai/aakashns/python-sorting-divide-and-conquer
💻 Problem Solving Template: https://jovian.ai/aakashns/python-problem-solving-template
🟢 Assignment 3 - Divide and Conquer Practice
💻 Starter Notebook: https://jovian.ai/aakashns/python-divide-and-conquer-assignment
🟢 Lesson 4 - Recursion and Dynamic Programming
💻 Problem-solving template: https://jovian.ai/aakashns/python-problem-solving-template
💻 Dynamic Programming problems: https://jovian.ai/aakashns/dynamic-programming-problems
🟢 Lesson 5 - Graph Algorithms (BFS, DFS & Shortest Paths)
💻 Graphs and Graph Algorithms (Starter Notebook): https://jovian.ai/aakashns/python-graph-algorithms
🟢 Project - Step-by-Step Solution to a Programming Problem
💻 Starter Notebook: https://jovian.ai/aakashns/python-problem-solving-template
🟢 Lesson 6 - Python Interview Questions, Tips & Advice
💻 Problem solving template: https://jovian.ai/aakashns/python-problem-solving-template
💻 Coding problem 1: https://jovian.ai/aakashns/python-subarray-with-given-sum
💻 Coding problem 2: https://jovian.ai/aakashns/python-minimum-edit-distance
⭐️ Course Contents ⭐️
⌨️ (00:00:00) Introduction
⌨️ (00:01:43) Binary Search Linked Lists and Complexity
⌨️ (00:03:43) Introduction
⌨️ (00:08:35) Problem
⌨️ (00:12:17) The Method
⌨️ (00:13:55) Solution
⌨️ (00:50:52) Complexity and Big O notation
⌨️ (01:24:57) Binary Search vs Linear Search
⌨️ (01:31:40) Generic Binary Search
⌨️ (01:40:08) Summary and Conclusion
⌨️ (01:44:30) Assignment Walkthrough
⌨️ (01:45:05) Introduction
⌨️ (01:50:01) Problem- Rotated Lists
⌨️ (01:53:02) The Method
⌨️ (01:54:03) Solution
⌨️ (02:30:47) Summary and Conclusion
⌨️ (02:33:29) Binary Search Trees Python Tutorial
⌨️ (02:34:41) Introduction
⌨️ (02:37:36) Problem
⌨️ (02:38:40) The Method
⌨️ (03:13:58) Binary tree
⌨️ (03:27:16) Traversing Binary Tree
⌨️ (03:36:10) Binary Search Tree
⌨️ (04:22:37) Self-Balancing Binary Trees and AVL Trees
⌨️ (04:26:27) Summary and Conclusion
⌨️ (04:30:33) Hash Tables and Python Dictionaries
⌨️ (04:31:09) Introduction
⌨️ (04:34:00) Problem
⌨️ (04:40:28) Data List
⌨️ (04:42:52) Hash Function
⌨️ (04:54:52) Basic Hash Table Implementation
⌨️ (05:03:07) Handling Collisions with Linear Probing
⌨️ (05:09:24) Summary and Conclusion
⌨️ (05:16:47) Sorting Algorithms and Divide & Conquer
⌨️ (05:17:48) Introduction
⌨️ (05:20:19) Problem
⌨️ (05:21:27) The Method
⌨️ (06:40:49) Custom Comparison Functions
⌨️ (06:48:53) Summary and Conclusion
⌨️ (06:54:57) Recursion Memoization & Dynamic Programming
⌨️ (06:56:37) Introduction
⌨️ (07:00:04) Problem
⌨️ (07:04:28) The Method
⌨️ (07:06:21) Solution
⌨️ (08:06:13) Knapsack Problems
⌨️ (08:08:48) The Method
⌨️ (08:09:24) Solution
⌨️ (08:43:26) Summary and Conclusion
⌨️ (08:44:05) Graph Algorithms BFS, DFS & Shortest Paths
⌨️ (08:45:02) Introduction
⌨️ (08:51:00) Graph Data Structure
⌨️ (09:15:57) Graph Algorithms - Breadth-First Search
⌨️ (09:37:28) Depth-First Search
⌨️ (10:08:26) Shortest Paths
⌨️ (10:40:39) Summary and Conclusion
⌨️ (10:42:21) Python Interview Questions Tips & Advice
⌨️ (10:43:09) Introduction
⌨️ (10:44:08) The Method
⌨️ (10:47:10) Solution
⌨️ (12:30:51) Summary and Conclusion
Learn and master the most common data structures in this full course from Google engineer William Fiset. This course teaches data structures to beginners using ...
Learn and master the most common data structures in this full course from Google engineer William Fiset. This course teaches data structures to beginners using high quality animations to represent the data structures visually.
You will learn how to code various data structures together with simple to follow step-by-step instructions. Every data structure presented will be accompanied by some working source code (in Java) to solidify your understanding.
💻 Code: https://github.com/williamfiset/data-structures
🎥 Course created by William Fiset. Check out his YouTube channel: https://www.youtube.com/channel/UCD8yeTczadqdARzQUp29PJw
⭐️ Course Contents ⭐️
⌨️ (0:00:00) Abstract data types
⌨️ (0:04:28) Introduction to Big-O
⌨️ (0:17:00) Dynamic and Static Arrays
⌨️ (0:27:40) Dynamic Array Code
⌨️ (0:35:03) Linked Lists Introduction
⌨️ (0:49:16) Doubly Linked List Code
⌨️ (0:58:26) Stack Introduction
⌨️ (1:09:40) Stack Implementation
⌨️ (1:12:49) Stack Code
⌨️ (1:15:58) Queue Introduction
⌨️ (1:22:03) Queue Implementation
⌨️ (1:27:26) Queue Code
⌨️ (1:31:32) Priority Queue Introduction
⌨️ (1:44:16) Priority Queue Min Heaps and Max Heaps
⌨️ (1:49:55) Priority Queue Inserting Elements
⌨️ (1:59:27) Priority Queue Removing Elements
⌨️ (2:13:00) Priority Queue Code
⌨️ (2:28:26) Union Find Introduction
⌨️ (2:33:57) Union Find Kruskal's Algorithm
⌨️ (2:40:04) Union Find - Union and Find Operations
⌨️ (2:50:30) Union Find Path Compression
⌨️ (2:56:37) Union Find Code
⌨️ (3:03:54) Binary Search Tree Introduction
⌨️ (3:15:57) Binary Search Tree Insertion
⌨️ (3:21:20) Binary Search Tree Removal
⌨️ (3:34:47) Binary Search Tree Traversals
⌨️ (3:46:17) Binary Search Tree Code
⌨️ (3:59:26) Hash table hash function
⌨️ (4:16:25) Hash table separate chaining
⌨️ (4:24:10) Hash table separate chaining source code
⌨️ (4:35:44) Hash table open addressing
⌨️ (4:46:36) Hash table linear probing
⌨️ (5:00:21) Hash table quadratic probing
⌨️ (5:09:32) Hash table double hashing
⌨️ (5:23:56) Hash table open addressing removing
⌨️ (5:31:02) Hash table open addressing code
⌨️ (5:45:36) Fenwick Tree range queries
⌨️ (5:58:46) Fenwick Tree point updates
⌨️ (6:03:09) Fenwick Tree construction
⌨️ (6:09:21) Fenwick tree source code
⌨️ (6:14:47) Suffix Array introduction
⌨️ (6:17:54) Longest Common Prefix (LCP) array
⌨️ (6:21:07) Suffix array finding unique substrings
⌨️ (6:25:36) Longest common substring problem suffix array
⌨️ (6:37:04) Longest common substring problem suffix array part 2
⌨️ (6:43:41) Longest Repeated Substring suffix array
⌨️ (6:48:13) Balanced binary search tree rotations
⌨️ (6:56:43) AVL tree insertion
⌨️ (7:05:42) AVL tree removals
⌨️ (7:14:12) AVL tree source code
⌨️ (7:30:49) Indexed Priority Queue | Data Structure
⌨️ (7:55:10) Indexed Priority Queue | Data Structure | Source Code
--
Learn to code for free and get a developer job: https://www.freecodecamp.org
Read hundreds of articles on programming: https://www.freecodecamp.org/news
Learn and master the most common data structures in this full course from Google engineer William Fiset. This course teaches data structures to beginners using high quality animations to represent the data structures visually.
You will learn how to code various data structures together with simple to follow step-by-step instructions. Every data structure presented will be accompanied by some working source code (in Java) to solidify your understanding.
💻 Code: https://github.com/williamfiset/data-structures
🎥 Course created by William Fiset. Check out his YouTube channel: https://www.youtube.com/channel/UCD8yeTczadqdARzQUp29PJw
⭐️ Course Contents ⭐️
⌨️ (0:00:00) Abstract data types
⌨️ (0:04:28) Introduction to Big-O
⌨️ (0:17:00) Dynamic and Static Arrays
⌨️ (0:27:40) Dynamic Array Code
⌨️ (0:35:03) Linked Lists Introduction
⌨️ (0:49:16) Doubly Linked List Code
⌨️ (0:58:26) Stack Introduction
⌨️ (1:09:40) Stack Implementation
⌨️ (1:12:49) Stack Code
⌨️ (1:15:58) Queue Introduction
⌨️ (1:22:03) Queue Implementation
⌨️ (1:27:26) Queue Code
⌨️ (1:31:32) Priority Queue Introduction
⌨️ (1:44:16) Priority Queue Min Heaps and Max Heaps
⌨️ (1:49:55) Priority Queue Inserting Elements
⌨️ (1:59:27) Priority Queue Removing Elements
⌨️ (2:13:00) Priority Queue Code
⌨️ (2:28:26) Union Find Introduction
⌨️ (2:33:57) Union Find Kruskal's Algorithm
⌨️ (2:40:04) Union Find - Union and Find Operations
⌨️ (2:50:30) Union Find Path Compression
⌨️ (2:56:37) Union Find Code
⌨️ (3:03:54) Binary Search Tree Introduction
⌨️ (3:15:57) Binary Search Tree Insertion
⌨️ (3:21:20) Binary Search Tree Removal
⌨️ (3:34:47) Binary Search Tree Traversals
⌨️ (3:46:17) Binary Search Tree Code
⌨️ (3:59:26) Hash table hash function
⌨️ (4:16:25) Hash table separate chaining
⌨️ (4:24:10) Hash table separate chaining source code
⌨️ (4:35:44) Hash table open addressing
⌨️ (4:46:36) Hash table linear probing
⌨️ (5:00:21) Hash table quadratic probing
⌨️ (5:09:32) Hash table double hashing
⌨️ (5:23:56) Hash table open addressing removing
⌨️ (5:31:02) Hash table open addressing code
⌨️ (5:45:36) Fenwick Tree range queries
⌨️ (5:58:46) Fenwick Tree point updates
⌨️ (6:03:09) Fenwick Tree construction
⌨️ (6:09:21) Fenwick tree source code
⌨️ (6:14:47) Suffix Array introduction
⌨️ (6:17:54) Longest Common Prefix (LCP) array
⌨️ (6:21:07) Suffix array finding unique substrings
⌨️ (6:25:36) Longest common substring problem suffix array
⌨️ (6:37:04) Longest common substring problem suffix array part 2
⌨️ (6:43:41) Longest Repeated Substring suffix array
⌨️ (6:48:13) Balanced binary search tree rotations
⌨️ (6:56:43) AVL tree insertion
⌨️ (7:05:42) AVL tree removals
⌨️ (7:14:12) AVL tree source code
⌨️ (7:30:49) Indexed Priority Queue | Data Structure
⌨️ (7:55:10) Indexed Priority Queue | Data Structure | Source Code
--
Learn to code for free and get a developer job: https://www.freecodecamp.org
Read hundreds of articles on programming: https://www.freecodecamp.org/news
Data Structures and algorithms for beginners. Ace your coding interview. Watch this tutorial to learn all about Big O, arrays and linked lists!
🚀 Get interview...
Data Structures and algorithms for beginners. Ace your coding interview. Watch this tutorial to learn all about Big O, arrays and linked lists!
🚀 Get interview-ready with my full course: https://mosh.link/dsa-course
👍 Subscribe for more awesome content: https://goo.gl/6PYaGF
Need Java foundations first? Check out my tutorial: https://youtu.be/eIrMbAQSU34
✋ Stay connected:
- Twitter: https://twitter.com/moshhamedani
- Facebook: https://www.facebook.com/programmingwithmosh/
- Instagram: https://www.instagram.com/codewithmosh.official/
- LinkedIn: https://www.linkedin.com/school/codewithmosh/
💡 What you'll learn:
- Big O notation for analyzing code efficiency.
- How to implement and use arrays.
- The basics of linked lists.
👉 This tutorial is perfect for you if:
- You're preparing for technical job interviews.
- You want to improve your coding fundamentals.
- You're a CS student learning these concepts.
Let's get started!
📖 TABLE OF CONTENT
0:00:00 Intro
0:01:04 What is Big O?
0:03:03 O(1)
0:04:32 O(n)
0:08:17 O(n^2)
0:10:41 O(log n)
0:13:20 O(2^n)
0:14:10 Space Complexity
0:17:53 Understanding Arrays
0:21:03 Working with Arrays
0:24:32 Exercise: Building an Array
0:27:24 Solution: Creating the Array Class
0:30:43 Solution: insert()
0:35:03 Solution: remove()
0:39:54 Solution: indexOf()
0:42:23 Dynamic Arrays
0:46:11 Linked Lists Introduction
0:46:41 What are Linked Lists?
0:51:16 Working with Linked Lists
0:54:40 Exercise: Building a Linked List
0:56:05 Solution: addLast()
1:02:15 Solution: addFirst()
1:04:28 Solution: indexOf()
1:06:23 Solution: contains()
1:07:28 Solution: removeFirst()
1:11:52 Solution: removeLast()
#ComputerScience #Coding #Programming
Data Structures and algorithms for beginners. Ace your coding interview. Watch this tutorial to learn all about Big O, arrays and linked lists!
🚀 Get interview-ready with my full course: https://mosh.link/dsa-course
👍 Subscribe for more awesome content: https://goo.gl/6PYaGF
Need Java foundations first? Check out my tutorial: https://youtu.be/eIrMbAQSU34
✋ Stay connected:
- Twitter: https://twitter.com/moshhamedani
- Facebook: https://www.facebook.com/programmingwithmosh/
- Instagram: https://www.instagram.com/codewithmosh.official/
- LinkedIn: https://www.linkedin.com/school/codewithmosh/
💡 What you'll learn:
- Big O notation for analyzing code efficiency.
- How to implement and use arrays.
- The basics of linked lists.
👉 This tutorial is perfect for you if:
- You're preparing for technical job interviews.
- You want to improve your coding fundamentals.
- You're a CS student learning these concepts.
Let's get started!
📖 TABLE OF CONTENT
0:00:00 Intro
0:01:04 What is Big O?
0:03:03 O(1)
0:04:32 O(n)
0:08:17 O(n^2)
0:10:41 O(log n)
0:13:20 O(2^n)
0:14:10 Space Complexity
0:17:53 Understanding Arrays
0:21:03 Working with Arrays
0:24:32 Exercise: Building an Array
0:27:24 Solution: Creating the Array Class
0:30:43 Solution: insert()
0:35:03 Solution: remove()
0:39:54 Solution: indexOf()
0:42:23 Dynamic Arrays
0:46:11 Linked Lists Introduction
0:46:41 What are Linked Lists?
0:51:16 Working with Linked Lists
0:54:40 Exercise: Building a Linked List
0:56:05 Solution: addLast()
1:02:15 Solution: addFirst()
1:04:28 Solution: indexOf()
1:06:23 Solution: contains()
1:07:28 Solution: removeFirst()
1:11:52 Solution: removeLast()
#ComputerScience #Coding #Programming
Hello everyone and welcome to an Introduction to Data Structures. My name is Steven and in this lecture-style course, I’ll be taking you through the topic of #D...
Hello everyone and welcome to an Introduction to Data Structures. My name is Steven and in this lecture-style course, I’ll be taking you through the topic of #Data_Structures in relation to Computer Science. We’ll go over what Data Structures are, how we measure a Data Structures efficiency, and then hop into talking about 12 of the most common Data Structures which will come up throughout your Computer Science journey.
-------------------=+| NullPointerExceptions Channel |+=-------------------
https://www.youtube.com/channel/UCmWDlvMYYEbW42B8JyxFBcA
-------------------=+| Links as They Appear|+=-------------------
An Introduction to Programming: https://www.youtube.com/watch?v=tVftenlYw44
Binary Search Explanation: https://youtu.be/tVftenlYw44?t=5567
Linear Search Explanation: https://youtu.be/tVftenlYw44?t=5457
Introduction to Object Oriented Programming: https://www.youtube.com/watch?v=3ycztbPPOlc
Recursion Explanation: https://youtu.be/tVftenlYw44?t=5787
Article explaining Backed Data Structures: https://tinyurl.com/y3fs9lt7
-------------------=+| Time Stamps |+=-------------------
💻 (00:00) Introduction
⌨️ (01:06) Timestamps
⌨️ (01:23) Script and Visuals
⌨️ (01:34) References + Research
⌨️ (01:56) Questions
⌨️ (02:12) Shameless Plug
⌨️ (02:51) What are Data Structures?
⌨️ (04:36) Series Overview
💻 (06:55) Measuring Efficiency with BigO Notation
⌨️ (09:45) Time Complexity Equations
⌨️ (11:13) The Meaning of BigO
⌨️ (12:42) Why BigO?
⌨️ (13:18) Quick Recap
⌨️ (14:27) Types of Time Complexity Equations
⌨️ (19:42) Final Note on Time Complexity Equations
💻 (20:21) The Array
⌨️ (20:58) Array Basics
⌨️ (22:09) Array Names
⌨️ (22:59) Parallel Arrays
⌨️ (23:59) Array Types
⌨️ (24:30) Array Size
⌨️ (25:45) Creating Arrays
⌨️ (26:11) Populate-First Arrays
⌨️ (28:09) Populate-Later Arrays
⌨️ (30:22) Numerical Indexes
⌨️ (31:57) Replacing information in an Array
⌨️ (32:42) 2-Dimensional Arrays
⌨️ (35:01) Arrays as a Data Structure
⌨️ (42:21) Pros and Cons
💻 (43:33) The ArrayList
⌨️ (44:42) Structure of the ArrayList
⌨️ (45:19) Initializing an ArrayList
⌨️ (47:34) ArrayList Functionality
⌨️ (49:30) ArrayList Methods
⌨️ (50:26) Add Method
⌨️ (53:57) Remove Method
⌨️ (55:33) Get Method
⌨️ (55:59) Set Method
⌨️ (56:57) Clear Method
⌨️ (57:30) toArray Method
⌨️ (59:00) ArrayList as a Data Structure
⌨️ (1:03:12) Comparing and Contrasting with Arrays
💻 (1:05:02) The Stack
⌨️ (1:05:06) The Different types of Data Structures
⌨️ (1:05:51) Random Access Data Structures
⌨️ (1:06:10) Sequential Access Data Structures
⌨️ (1:07:36) Stack Basics
⌨️ (1:09:01) Common Stack Methods
⌨️ (1:09:45) Push Method
⌨️ (1:10:32) Pop Method
⌨️ (1:11:46) Peek Method
⌨️ (1:12:27) Contains Method
⌨️ (1:13:23) Time Complexity Equations
⌨️ (1:15:28) Uses for Stacks
💻 (1:18:01) The Queue
⌨️ (1:18:51) Queue Basics
⌨️ (1:20:44) Common Queue Methods
⌨️ (1:21:13) Enqueue Method
⌨️ (1:22:20) Dequeue Method
⌨️ (1:23:08) Peek Method
⌨️ (1:24:15) Contains Method
⌨️ (1:25:05) Time Complexity Equations
⌨️ (1:27:05) Common Queue Uses
💻 (1:28:16) The Linked List
⌨️ (1:31:37 ) LinkedList Visualization
⌨️ (1:33:55) Adding and Removing Information
⌨️ (1:41:28) Time Complexity Equations
⌨️ (1:44:26) Uses for LinkedLists
💻 (1:47:19) The Doubly-LinkedList
⌨️ (1:48:44) Visualization
⌨️ (1:50:56) Adding and Removing Information
⌨️ (1:58:30) Time Complexity Equations
⌨️ (1:59:06) Uses of a Doubly-LinkedList
💻 (2:00:21) The Dictionary
⌨️ (2:01:15) Dictionary Basics
⌨️ (2:02:00) Indexing Dictionaries
⌨️ (2:02:40) Dictionary Properties
💻 (2:05:53) Hash Table Mini-Lesson
⌨️ (2:13:26) Time Complexity Equations
💻 (2:16:39) Trees
⌨️ (2:16:55) Introduction to Hierarchical Data
⌨️ (2:18:54) Formal Background on the Tree
⌨️ (2:20:03) Tree Terminology and Visualization
⌨️ (2:25:08) Different types of Trees
⌨️ (2:28:07) Uses for the Tree
💻 (2:29:00) Tries
⌨️ (2:29:50) Trie Basics
⌨️ (2:30:41) Trie Visualization
⌨️ (2:34:33) Flagging
⌨️ (2:35:15) Uses for Tries
💻 (2:38:25) Heaps
⌨️ (2:38:51) Heap Basics
⌨️ (2:39:19) Min-Heaps
⌨️ (2:40:07) Max-Heaps
⌨️ (2:40:59) Building Heaps
⌨️ (2:44:20) Deleting from Heaps
⌨️ (2:46:00) Heap Implementations
💻 (2:48:15) Graphs
⌨️ (2:49:25) Graph Basics
⌨️ (2:52:04) Directed vs. Undirected Graphs
⌨️ (2:53:45) Cyclic vs. Acyclic Graphs
⌨️ (2:55:04 Weighted Graphs
⌨️ (2:55:46) Types of Graphs
💻 (2:58:20) Conclusion
💻 (2:58:43) Shameless Plug
-------------------=+| Script, Visuals and Sources |+=-------------------
Google Folder: https://tinyurl.com/yxr64y46
All three are in a google doc as the description length on YouTube is only 5000 Characters
Hello everyone and welcome to an Introduction to Data Structures. My name is Steven and in this lecture-style course, I’ll be taking you through the topic of #Data_Structures in relation to Computer Science. We’ll go over what Data Structures are, how we measure a Data Structures efficiency, and then hop into talking about 12 of the most common Data Structures which will come up throughout your Computer Science journey.
-------------------=+| NullPointerExceptions Channel |+=-------------------
https://www.youtube.com/channel/UCmWDlvMYYEbW42B8JyxFBcA
-------------------=+| Links as They Appear|+=-------------------
An Introduction to Programming: https://www.youtube.com/watch?v=tVftenlYw44
Binary Search Explanation: https://youtu.be/tVftenlYw44?t=5567
Linear Search Explanation: https://youtu.be/tVftenlYw44?t=5457
Introduction to Object Oriented Programming: https://www.youtube.com/watch?v=3ycztbPPOlc
Recursion Explanation: https://youtu.be/tVftenlYw44?t=5787
Article explaining Backed Data Structures: https://tinyurl.com/y3fs9lt7
-------------------=+| Time Stamps |+=-------------------
💻 (00:00) Introduction
⌨️ (01:06) Timestamps
⌨️ (01:23) Script and Visuals
⌨️ (01:34) References + Research
⌨️ (01:56) Questions
⌨️ (02:12) Shameless Plug
⌨️ (02:51) What are Data Structures?
⌨️ (04:36) Series Overview
💻 (06:55) Measuring Efficiency with BigO Notation
⌨️ (09:45) Time Complexity Equations
⌨️ (11:13) The Meaning of BigO
⌨️ (12:42) Why BigO?
⌨️ (13:18) Quick Recap
⌨️ (14:27) Types of Time Complexity Equations
⌨️ (19:42) Final Note on Time Complexity Equations
💻 (20:21) The Array
⌨️ (20:58) Array Basics
⌨️ (22:09) Array Names
⌨️ (22:59) Parallel Arrays
⌨️ (23:59) Array Types
⌨️ (24:30) Array Size
⌨️ (25:45) Creating Arrays
⌨️ (26:11) Populate-First Arrays
⌨️ (28:09) Populate-Later Arrays
⌨️ (30:22) Numerical Indexes
⌨️ (31:57) Replacing information in an Array
⌨️ (32:42) 2-Dimensional Arrays
⌨️ (35:01) Arrays as a Data Structure
⌨️ (42:21) Pros and Cons
💻 (43:33) The ArrayList
⌨️ (44:42) Structure of the ArrayList
⌨️ (45:19) Initializing an ArrayList
⌨️ (47:34) ArrayList Functionality
⌨️ (49:30) ArrayList Methods
⌨️ (50:26) Add Method
⌨️ (53:57) Remove Method
⌨️ (55:33) Get Method
⌨️ (55:59) Set Method
⌨️ (56:57) Clear Method
⌨️ (57:30) toArray Method
⌨️ (59:00) ArrayList as a Data Structure
⌨️ (1:03:12) Comparing and Contrasting with Arrays
💻 (1:05:02) The Stack
⌨️ (1:05:06) The Different types of Data Structures
⌨️ (1:05:51) Random Access Data Structures
⌨️ (1:06:10) Sequential Access Data Structures
⌨️ (1:07:36) Stack Basics
⌨️ (1:09:01) Common Stack Methods
⌨️ (1:09:45) Push Method
⌨️ (1:10:32) Pop Method
⌨️ (1:11:46) Peek Method
⌨️ (1:12:27) Contains Method
⌨️ (1:13:23) Time Complexity Equations
⌨️ (1:15:28) Uses for Stacks
💻 (1:18:01) The Queue
⌨️ (1:18:51) Queue Basics
⌨️ (1:20:44) Common Queue Methods
⌨️ (1:21:13) Enqueue Method
⌨️ (1:22:20) Dequeue Method
⌨️ (1:23:08) Peek Method
⌨️ (1:24:15) Contains Method
⌨️ (1:25:05) Time Complexity Equations
⌨️ (1:27:05) Common Queue Uses
💻 (1:28:16) The Linked List
⌨️ (1:31:37 ) LinkedList Visualization
⌨️ (1:33:55) Adding and Removing Information
⌨️ (1:41:28) Time Complexity Equations
⌨️ (1:44:26) Uses for LinkedLists
💻 (1:47:19) The Doubly-LinkedList
⌨️ (1:48:44) Visualization
⌨️ (1:50:56) Adding and Removing Information
⌨️ (1:58:30) Time Complexity Equations
⌨️ (1:59:06) Uses of a Doubly-LinkedList
💻 (2:00:21) The Dictionary
⌨️ (2:01:15) Dictionary Basics
⌨️ (2:02:00) Indexing Dictionaries
⌨️ (2:02:40) Dictionary Properties
💻 (2:05:53) Hash Table Mini-Lesson
⌨️ (2:13:26) Time Complexity Equations
💻 (2:16:39) Trees
⌨️ (2:16:55) Introduction to Hierarchical Data
⌨️ (2:18:54) Formal Background on the Tree
⌨️ (2:20:03) Tree Terminology and Visualization
⌨️ (2:25:08) Different types of Trees
⌨️ (2:28:07) Uses for the Tree
💻 (2:29:00) Tries
⌨️ (2:29:50) Trie Basics
⌨️ (2:30:41) Trie Visualization
⌨️ (2:34:33) Flagging
⌨️ (2:35:15) Uses for Tries
💻 (2:38:25) Heaps
⌨️ (2:38:51) Heap Basics
⌨️ (2:39:19) Min-Heaps
⌨️ (2:40:07) Max-Heaps
⌨️ (2:40:59) Building Heaps
⌨️ (2:44:20) Deleting from Heaps
⌨️ (2:46:00) Heap Implementations
💻 (2:48:15) Graphs
⌨️ (2:49:25) Graph Basics
⌨️ (2:52:04) Directed vs. Undirected Graphs
⌨️ (2:53:45) Cyclic vs. Acyclic Graphs
⌨️ (2:55:04 Weighted Graphs
⌨️ (2:55:46) Types of Graphs
💻 (2:58:20) Conclusion
💻 (2:58:43) Shameless Plug
-------------------=+| Script, Visuals and Sources |+=-------------------
Google Folder: https://tinyurl.com/yxr64y46
All three are in a google doc as the description length on YouTube is only 5000 Characters
Learn common data structures and algorithms in this tutorial course. You will learn the theory behind them, as well as how to program them in JavaScript.
⭐️ Co...
Learn common data structures and algorithms in this tutorial course. You will learn the theory behind them, as well as how to program them in JavaScript.
⭐️ Contents (link to code after title) ⭐️
⌨️ Stacks (00:21) https://codepen.io/beaucarnes/pen/yMBGbR?editors=0012
⌨️ Sets (09:03) https://codepen.io/beaucarnes/pen/dvGeeq?editors=0012
⌨️ Queues & Priority Queues (19:24) https://codepen.io/beaucarnes/pen/QpaQRG?editors=0012
⌨️ Binary Search Tree (26:03) https://codepen.io/beaucarnes/pen/ryKvEQ?editors=0011
⌨️ Binary Search Tree: Traversal & Height (39:34) https://codepen.io/beaucarnes/pen/ryKvEQ?editors=0011
⌨️ Hash Tables (53:19) https://codepen.io/beaucarnes/pen/VbYGMb?editors=0012
⌨️ Linked List (1:03:04) https://codepen.io/beaucarnes/pen/ybOvBq?editors=0011
⌨️ Trie (1:14:59) https://codepen.io/beaucarnes/pen/mmBNBd?editors=0011
⌨️ Heap (max and min) (1:27:29) https://codepen.io/beaucarnes/pen/JNvENQ?editors=0010
🔗 Heap visualization: https://www.cs.usfca.edu/~galles/visualization/Heap.html
⌨️ Graphs: adjacency list, adjacency matrix, incidence matrix (1:42:07)
⌨️ Graphs: breadth-first search (1:46:45) https://codepen.io/beaucarnes/pen/XgrXvw?editors=0012
📄Data structures article by Beau Carnes: https://medium.freecodecamp.org/10-common-data-structures-explained-with-videos-exercises-aaff6c06fb2b
🐦Follow creator Beau Carnes on Twitter: https://twitter.com/carnesbeau
🔗Beau also made this Algorithms course from Manning Publications: https://www.manning.com/livevideo/algorithms-in-motion?a_aid=algmotion&a_bid=9022d293 (Promo code: 39carnes)
🎥And if you like robots and toys, check out Beau's other YouTube channel: https://www.youtube.com/robotfamily
--
Learn to code for free and get a developer job: https://www.freecodecamp.org
Read hundreds of articles on programming: https://medium.freecodecamp.org
Learn common data structures and algorithms in this tutorial course. You will learn the theory behind them, as well as how to program them in JavaScript.
⭐️ Contents (link to code after title) ⭐️
⌨️ Stacks (00:21) https://codepen.io/beaucarnes/pen/yMBGbR?editors=0012
⌨️ Sets (09:03) https://codepen.io/beaucarnes/pen/dvGeeq?editors=0012
⌨️ Queues & Priority Queues (19:24) https://codepen.io/beaucarnes/pen/QpaQRG?editors=0012
⌨️ Binary Search Tree (26:03) https://codepen.io/beaucarnes/pen/ryKvEQ?editors=0011
⌨️ Binary Search Tree: Traversal & Height (39:34) https://codepen.io/beaucarnes/pen/ryKvEQ?editors=0011
⌨️ Hash Tables (53:19) https://codepen.io/beaucarnes/pen/VbYGMb?editors=0012
⌨️ Linked List (1:03:04) https://codepen.io/beaucarnes/pen/ybOvBq?editors=0011
⌨️ Trie (1:14:59) https://codepen.io/beaucarnes/pen/mmBNBd?editors=0011
⌨️ Heap (max and min) (1:27:29) https://codepen.io/beaucarnes/pen/JNvENQ?editors=0010
🔗 Heap visualization: https://www.cs.usfca.edu/~galles/visualization/Heap.html
⌨️ Graphs: adjacency list, adjacency matrix, incidence matrix (1:42:07)
⌨️ Graphs: breadth-first search (1:46:45) https://codepen.io/beaucarnes/pen/XgrXvw?editors=0012
📄Data structures article by Beau Carnes: https://medium.freecodecamp.org/10-common-data-structures-explained-with-videos-exercises-aaff6c06fb2b
🐦Follow creator Beau Carnes on Twitter: https://twitter.com/carnesbeau
🔗Beau also made this Algorithms course from Manning Publications: https://www.manning.com/livevideo/algorithms-in-motion?a_aid=algmotion&a_bid=9022d293 (Promo code: 39carnes)
🎥And if you like robots and toys, check out Beau's other YouTube channel: https://www.youtube.com/robotfamily
--
Learn to code for free and get a developer job: https://www.freecodecamp.org
Read hundreds of articles on programming: https://medium.freecodecamp.org
This is a full four-and-a-half hour crash course on algorithms and data structures. It is a compilation of all the individual episodes from the playlist.
Times...
This is a full four-and-a-half hour crash course on algorithms and data structures. It is a compilation of all the individual episodes from the playlist.
Timestamps
(00:00:00) Intro
(00:01:42) Fundamentals
(00:30:17) Runtime Complexity
(00:58:08) Big-O Notation
(01:11:55) Important Runtimes
(01:31:54) Analyzing Algorithms
(01:57:04) Greedy Algorithms
(02:02:42) Sorting Algorithms
(02:58:11) Graph Theory
(03:25:00) Basic Data Structures
(04:09:05) Self-Balancing Trees
◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾
📚 Programming Books & Merch 📚
💻 The Algorithm Bible Book: https://www.neuralnine.com/books/
🐍 The Python Bible Book: https://www.neuralnine.com/books/
👕 Programming Merch: https://www.neuralnine.com/shop
🌐 Social Media & Contact 🌐
📱 Website: https://www.neuralnine.com/
📷 Instagram: https://www.instagram.com/neuralnine
🐦 Twitter: https://twitter.com/neuralnine
🤵 LinkedIn: https://www.linkedin.com/company/neuralnine/
📁 GitHub: https://github.com/NeuralNine
🖥️ My Coding Setup 🖥️
⌨️ Keyboard: http://hyperurl.co/neuralkeyboard
🖱️ Mouse: http://hyperurl.co/neuralmouse
🖥️ Monitor: http://hyperurl.co/neuralmonitor
🎙️ Microphone: http://hyperurl.co/neuralmicrophone
✏️ Drawing Tablet: http://hyperurl.co/neuraldraw
🎵 Outro Music From: https://www.bensound.com/
◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾
This is a full four-and-a-half hour crash course on algorithms and data structures. It is a compilation of all the individual episodes from the playlist.
Timestamps
(00:00:00) Intro
(00:01:42) Fundamentals
(00:30:17) Runtime Complexity
(00:58:08) Big-O Notation
(01:11:55) Important Runtimes
(01:31:54) Analyzing Algorithms
(01:57:04) Greedy Algorithms
(02:02:42) Sorting Algorithms
(02:58:11) Graph Theory
(03:25:00) Basic Data Structures
(04:09:05) Self-Balancing Trees
◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾
📚 Programming Books & Merch 📚
💻 The Algorithm Bible Book: https://www.neuralnine.com/books/
🐍 The Python Bible Book: https://www.neuralnine.com/books/
👕 Programming Merch: https://www.neuralnine.com/shop
🌐 Social Media & Contact 🌐
📱 Website: https://www.neuralnine.com/
📷 Instagram: https://www.instagram.com/neuralnine
🐦 Twitter: https://twitter.com/neuralnine
🤵 LinkedIn: https://www.linkedin.com/company/neuralnine/
📁 GitHub: https://github.com/NeuralNine
🖥️ My Coding Setup 🖥️
⌨️ Keyboard: http://hyperurl.co/neuralkeyboard
🖱️ Mouse: http://hyperurl.co/neuralmouse
🖥️ Monitor: http://hyperurl.co/neuralmonitor
🎙️ Microphone: http://hyperurl.co/neuralmicrophone
✏️ Drawing Tablet: http://hyperurl.co/neuraldraw
🎵 Outro Music From: https://www.bensound.com/
◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾
In this course you will learn about algorithms and data structures, two of the fundamental topics in computer science. There are three main parts to this course: algorithms, data structures, and a deep dive into sorting and searching algorithms.
By the end, you will understand what algorithms and data structures are, how they are measured and evaluated, and how they are used to solve problems.
This course was developed by Pasan Premaratne and Jay McGavren. It was made possible by a grant from teamtreehouse.com
⭐️ Course Contents ⭐️
⌨️ (0:00:00) Introduction to Algorithms
⌨️ (1:57:44) Introduction to Data Structures
⌨️ (4:11:02) Algorithms: Sorting and Searching
⭐️ Code Snippets for Course ⭐️
💻 Introduction to Algorithms:
⌨️ Algorithms in Code:
🔗 Linear Search Implementations: https://teamtreehouse.com/library/introduction-to-algorithms/algorithms-in-code/linear-search-implementations
🔗 Binary Search Implementations: https://teamtreehouse.com/library/introduction-to-algorithms/algorithms-in-code/binary-search-implementations
💻 Introduction to Data Structures
⌨️ Exploring Arrays:
🔗 Array Characteristics and Storage: https://teamtreehouse.com/library/introduction-to-data-structures/exploring-arrays/array-characteristics-and-storage
🔗 Operations on Arrays: https://teamtreehouse.com/library/introduction-to-data-structures/exploring-arrays/operations-on-arrays
⌨️ Building a Linked List:
🔗 Singly and Doubly Linked Lists: https://teamtreehouse.com/library/introduction-to-data-structures/building-a-linked-list/singly-and-doubly-linked-lists-2
🔗 Linked List Operations: https://teamtreehouse.com/library/introduction-to-data-structures/building-a-linked-list/linked-lists-operations
⌨️ The Merge Sort Algorithm:
🔗 Merge Sort Implementations: https://teamtreehouse.com/library/introduction-to-data-structures/the-merge-sort-algorithm/merge-sort-implementations
🔗 Alternate Versions of Merge Sort: https://teamtreehouse.com/library/introduction-to-data-structures/the-merge-sort-algorithm/alternate-versions-of-merge-sort
⌨️ Merge Sort and Linked Lists:
🔗 Implementing Merge Sort on Linked Lists: https://teamtreehouse.com/library/introduction-to-data-structures/merge-sort-and-linked-lists/implementing-merge-sort-on-linked-lists
💻 Algorithms: Sorting and Searching
⌨️ Sorting Algorithms:
🔗 Code for Bogosort: https://teamtreehouse.com/library/algorithms-sorting-and-searching/sorting-algorithms/code-for-bogosort
🔗 Code for Selection Sort: https://teamtreehouse.com/library/algorithms-sorting-and-searching/sorting-algorithms/code-for-selection-sort
🔗 Code for Quicksort: https://teamtreehouse.com/library/algorithms-sorting-and-searching/sorting-algorithms/code-for-quicksort
🔗 Code for Merge Sort: https://teamtreehouse.com/library/algorithms-sorting-and-searching/sorting-algorithms/code-for-merge-sort
⌨️ Searching Names:
🔗 Code for Linear Search: https://teamtreehouse.com/library/algorithms-sorting-and-searching/searching-names/code-for-linear-search
🔗 Code for Binary Search: https://teamtreehouse.com/library/algorithms-sorting-and-searching/searching-names/code-for-binary-search
--
Learn to code for free and get a developer job: https://www.freecodecamp.org
Read hundreds of articles on programming: https://freecodecamp.org/news
Learn and master the most common data structures in this full course from Google engineer William Fiset. This course teaches data structures to beginners using high quality animations to represent the data structures visually.
You will learn how to code various data structures together with simple to follow step-by-step instructions. Every data structure presented will be accompanied by some working source code (in Java) to solidify your understanding.
💻 Code: https://github.com/williamfiset/data-structures
🎥 Course created by William Fiset. Check out his YouTube channel: https://www.youtube.com/channel/UCD8yeTczadqdARzQUp29PJw
⭐️ Course Contents ⭐️
⌨️ (0:00:00) Abstract data types
⌨️ (0:04:28) Introduction to Big-O
⌨️ (0:17:00) Dynamic and Static Arrays
⌨️ (0:27:40) Dynamic Array Code
⌨️ (0:35:03) Linked Lists Introduction
⌨️ (0:49:16) Doubly Linked List Code
⌨️ (0:58:26) Stack Introduction
⌨️ (1:09:40) Stack Implementation
⌨️ (1:12:49) Stack Code
⌨️ (1:15:58) Queue Introduction
⌨️ (1:22:03) Queue Implementation
⌨️ (1:27:26) Queue Code
⌨️ (1:31:32) Priority Queue Introduction
⌨️ (1:44:16) Priority Queue Min Heaps and Max Heaps
⌨️ (1:49:55) Priority Queue Inserting Elements
⌨️ (1:59:27) Priority Queue Removing Elements
⌨️ (2:13:00) Priority Queue Code
⌨️ (2:28:26) Union Find Introduction
⌨️ (2:33:57) Union Find Kruskal's Algorithm
⌨️ (2:40:04) Union Find - Union and Find Operations
⌨️ (2:50:30) Union Find Path Compression
⌨️ (2:56:37) Union Find Code
⌨️ (3:03:54) Binary Search Tree Introduction
⌨️ (3:15:57) Binary Search Tree Insertion
⌨️ (3:21:20) Binary Search Tree Removal
⌨️ (3:34:47) Binary Search Tree Traversals
⌨️ (3:46:17) Binary Search Tree Code
⌨️ (3:59:26) Hash table hash function
⌨️ (4:16:25) Hash table separate chaining
⌨️ (4:24:10) Hash table separate chaining source code
⌨️ (4:35:44) Hash table open addressing
⌨️ (4:46:36) Hash table linear probing
⌨️ (5:00:21) Hash table quadratic probing
⌨️ (5:09:32) Hash table double hashing
⌨️ (5:23:56) Hash table open addressing removing
⌨️ (5:31:02) Hash table open addressing code
⌨️ (5:45:36) Fenwick Tree range queries
⌨️ (5:58:46) Fenwick Tree point updates
⌨️ (6:03:09) Fenwick Tree construction
⌨️ (6:09:21) Fenwick tree source code
⌨️ (6:14:47) Suffix Array introduction
⌨️ (6:17:54) Longest Common Prefix (LCP) array
⌨️ (6:21:07) Suffix array finding unique substrings
⌨️ (6:25:36) Longest common substring problem suffix array
⌨️ (6:37:04) Longest common substring problem suffix array part 2
⌨️ (6:43:41) Longest Repeated Substring suffix array
⌨️ (6:48:13) Balanced binary search tree rotations
⌨️ (6:56:43) AVL tree insertion
⌨️ (7:05:42) AVL tree removals
⌨️ (7:14:12) AVL tree source code
⌨️ (7:30:49) Indexed Priority Queue | Data Structure
⌨️ (7:55:10) Indexed Priority Queue | Data Structure | Source Code
--
Learn to code for free and get a developer job: https://www.freecodecamp.org
Read hundreds of articles on programming: https://www.freecodecamp.org/news
Data Structures and algorithms for beginners. Ace your coding interview. Watch this tutorial to learn all about Big O, arrays and linked lists!
🚀 Get interview-ready with my full course: https://mosh.link/dsa-course
👍 Subscribe for more awesome content: https://goo.gl/6PYaGF
Need Java foundations first? Check out my tutorial: https://youtu.be/eIrMbAQSU34
✋ Stay connected:
- Twitter: https://twitter.com/moshhamedani
- Facebook: https://www.facebook.com/programmingwithmosh/
- Instagram: https://www.instagram.com/codewithmosh.official/
- LinkedIn: https://www.linkedin.com/school/codewithmosh/
💡 What you'll learn:
- Big O notation for analyzing code efficiency.
- How to implement and use arrays.
- The basics of linked lists.
👉 This tutorial is perfect for you if:
- You're preparing for technical job interviews.
- You want to improve your coding fundamentals.
- You're a CS student learning these concepts.
Let's get started!
📖 TABLE OF CONTENT
0:00:00 Intro
0:01:04 What is Big O?
0:03:03 O(1)
0:04:32 O(n)
0:08:17 O(n^2)
0:10:41 O(log n)
0:13:20 O(2^n)
0:14:10 Space Complexity
0:17:53 Understanding Arrays
0:21:03 Working with Arrays
0:24:32 Exercise: Building an Array
0:27:24 Solution: Creating the Array Class
0:30:43 Solution: insert()
0:35:03 Solution: remove()
0:39:54 Solution: indexOf()
0:42:23 Dynamic Arrays
0:46:11 Linked Lists Introduction
0:46:41 What are Linked Lists?
0:51:16 Working with Linked Lists
0:54:40 Exercise: Building a Linked List
0:56:05 Solution: addLast()
1:02:15 Solution: addFirst()
1:04:28 Solution: indexOf()
1:06:23 Solution: contains()
1:07:28 Solution: removeFirst()
1:11:52 Solution: removeLast()
#ComputerScience #Coding #Programming
Hello everyone and welcome to an Introduction to Data Structures. My name is Steven and in this lecture-style course, I’ll be taking you through the topic of #Data_Structures in relation to Computer Science. We’ll go over what Data Structures are, how we measure a Data Structures efficiency, and then hop into talking about 12 of the most common Data Structures which will come up throughout your Computer Science journey.
-------------------=+| NullPointerExceptions Channel |+=-------------------
https://www.youtube.com/channel/UCmWDlvMYYEbW42B8JyxFBcA
-------------------=+| Links as They Appear|+=-------------------
An Introduction to Programming: https://www.youtube.com/watch?v=tVftenlYw44
Binary Search Explanation: https://youtu.be/tVftenlYw44?t=5567
Linear Search Explanation: https://youtu.be/tVftenlYw44?t=5457
Introduction to Object Oriented Programming: https://www.youtube.com/watch?v=3ycztbPPOlc
Recursion Explanation: https://youtu.be/tVftenlYw44?t=5787
Article explaining Backed Data Structures: https://tinyurl.com/y3fs9lt7
-------------------=+| Time Stamps |+=-------------------
💻 (00:00) Introduction
⌨️ (01:06) Timestamps
⌨️ (01:23) Script and Visuals
⌨️ (01:34) References + Research
⌨️ (01:56) Questions
⌨️ (02:12) Shameless Plug
⌨️ (02:51) What are Data Structures?
⌨️ (04:36) Series Overview
💻 (06:55) Measuring Efficiency with BigO Notation
⌨️ (09:45) Time Complexity Equations
⌨️ (11:13) The Meaning of BigO
⌨️ (12:42) Why BigO?
⌨️ (13:18) Quick Recap
⌨️ (14:27) Types of Time Complexity Equations
⌨️ (19:42) Final Note on Time Complexity Equations
💻 (20:21) The Array
⌨️ (20:58) Array Basics
⌨️ (22:09) Array Names
⌨️ (22:59) Parallel Arrays
⌨️ (23:59) Array Types
⌨️ (24:30) Array Size
⌨️ (25:45) Creating Arrays
⌨️ (26:11) Populate-First Arrays
⌨️ (28:09) Populate-Later Arrays
⌨️ (30:22) Numerical Indexes
⌨️ (31:57) Replacing information in an Array
⌨️ (32:42) 2-Dimensional Arrays
⌨️ (35:01) Arrays as a Data Structure
⌨️ (42:21) Pros and Cons
💻 (43:33) The ArrayList
⌨️ (44:42) Structure of the ArrayList
⌨️ (45:19) Initializing an ArrayList
⌨️ (47:34) ArrayList Functionality
⌨️ (49:30) ArrayList Methods
⌨️ (50:26) Add Method
⌨️ (53:57) Remove Method
⌨️ (55:33) Get Method
⌨️ (55:59) Set Method
⌨️ (56:57) Clear Method
⌨️ (57:30) toArray Method
⌨️ (59:00) ArrayList as a Data Structure
⌨️ (1:03:12) Comparing and Contrasting with Arrays
💻 (1:05:02) The Stack
⌨️ (1:05:06) The Different types of Data Structures
⌨️ (1:05:51) Random Access Data Structures
⌨️ (1:06:10) Sequential Access Data Structures
⌨️ (1:07:36) Stack Basics
⌨️ (1:09:01) Common Stack Methods
⌨️ (1:09:45) Push Method
⌨️ (1:10:32) Pop Method
⌨️ (1:11:46) Peek Method
⌨️ (1:12:27) Contains Method
⌨️ (1:13:23) Time Complexity Equations
⌨️ (1:15:28) Uses for Stacks
💻 (1:18:01) The Queue
⌨️ (1:18:51) Queue Basics
⌨️ (1:20:44) Common Queue Methods
⌨️ (1:21:13) Enqueue Method
⌨️ (1:22:20) Dequeue Method
⌨️ (1:23:08) Peek Method
⌨️ (1:24:15) Contains Method
⌨️ (1:25:05) Time Complexity Equations
⌨️ (1:27:05) Common Queue Uses
💻 (1:28:16) The Linked List
⌨️ (1:31:37 ) LinkedList Visualization
⌨️ (1:33:55) Adding and Removing Information
⌨️ (1:41:28) Time Complexity Equations
⌨️ (1:44:26) Uses for LinkedLists
💻 (1:47:19) The Doubly-LinkedList
⌨️ (1:48:44) Visualization
⌨️ (1:50:56) Adding and Removing Information
⌨️ (1:58:30) Time Complexity Equations
⌨️ (1:59:06) Uses of a Doubly-LinkedList
💻 (2:00:21) The Dictionary
⌨️ (2:01:15) Dictionary Basics
⌨️ (2:02:00) Indexing Dictionaries
⌨️ (2:02:40) Dictionary Properties
💻 (2:05:53) Hash Table Mini-Lesson
⌨️ (2:13:26) Time Complexity Equations
💻 (2:16:39) Trees
⌨️ (2:16:55) Introduction to Hierarchical Data
⌨️ (2:18:54) Formal Background on the Tree
⌨️ (2:20:03) Tree Terminology and Visualization
⌨️ (2:25:08) Different types of Trees
⌨️ (2:28:07) Uses for the Tree
💻 (2:29:00) Tries
⌨️ (2:29:50) Trie Basics
⌨️ (2:30:41) Trie Visualization
⌨️ (2:34:33) Flagging
⌨️ (2:35:15) Uses for Tries
💻 (2:38:25) Heaps
⌨️ (2:38:51) Heap Basics
⌨️ (2:39:19) Min-Heaps
⌨️ (2:40:07) Max-Heaps
⌨️ (2:40:59) Building Heaps
⌨️ (2:44:20) Deleting from Heaps
⌨️ (2:46:00) Heap Implementations
💻 (2:48:15) Graphs
⌨️ (2:49:25) Graph Basics
⌨️ (2:52:04) Directed vs. Undirected Graphs
⌨️ (2:53:45) Cyclic vs. Acyclic Graphs
⌨️ (2:55:04 Weighted Graphs
⌨️ (2:55:46) Types of Graphs
💻 (2:58:20) Conclusion
💻 (2:58:43) Shameless Plug
-------------------=+| Script, Visuals and Sources |+=-------------------
Google Folder: https://tinyurl.com/yxr64y46
All three are in a google doc as the description length on YouTube is only 5000 Characters
Learn common data structures and algorithms in this tutorial course. You will learn the theory behind them, as well as how to program them in JavaScript.
⭐️ Contents (link to code after title) ⭐️
⌨️ Stacks (00:21) https://codepen.io/beaucarnes/pen/yMBGbR?editors=0012
⌨️ Sets (09:03) https://codepen.io/beaucarnes/pen/dvGeeq?editors=0012
⌨️ Queues & Priority Queues (19:24) https://codepen.io/beaucarnes/pen/QpaQRG?editors=0012
⌨️ Binary Search Tree (26:03) https://codepen.io/beaucarnes/pen/ryKvEQ?editors=0011
⌨️ Binary Search Tree: Traversal & Height (39:34) https://codepen.io/beaucarnes/pen/ryKvEQ?editors=0011
⌨️ Hash Tables (53:19) https://codepen.io/beaucarnes/pen/VbYGMb?editors=0012
⌨️ Linked List (1:03:04) https://codepen.io/beaucarnes/pen/ybOvBq?editors=0011
⌨️ Trie (1:14:59) https://codepen.io/beaucarnes/pen/mmBNBd?editors=0011
⌨️ Heap (max and min) (1:27:29) https://codepen.io/beaucarnes/pen/JNvENQ?editors=0010
🔗 Heap visualization: https://www.cs.usfca.edu/~galles/visualization/Heap.html
⌨️ Graphs: adjacency list, adjacency matrix, incidence matrix (1:42:07)
⌨️ Graphs: breadth-first search (1:46:45) https://codepen.io/beaucarnes/pen/XgrXvw?editors=0012
📄Data structures article by Beau Carnes: https://medium.freecodecamp.org/10-common-data-structures-explained-with-videos-exercises-aaff6c06fb2b
🐦Follow creator Beau Carnes on Twitter: https://twitter.com/carnesbeau
🔗Beau also made this Algorithms course from Manning Publications: https://www.manning.com/livevideo/algorithms-in-motion?a_aid=algmotion&a_bid=9022d293 (Promo code: 39carnes)
🎥And if you like robots and toys, check out Beau's other YouTube channel: https://www.youtube.com/robotfamily
--
Learn to code for free and get a developer job: https://www.freecodecamp.org
Read hundreds of articles on programming: https://medium.freecodecamp.org
This is a full four-and-a-half hour crash course on algorithms and data structures. It is a compilation of all the individual episodes from the playlist.
Timestamps
(00:00:00) Intro
(00:01:42) Fundamentals
(00:30:17) Runtime Complexity
(00:58:08) Big-O Notation
(01:11:55) Important Runtimes
(01:31:54) Analyzing Algorithms
(01:57:04) Greedy Algorithms
(02:02:42) Sorting Algorithms
(02:58:11) Graph Theory
(03:25:00) Basic Data Structures
(04:09:05) Self-Balancing Trees
◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾
📚 Programming Books & Merch 📚
💻 The Algorithm Bible Book: https://www.neuralnine.com/books/
🐍 The Python Bible Book: https://www.neuralnine.com/books/
👕 Programming Merch: https://www.neuralnine.com/shop
🌐 Social Media & Contact 🌐
📱 Website: https://www.neuralnine.com/
📷 Instagram: https://www.instagram.com/neuralnine
🐦 Twitter: https://twitter.com/neuralnine
🤵 LinkedIn: https://www.linkedin.com/company/neuralnine/
📁 GitHub: https://github.com/NeuralNine
🖥️ My Coding Setup 🖥️
⌨️ Keyboard: http://hyperurl.co/neuralkeyboard
🖱️ Mouse: http://hyperurl.co/neuralmouse
🖥️ Monitor: http://hyperurl.co/neuralmonitor
🎙️ Microphone: http://hyperurl.co/neuralmicrophone
✏️ Drawing Tablet: http://hyperurl.co/neuraldraw
🎵 Outro Music From: https://www.bensound.com/
◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾◾
In sailing, a course is the lowermost sail on a mast.
This term is used predominantly in the plural to describe the lowest sails on a square rigged vessel, i.e., a ship's courses would be the foresail, mainsail, and, on the rare occasions in which one is shipped, mizzen.Gaff-rigged vessels may use the term (for the lowest sail rigged aft of each mast), but are more likely to refer simply to a mainsail, foresail, etc. A Bermuda- or lateen-rigged yacht, whether sloop, cutter, ketch or yawl, would not usually be described as having a course.
References
↑ "The Mainsail, Foresail, and Mizen, are also called Courses." Lever, Darcy. The Young Sea Officer's Sheet Anchor. 2nd Edition first published 1819. (c) 1998 by Dover Publications, Inc., Mineola, NY 11501: p. 121. N.B. The "mizen" to which Lever refers is a fore-and-aft sail more commonly called "spanker" or "driver" today as, indeed, he did on occasion, q.v., p. 66. The lowest yard on a ship's mizzenmast is the "cross-jack yard" and a squaresail bent thereon is typically referred to as a cross-jack. The true "mizzen yard" evolved into or was replaced by the gaff by the turn of the 19th century, q.v., page 42.
When you're absolute beginners It's a panoramic view From her majesty Mount Zion And the kingdom is for you Uh huh, uh huh When you tumble upon that valley Shark or sparrow line the stairs When the arrows start descending Then they scatter everywhere On a bookshelf in Caledonia Sits a map of passageways Best to stumble upon Mount Zion To behold the natural gates Uh huh, uh huh They say the original sinners Never felt a drop of pain Until that second in the garden Then they felt it each and every day So draw back your bows you hunters Who have never felt that plain All the absolute beginners They are safe in the shade for today Uh huh, uh huh When you're absolute beginners It's a panoramic view From her majesty Mount Zion And the kingdom is for you Uh huh, uh huh, uh huh, uh huh, uh huh