English | MP4 | AVC 1920×1080 | AAC 44KHz 2ch | 9h 20m | 1.76 GB
Learn all the core basics and fundamentals about JavaScript algorithms, dive into tons of examples and get a plan for building and measuring algorithms.
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.
Table of Contents
Getting Started
1 Welcome to the Course!
2 What & Why
3 Measuring Algorithm Performance & Time Complexity
4 Big O Notation
5 Deriving the Time Complexity / Big O of an Algorithm
6 Constant Time
7 Using Big O For Algorithm Comparison
8 A First Task!
9 Solution & A Gotcha
10 About this Course & Outline
Math Algorithms & Practicing The Basics
11 Module Introduction
12 The Fibonacci Problem
13 The Fibonacci Solution
14 Fibonacci Big O (Time Complexity)
15 The “Is Prime” Problem
16 The “Is Prime” Solution
17 “Is Prime”, Big O & Multiple Cases
18 “Is Prime” – Improved Version
19 Time to Practice (Problem)
20 Time to Practice (Solution)
21 Identifying Big O Quickly
22 Is Power Of Two Algorithm
23 Logarithmic Time Complexity
24 Bitwise Operators & Power Of Two
25 Again: Identifying Big O Quickly
26 The Factorial Algorithm
Recursion & Dynamic Programming
27 Module Introduction
28 Recursion in Algorithms
29 Exponential Time Complexity
30 Quadratic Time Complexity vs Exponential Time Complexity
31 What is “Dynamic Programming”?
32 “Dynamic Programming” in Action
33 The “Bottom Up” Approach
Search Algorithms
34 Module Introduction
35 What Search Algorithms Are About
36 Introducing Linear Search
37 Linear Search in Action
38 Linear Search Time Complexity
39 Binary Search in Theory
40 Binary Search in Action
41 Binary Search Time Complexity
42 Recursive Binary Search
43 The Master Theorem
Sorting Algorithms
44 Module Introduction
45 What are Sorting Algorithms About?
46 Bubble Sort – Theory
47 Bubble Sort in Action
48 Bubble Sort Time Complexity
49 Quicksort – Theory
50 Quicksort in Action
51 Quicksort Time Complexity
52 Merge Sort – Theory
53 Merge Sort in Action
54 Merge Sort Time Complexity
55 Summary
Space Complexity
56 Module Introduction
57 Introducing Space Complexity
58 Deriving Space Complexity
59 Factorial Algorithm (Loop) – Space Complexity
60 Factorial Algorithm (Recursive) – Space Complexity
61 Linear Search – Space Complexity
62 Binary Search – Space Complexity
63 Bubble Sort – Space Complexity
64 Quicksort – Space Complexity
65 Merge Sort – Space Complexity
Sets (Array) Algorithms
66 Module Introduction
67 An Introduction to Sets
68 The Cartesian Product Algorithm
69 Cartesian Product – Time Complexity
70 The Cartesian Product Algorithm – Without Limits
71 The Permutations Algorithms
72 Permutations without Repetitions
73 Understanding Permutations
74 Permutations without Repetitions – Big O
75 Permutations WITH Repetitions
More Complex Algorithms & How To Solve Code Problems
76 Module Introduction
77 Solving Problems In A Structured Way
78 Simplifying Problems
79 Practice Makes Perfect!
80 The Knapsack Problem (0/1)
81 A Wrong Approach
82 Approaching the Problem Differently
83 A Working Knapsack Solution
84 An Improved Knapsack Algorithm
85 Greedy vs Dynamic Algorithms
86 A Greedy Knapsack Algorithm
87 A New Problem Solving Plan
88 The Change Making Problem
89 A Greedy Change Making Algorithm
90 A Variation to the Change Making Problem
Roundup & Next Steps
91 Course Roundup
Resolve the captcha to access the links!