Algorithms are a complex, yet **vital part of programming** and of being a developer!

Being able to come up with algorithms (= being able to **solve problems**) is extremely important, not only for **interviews** but also, in general, to **grow** as a developer.

But diving into algorithms and finding the **best possible solution** for a given problem can be a daunting task.

And even once you have found a solution, it might not be the best one.

**This course helps you with all of that!**

You will learn **what** algorithms are, **which kinds** of algorithms you may find out there and most importantly, you will learn how to **derive algorithms** and how to **judge as well as compare** them!

We will dive into this complex topic step by step and by the end of the course, you will have a very strong foundation and all the core fundamental concepts you need to build and optimize your own algorithms for any problem out there!

This course introduces you to algorithms all related important concepts step by step.

**In detail, you will learn:**

- What algorithms are
- Why algorithms are important
- How to judge and compare algorithms
- All about “Time Complexity”, “Space Complexity” and the “Big O” notation
- Different time complexities and how to derive them
- How to use recursion with algorithms
- Optimization approaches like “Dynamic Programming”
- All core concepts you need for math, search, sorting and sets/ array algorithms
- Different kinds of solving problems (e.g. greedy approaches, dynamic approaches)

By the end of the course, you will have a very **solid foundation** and a **plan on how to tackle any problem** and find a fitting algorithm! You will be well-prepared to dive deeper and explore more problems and algorithms.

The different concepts are taught step by step with small, focused code examples and all building blocks being visualized on slides to make understanding them as easy as possible!

This course is for you if you want to take the next step as a developer, if you want to ace interviews or if you simply want to grow as a developer.

It assumes **no prior algorithm knowledge** but you of course need **solid programming fundamentals** – preferably in JavaScript, the programming language used in this course.

## What you will learn

Welcome to the Course!

What & Why

Measuring Algorithm Performance & Time Complexity

Big O Notation

Deriving the Time Complexity / Big O of an Algorithm

Constant Time

Using Big O For Algorithm Comparison

A First Task!

Solution & A Gotcha

About this Course & Outline

Module Introduction

The Fibonacci Problem

The Fibonacci Solution

Fibonacci Big O (Time Complexity)

The “Is Prime” Problem

The “Is Prime” Solution

“Is Prime”, Big O & Multiple Cases

“Is Prime” – Improved Version

Time to Practice (Problem)

Time to Practice (Solution)

Identifying Big O Quickly

Is Power Of Two Algorithm

Logarithmic Time Complexity

Bitwise Operators & Power Of Two

Again: Identifying Big O Quickly

The Factorial Algorithm

Module Introduction

Recursion in Algorithms

Exponential Time Complexity

Quadratic Time Complexity vs Exponential Time Complexity

What is “Dynamic Programming”?

“Dynamic Programming” in Action

The “Bottom Up” Approach

Module Introduction

What Search Algorithms Are About

Introducing Linear Search

Linear Search in Action

Linear Search Time Complexity

Binary Search in Theory

Binary Search in Action

Binary Search Time Complexity

Recursive Binary Search

The Master Theorem

Module Introduction

What are Sorting Algorithms About?

Bubble Sort – Theory

Bubble Sort in Action

Bubble Sort Time Complexity

Quicksort – Theory

Quicksort in Action

Quicksort Time Complexity

Merge Sort – Theory

Merge Sort in Action

Merge Sort Time Complexity

Summary

Module Introduction

Introducing Space Complexity

Deriving Space Complexity

Factorial Algorithm (Loop) – Space Complexity

Factorial Algorithm (Recursive) – Space Complexity

Linear Search – Space Complexity

Binary Search – Space Complexity

Bubble Sort – Space Complexity

Quicksort – Space Complexity

Merge Sort – Space Complexity

Module Introduction

An Introduction to Sets

The Cartesian Product Algorithm

Cartesian Product – Time Complexity

The Cartesian Product Algorithm – Without Limits

The Permutations Algorithms

Permutations without Repetitions

Understanding Permutations

Permutations without Repetitions – Big O

Permutations WITH Repetitions

Module Introduction

Solving Problems In A Structured Way

Simplifying Problems

Practice Makes Perfect!

The Knapsack Problem (0/1)

A Wrong Approach

Approaching the Problem Differently

A Working Knapsack Solution

An Improved Knapsack Algorithm

Greedy vs Dynamic Algorithms

A Greedy Knapsack Algorithm

A New Problem Solving Plan

The Change Making Problem

A Greedy Change Making Algorithm

A Variation to the Change Making Problem

Course Roundup

Sales Page: **https://pro.academind.com/p/javascript-algorithms-the-fundamentals**