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.
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
Using Big O For Algorithm Comparison
A First Task!
Solution & A Gotcha
About this Course & Outline
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
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
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
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
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
An Introduction to Sets
The Cartesian Product Algorithm
Cartesian Product – Time Complexity
The Cartesian Product Algorithm – Without Limits
The Permutations Algorithms
Permutations without Repetitions
Permutations without Repetitions – Big O
Permutations WITH Repetitions
Solving Problems In A Structured Way
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