Data Structures and Algorithms 🚀

To kick off the AlgoDaily Data Structures and Algorithms course, we'll discuss two important visual concepts you'll need to master: pointers and windows.

Pointers and Windows covers the most common type of programming interview questions: those involving arrays, vectors, lists, and references. We first cover the basics of strings and arrays, then we go through some important structures (like sets) and techniques (like sliding window), before launching you into some exercises in the next few sections to practice your knowledge.

We'll now go through our first section that's chock-full of challenges. After learning about the most important patterns for linear data structures, we'll get some practice with basic string problems.

Recall that a string is sequence of characters, either as a literal constant or as some kind of variable, that can usually have its elements be mutated and length changed. Due to their prevalence in day-to-day programming, they account for a significant amount of the problems you may encounter in interviews.

After we wrap, we'll move onto some basic array interview problems.

We'll now move on to a very similar structure to strings-- arrays.

Defined as a basic linear data structure that holds a fixed number of containers to store data, arrays are the building blocks of many other data structures.

Let's hammer the array techniques home with the following problems.

After understanding linear data structures and practicing on some problems, we'll now turn to one of the most important concepts in algorithms: sorting.

We'll cover the fundamentals and go through a collection of important basic sorting algorithms to know.

Ready to level up a bit?

What's a linear data structure that holds a fixed number of containers to store data? Arrays. And let's work through lots of array problems, but we'll up the ante and make them a little more difficult!

If you've studied Computer Science, you've heard about recursion before. Recursion is the process of defining a problem in terms of itself, and is surprisingly handy when it comes to cracking tough programming interviews.

In this section, we'll learn how to use recursion to solve a few problems. We'll start with a simple concept, and then build up to more complex problems.

In this section, we cover the use of hash maps and hash tables. A hash table/map is a data structure that maps keys to values using a hash function to compute an index of buckets.

It gets an entire section for itself given how commonly you'll use them in real-world solutions. We also start introducing you to a powerful technique, dynamic programming, which can be used to solve some of the more challenging interview questions.

We're now moving on to stacks!

They are a container of objects that are inserted and removed according to the first-in, last-out principle. Stacks are a little more complex than lists, but they provide some useful additional functionality. The first element added to the stack is the last element removed, which makes them more like a traditional stack of plates in a cafe or diner. They're used to store data that might be added and removed many times, like undo information for a text editor, browser history or an undo command.

In this section, we'll look at how queues work and how to use them in your interviews and in writing programs.

Queues work by storing data items in the order they arrive, and removing or processing them in the same order. This is known as first-in, first-out (FIFO) processing. They have many different uses, but developers often find them especially useful when it comes to doing some work in order, or in the background while keeping the main program/thread unblocked. They're very similar to stacks, which are LIFO (last-in, first-out) structures.

Let's start playing with some pointers! Linked lists can be confusing to start, by we'll show you step by step how to master them.

Linked lists are a data structure that contain a sequence of items. They are very useful when you need to keep track of a group of objects and add or remove items from the middle of the list based on your needs.

In this section we'll cover:

• What is a linked list?
• How do they work?
• What are their advantages and disadvantages?

Linked lists are a collection of nodes that are connected by links or pointers. In this section, we'll power through some exercises to get you familiar with their inner workings.

The goal of this section is to become comfortable using linked list terminology and concepts. We'll start by practicing the basic operations on a linked list — adding and removing elements — and then we'll move on to more advanced topics like finding specific elements in a list.

Knowledge of trees and tree traversal algorithms are required to understand the inner workings of databases, autocompletion, file directories, and much more. As usual, you'll get a strong overview of what you need to know before we jump into some problems.

Tree traversal algorithms are crucial for understanding how data is organized in many applications. They're used in file systems, compilers, XML parsers, databases and many other places. In this chapter we'll start by giving an overview of what trees are and why they're so useful, and get to know some more advanced patterns prior to jumping into problems!

Trees are a data structure that models a hierarchical collection of nodes via links. We'll tackle some problems in this section to get practice in.

In the majority of cases, we've given you some environment variables that provide the object structure of a tree, letting you focus on the algorithm at hand!

Binary search trees are a type of binary trees that takes ordering into account.

BSTs are used to store data items which may be inserted, deleted, or retrieved in constant time. In addition, the BST property ensures that the tree is balanced) and that the height of the tree is logarithmic in the number of nodes in it.

They are an example of a self-balancing binary tree: every node in a binary search tree has at most two children, with every child having a value less than its parent. This allows us to perform lookups and insertions by searching through the tree from top to bottom until we find our target node, which has no more than two children itself; at this point we have found our target or there is no such node in our tree.

Because of these attributes, they make for popular interview problems!

In programming, we use graphs to model relationships between objects. Social media, map and GIS software, and the entire World Wide Web are built on top of these simple but foundational data structures.

So what exactly is a graph? A graph is a collection of nodes connected by edges (or lines). Nodes can be anything: people, places, things. Edges connect two or more nodes together. If you're familiar with social networking sites like Facebook or Twitter, you've already seen graphs in action.

Graphs are an extremely powerful tool for understanding our world because they capture relationships between objects, or how those objects relate to one another. You can use them to represent everything from connections between friends on social networks, to road networks that criss-cross cities and countries around the world.

Graphs are an abstract data type made up of connected vertices and edges that allows operations on those connections. They are also used in other disciplines. For example, in epidemiology and public health research, we use graphs to model disease transmission between hosts. In this post, I'll focus on how we can use graph theory to model relationships between people and the things they care about.

Let's practice using them in this section!

Dynamic programming is both a mathematical optimization method and a computer programming method that breaks down complicated problems to sub-problems. Dynamic programming uses recursion to solve problems which would be solved iteratively in an equivalent tree or network model. The technique was introduced by Richard Bellman (1952), who used it to solve a variety of problems including those in the fields of mathematics, economics, statistics, engineering, accounting, linguistics and other areas of science.

Dynamic programming solves a problem by breaking it down into subproblems and storing their solutions as part of the original problem's solution. The approach works by first solving each subproblem as if it were the only one; that is done by solving only for the first variable in each subproblem. Then, all values from all subproblems are summed up together to get the final solution for the entire original problem. This technique is known as "memoization".

Even if you never encounter them, the concepts learned are useful for solving many other kinds of coding challenges. Let's practice some dynamic programming problems!

As we've studied before, recursion is the process of defining a problem in terms of itself, and is surprisingly handy when it comes to cracking tough programming interviews.

In this section, we'll go through problems involving recursion. Problems involving recursion often involve more focused visualization than those that don't, so don't be discouraged if you can't solve them right away. It's important to practice these problems, as they are a common interview topic.

In one of our final sections of the course, we'll study some hard string problems. Recall that strings are a sequence of characters, either as a literal constant or as some kind of variable, that can have its elements be mutated and length changed.

In this section, we'll study some problems that require a bit more thought than the previous ones. Some of them may involve multiple data structures, and some may involve some clever algorithms. We'll start with a problem that involves a bit of both.

A basic linear data structure that holds a fixed number of containers to store data.