# Algorithms For Beginners

(ALGO.AE1) / ISBN : 978-1-64459-539-8## About This Course

The Algorithms For Beginners course helps you explore fundamental algorithmic concepts, such as time complexity, sorting techniques, and recursive problem-solving. With this course you will learn how to design, analyze, and implement efficient algorithms to tackle a wide range of real-world challenges. Additionally, you'll have the skills and confidence to apply algorithmic principles to your own projects, setting you up for success in any coding-centric career or further studies in computer science.

## Get the support you need. Enroll in our Instructor-Led Course.

### Lessons

23+ Lessons | 40+ Exercises | 150+ Quizzes | 116+ Flashcards | 116+ Glossary of terms

### Introduction

- About This Course
- False Assumptions
- Icons Used in This Course
- Where to Go from Here

### Introducing Algorithms

- Describing Algorithms
- Using Computers to Solve Problems
- Distinguishing between Issues and Solutions
- Structuring Data to Obtain a Solution

### Considering Algorithm Design

- Starting to Solve a Problem
- Dividing and Conquering
- Learning that Greed Can Be Good
- Computing Costs and Following Heuristics
- Evaluating Algorithms

### Working with Google Colab

- Defining Google Colab
- Working with Notebooks
- Performing Common Tasks
- Using Hardware Acceleration
- Executing the Code
- Getting Help

### Performing Essential Data Manipulations Using Python

- Performing Calculations Using Vectors and Matrixes
- Creating Combinations the Right Way
- Getting the Desired Results Using Recursion
- Performing Tasks More Quickly

### Developing a Matrix Computation Class

- Avoiding the Use of NumPy
- Understanding Why Using a Class is Important
- Building the Basic Class
- Manipulating the Matrix

### Structuring Data

- Determining the Need for Structure
- Stacking and Piling Data in Order
- Working with Trees
- Representing Relations in a Graph

### Arranging and Searching Data

- Sorting Data Using Merge Sort and Quick Sort
- Using Search Trees and the Heap
- Relying on Hashing

### Understanding Graph Basics

- Explaining the Importance of Networks
- Defining How to Draw a Graph
- Measuring Graph Functionality
- Putting a Graph in Numeric Format

### Reconnecting the Dots

- Traversing a Graph Efficiently
- Sorting the Graph Elements
- Reducing to a Minimum Spanning Tree
- Finding the Shortest Route

### Discovering Graph Secrets

- Envisioning Social Networks as Graphs
- Navigating a Graph

### Getting the Right Web page

- Finding the World in a Search Engine
- Explaining the PageRank Algorithm
- Implementing PageRank
- Going Beyond the PageRank Paradigm

### Managing Big Data

- Transforming Power into Data
- Streaming Flows of Data
- Sketching an Answer from Stream Data

### Parallelizing Operations

- Managing Immense Amounts of Data
- Working Out Algorithms for MapReduce

### Compressing and Concealing Data

- Making Data Smaller
- Hiding Your Secrets with Cryptography

### Working with Greedy Algorithms

- Deciding When It Is Better to Be Greedy
- Finding Out How Greedy Can Be Useful

### Relying on Dynamic Programming

- Explaining Dynamic Programming
- Discovering the Best Dynamic Recipes

### Using Randomized Algorithms

- Defining How Randomization Works
- Putting Randomness into your Logic

### Performing Local Search

- Understanding Local Search
- Presenting Local Search Tricks
- Solving Satisfiability of Boolean Circuits

### Employing Linear Programming

- Using Linear Functions as a Tool
- Using Linear Programming in Practice

### Considering Heuristics

- Differentiating Heuristics
- Routing Robots Using Heuristics
- Explaining Path Finding Algorithms

### Ten Algorithms That Are Changing the World

- Using Sort Routines
- Looking for Things with Search Routines
- Shaking Things Up with Random Numbers
- Performing Data Compression
- Keeping Data Secret
- Changing the Data Domain
- Analyzing Links
- Spotting Data Patterns
- Dealing with Automation and Automatic Responses
- Creating Unique Identifiers

### Ten Algorithmic Problems Yet to Solve

- Solving Problems Quickly
- Solving 3SUM Problems More Efficiently
- Making Matrix Multiplication Faster
- Determining Whether an Application Will End
- Creating and Using One-Way Functions
- Multiplying Really Large Numbers
- Dividing a Resource Equally
- Reducing Edit Distance Calculation Time
- Playing the Parity Game
- Understanding Spatial Issues

### Performing Essential Data Manipulations Using Python

- Performing Logical Operations
- Using Comparison Operators
- Performing Data Manipulations
- Finding the Factorial of a Number Using Recursion

### Developing a Matrix Computation Class

- Using Matrix Operations
- Flattening a Matrix

### Structuring Data

- Dealing with Missing Values
- Removing the Duplicate Records
- Creating and Traversing a Binary Tree

### Arranging and Searching Data

- Implementing Quick Sort
- Implementing Merge Sort
- Building and Searching a Binary Heap

### Understanding Graph Basics

- Implementing a Graph
- Adding a Graph to a Matrix
- Using Sparse Representations

### Reconnecting the Dots

- Creating a Minimum Spanning Tree
- Adding a Negative Edge to a Graph
- Using the Floyd-Warshall Algorithm

### Getting the Right Web page

- Creating a Network with a Spider Trap

### Managing Big Data

- Demonstrating the Bloom Filter

### Parallelizing Operations

- Using the lambda Function
- Setting up a MapReduce Simulation

### Compressing and Concealing Data

- Using Compression
- Using Encryption

### Working with Greedy Algorithms

- Using the change Function

### Relying on Dynamic Programming

- Printing a Fibonacci Sequence Using Recursion
- Using Dynamic Programming

### Using Randomized Algorithms

- Creating a Histogram
- Creating a Monte Carlo Simulation
- Implementing the Quick Select Algorithm
- Computing the Median of a Series

### Employing Linear Programming

- Visualizing Data Using Python Plotting Functions

### Considering Heuristics

- Creating a Maze