Big O Notation for Algorithms in plain English from Udemy

Angela Belfort, CEO of Firma Logistics strode into the meeting room quietly enraged. The way CEOs are enraged, composed and at the same time fuming. She is followed by her entourage. All the important people that make all the decisions. You’ve been at the company for just over a year and you’re not quite sure how you ended up in this room.

Her assistant had already set the room projector showing the live feed of the company’s fleet, over 4000 lorries scattered all over the country. Each vehicle was shown as a dot, colored red as stationary, green as moving. Almost all of them were red.

“What the hell is going on? I have lorry drivers complaining to unions because we aren’t able to give them a delivery schedule. I have furious suppliers on the lines asking for updates on their packages. We’ve got competitors circling over our clients like vultures. Can someone explain to me what is happening?”, Angela started.

Everyone was expecting an answer from the CTO, Brian Holms. Technically, on the huge org chart, he is your manager somewhere along the path from your position to the top, but it sure is a long way. He replies with “Er… em… We seem to be having some IT issues. I brought Alex here with me as she seems to have found a bug in the system”.

The focus is now completely on you. Hey, this might be the day you get fired after all… “It’s not really a bug. A section of the current scheduling algorithm has a quadratic runtime complexity with respect to the number of routes”.

The room looks at you as if you said the moon was made out of cheese. The big wigs turn their heads back to Brian for an explanation, but he seems as lost as they are. Instead he nervously nods, encouraging you to go on.

“Ok. Remember Paul Zimmer? Our ex-tech lead guy? Well it turns out that some of his old code does not scale well. It was fine while we had a few hundred lorries, but now that the company has grown so much the scheduling program is not able to keep up with the load. Especially on busy days like today. We have not really invested in keeping the code with the latest technologies and now nobody knows how it really works.” This is literally the most dumbed down version you can think of.

Angela jumps in “Where is this Paul?”

“He retired about a year ago. Rumor has it he opened an American diner in Hong Kong.”, replies Brian.

Angela’s composure is all gone now. “Can we fix the damn thing?”, she shouts.

“Well it’s very old code, nobody really understands how it works and we have been trying to reach Paul but if he’s in a different country… ”, puts in Brian but is interrupted by you.

“I already have a working linear solution. By linear I mean it will scale fine with our needs. I just need to run some further testing and then we can probably release it.”

Brian is visibly shocked. Everyone else is kind of confused, not completely sure what is going on. Angela is the only one with a grin.

Understanding the basics of Big O notation and being able to "read" how much an algorithm can scale is a must for all serious developers. This extra skill gives you the edge to take your career forward, to distinguish yourself from the rest of the crowd and get ahead. It helps you pass difficult coding interviews to get hired from some of the best tech companies.

The code in this course is in Python however if you have experience from any other major programming language (such as Java, C#, JavaScript, Ruby etc...) you'll be ok with the code in the course as it's designed to be easy to grasp.

All code in this course can be found on github, username/project: cutajarj/BigONotationInPlainEnglish

So don't be a Brian, sign up to the course and learn something new today.

What's inside

Learning objectives

Learn what the big o notation is about
Look at an algorithm and classify it according to their big o complexity
Identify and write more performant code and algorithms in your work as a software developer

Acquire the extra knowledge to help you pass more coding interviews
Exponential o(c^n), quadratic o(n^2), linear o(n), log linear o(n log n), logarithmic o(log n) and constant o(1) complexity functional classes
Introduction to complexity theory

Learn what the big o notation is about
Look at an algorithm and classify it according to their big o complexity
Identify and write more performant code and algorithms in your work as a software developer
Acquire the extra knowledge to help you pass more coding interviews
Exponential o(c^n), quadratic o(n^2), linear o(n), log linear o(n log n), logarithmic o(log n) and constant o(1) complexity functional classes
Introduction to complexity theory

Syllabus

Introduction

Introduction Big O Notation Part 1

Cracking an A to Z padlock

Introduction Big O Notation Part 2

Traffic lights

Read about what's good

what should give you pause

and possible dealbreakers

Helps developers identify and write more performant code, which is essential for building scalable and efficient applications in real-world scenarios

Provides the knowledge to help learners pass coding interviews, which is a critical step in securing positions at top tech companies

Explores various complexity classes, including exponential, quadratic, linear, log-linear, logarithmic, and constant, which are fundamental concepts in algorithm analysis

Uses Python for code examples, but the course is designed to be easily grasped by those with experience in other major programming languages

Covers practical algorithms like finding the minimum, string equals, closest points brute force, and binary search, which are commonly used in software development

Requires learners to have access to Github, where all the code in this course can be found, which may require creating an account

Reviews summary

Clear, plain english big o introduction

According to students, this course offers a highly effective introduction to Big O notation, particularly praised for its "plain English" approach that makes complex concepts understandable. Learners highlight its usefulness for building a solid foundation and its relevance for coding interviews. The course employs practical examples and the code demonstrations, primarily in Python, are found to be easy to follow even for those using other languages. While widely appreciated by beginners and those needing a refresher, a few reviewers note it might be too basic for experienced developers seeking deep dives into advanced optimization techniques.

Solid introduction, but potentially basic.

"Good course, covers the basics well... Might be a bit simple for experienced developers."

"Okay course. The explanations are simple, perhaps too simple at times. Didn't go into as much depth as I hoped..."

"A bit too basic for me. I was looking for more advanced topics..."

"Suitable only for absolute beginners."

Uses relatable examples and clear code.

"...and the examples are very clear. Helped me understand scalability much better..."

"The analogy at the beginning is helpful. The Python code examples are easy to follow..."

"The examples illustrating O(n^2) vs O(n) were particularly insightful."

"Covers the main complexity types with understandable examples. The Python isn't a barrier."

Helps prepare for coding interview questions.

"Great for interview prep. Highly recommend for anyone new to the topic."

"Useful for getting a grasp on algorithm efficiency."

"Helped me review concepts for upcoming interviews."

"Acquire the extra knowledge to help you pass more coding interviews"

Complex Big O concepts explained simply.

"Absolutely brilliant! Finally, Big O notation makes sense. The plain English approach really works..."

"Excellent explanation! I struggled with Big O before, but this course simplified it completely."

"Loved the plain English style. It broke down complex concepts into understandable chunks."

"Very clear and concise. The different complexity classes were explained well..."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Big O Notation for Algorithms in plain English with these activities:

Review Data Structures and Algorithms Fundamentals

Show steps

Solidify your understanding of fundamental data structures and algorithms to better grasp the concepts of Big O notation.

Show steps

Review common data structures like arrays, linked lists, and trees.
Practice implementing basic algorithms such as searching and sorting.
Familiarize yourself with time and space complexity analysis.

Review 'Grokking Algorithms'

Show steps

Gain a more intuitive understanding of algorithms and their complexities through visual explanations.

View Grokking Algorithms, Second Edition on Amazon

Show steps

Read the chapters related to Big O notation and common algorithms.
Work through the examples and exercises in the book.
Compare the book's explanations with the course material.

LeetCode Easy Problems on Time Complexity

Show steps

Reinforce your understanding of Big O notation by solving practical coding problems.

Show steps

Select a set of LeetCode easy problems focused on time complexity.
Analyze the time complexity of your solutions.
Compare your solutions with the optimal solutions.

Four other activities

Expand to see all activities and additional details

Show all seven activities

Create a Big O Notation Cheat Sheet

Show steps

Solidify your knowledge by summarizing the different Big O complexities and their characteristics.

Show steps

List the common Big O complexities (O(1), O(log n), O(n), O(n log n), O(n^2), O(2^n)).
Provide examples of algorithms that fall into each complexity class.
Include a brief explanation of the scalability implications of each complexity.

Implement a Scalable Scheduling Algorithm

Show steps

Apply your knowledge of Big O notation to design and implement a scheduling algorithm that scales efficiently.

Show steps

Define the requirements for the scheduling algorithm.
Design an algorithm with a specific time complexity (e.g., O(n log n)).
Implement the algorithm in Python or another language.
Test the algorithm with different input sizes to verify its scalability.

Review 'Introduction to Algorithms' (CLRS)

Show steps

Deepen your understanding of the theoretical foundations of Big O notation and algorithm analysis.

View Introduction to Algorithms, fourth edition on Amazon

Show steps

Read the chapters on algorithm analysis and asymptotic notation.
Work through the mathematical proofs and exercises.
Compare the book's treatment with the course material.

Help Others on Big O Notation

Show steps

Reinforce your understanding by explaining Big O notation to others.

Show steps

Answer questions about Big O notation on online forums.
Tutor other students who are struggling with the concepts.
Lead a study group to discuss Big O notation and algorithm analysis.

Career center

Learners who complete Big O Notation for Algorithms in plain English will develop knowledge and skills that may be useful to these careers:

Algorithm Developer

An algorithm developer designs and implements algorithms for various applications. This course on Big O Notation for Algorithms in plain English is very useful for any algorithm developer. The course is designed to equip developers with the ability to classify algorithms based on their Big O complexity. An algorithm developer can apply that knowledge to write more performant code. The course's emphasis on scalability directly relates to the core responsibilities of an algorithm developer, ensuring that the algorithms they create can handle increasing data volumes effectively. The course's syllabus covering Exponential, Quadratic, Linear, and Logarithmic Complexity Functional Classes is relevant for professionals in this field.

See salaries and explore the career path for Algorithm Developer

Performance Engineer

A performance engineer analyzes and optimizes software systems to improve their performance and scalability. This course on Big O Notation for Algorithms in plain English is designed to benefit a performance engineer. Big O notation is essential for understanding how algorithms scale with increasing input sizes. The course helps performance engineers identify and address performance bottlenecks in software systems. The course's focus on understanding scalability and identifying more performant code directly aligns with the core responsibilities of a performance engineer. The course's treatment of Exponential, Quadratic, Linear, and Logarithmic Complexity Functional Classes can be helpful.

See salaries and explore the career path for Performance Engineer

Software Architect

A software architect designs high level software solutions. This course on Big O Notation for Algorithms in plain English is applicable to the work that a software architect does. Understanding Big O notation helps them to design efficient algorithms. The course's focus on identifying and writing more performant code directly supports the software architect's ability to create efficient solutions. Furthermore, knowledge of complexity classes such as Quadratic O(n^2), Linear O(n), and Logarithmic O(Log n) can provide insights when designing algorithms.

See salaries and explore the career path for Software Architect

Software Engineer

A software engineer designs, develops, and tests software applications. This course on Big O Notation for Algorithms in plain English may be useful for software engineers who want to write efficient and scalable code. Understanding Big O notation helps to analyze the performance of algorithms and choose the most appropriate algorithms for specific tasks. The course's focus on identifying and writing more performant code directly supports the software engineer's ability to create efficient solutions. Furthermore, knowledge of complexity classes such as Quadratic O(n^2), Linear O(n), and Logarithmic O(Log n) can aid a software engineer in optimizing existing systems.

See salaries and explore the career path for Software Engineer

Backend Developer

A backend developer works on the server side of web applications, handling data storage, processing, and API development. This course on Big O Notation for Algorithms in plain English should prove useful for backend developers. Understanding Big O notation helps them write efficient code that can handle large volumes of data and traffic. The course helps backend developers make informed decisions about algorithm selection and optimization. The course's coverage of Exponential, Quadratic, Linear, and Logarithmic Complexity Functional Classes can prove relevant to a backend developer's work. The course's syllabus covering scalabililty might also be valuable.

See salaries and explore the career path for Backend Developer

Machine Learning Engineer

A machine learning engineer develops and deploys machine learning models. This course on Big O Notation for Algorithms in plain English may be useful for machine learning engineers. Understanding Big O notation helps them choose efficient algorithms and optimize model training and prediction. The course's emphasis on scalability and identifying more performant code is relevant for machine learning engineers who need to handle large datasets and complex models. In particular, the course's discussion of Exponential, Quadratic, Linear, and Logarithmic Complexity Functional Classes helps them make the best choice of algorithm.

See salaries and explore the career path for Machine Learning Engineer

Full-Stack Developer

A full stack developer works on both the front end and back end of web applications. This course on Big O Notation for Algorithms in plain English may be useful for a full stack developer. Understanding Big O notation helps them write efficient code for both the client side and server side of applications. The course's emphasis on scalability and identifying more performant code is relevant for a full stack developer who needs to optimize the performance of entire applications. Understanding the code's performance also helps with coding interviews. The course's discussion of Exponential, Quadratic, Linear, and Logarithmic Complexity Functional Classes can prove relevant.

See salaries and explore the career path for Full-Stack Developer

Data Engineer

A data engineer builds and maintains the infrastructure for data storage and processing. This course on Big O Notation for Algorithms in plain English may be useful for data engineers. Understanding Big O notation helps them design efficient data pipelines and optimize data processing algorithms. The course's emphasis on scalability and identifying more performant code is directly applicable to a data engineer's work, who have a need to handle large datasets. The course's discussion of Exponential, Quadratic, Linear, and Logarithmic Complexity Functional Classes can prove valuable.

See salaries and explore the career path for Data Engineer

Data Scientist

A data scientist analyzes large datasets to extract meaningful insights and develop data driven solutions. This course may be useful for data scientists who work with algorithms that process large amounts of data. Big O notation becomes crucial when optimizing data processing pipelines and machine learning models. By learning about algorithmic complexity, a data scientist can select algorithms that scale efficiently. The course's coverage of complexity theory and practical examples related to algorithmic performance can enhance a data scientist's ability to build scalable and efficient solutions. The examination of algorithms with Exponential, Quadratic, and Linear complexity may also be relevant.

See salaries and explore the career path for Data Scientist

Cloud Architect

A cloud architect designs and implements cloud computing solutions. This course on Big O Notation for Algorithms in plain English may be useful for cloud architects. Understanding Big O notation helps them optimize the performance of cloud based applications and services. The course's emphasis on scalability and identifying more performant code is directly applicable to a cloud architect's work. They typically need to handle large datasets and complex systems. The course's discussion of Exponential, Quadratic, Linear, and Logarithmic Complexity Functional Classes can be helpful.

See salaries and explore the career path for Cloud Architect

System Architect

A system architect designs the overall structure of software systems, ensuring that they are scalable, reliable, and maintainable. This course on Big O Notation for Algorithms in plain English may be useful for system architects who need to make informed decisions about the performance characteristics of different architectural components. Understanding Big O notation helps in evaluating the scalability of different design choices and identifying potential performance bottlenecks. The course's emphasis on scalability and identifying more performant code directly supports the system architect's ability to design efficient and scalable systems. The course's treatment of Exponential, Quadratic, Linear, and Logarithmic Complexity Functional Classes can be helpful.

See salaries and explore the career path for System Architect

Technical Lead

A technical lead guides and mentors a team of software developers, ensuring that projects are completed successfully. This course may be useful for technical leads who need to evaluate the performance and scalability of code written by their team. Understanding Big O notation helps them assess the efficiency of different algorithms and identify potential performance issues. The course's emphasis on understanding scalability and identifying more performant code directly benefits a technical lead's ability to guide their team toward writing efficient and maintainable code. Furthermore, the course can aid problem solving.

See salaries and explore the career path for Technical Lead

Technology Consultant

A technology consultant advises businesses on how to use technology to meet their goals. This course on Big O Notation for Algorithms in plain English may be useful for technology consultants. Understanding Big O notation helps them evaluate the performance of different software systems and recommend solutions that meet their clients' needs. The course's emphasis on scalability and identifying more performant code supports a technology consultant's ability to assess the efficiency of different technology solutions. Also, acquiring the extra knowledge to help you pass coding interviews would prove useful.

See salaries and explore the career path for Technology Consultant

Database Administrator

A database administrator manages and maintains databases, ensuring data integrity and accessibility. This course may be useful for database administrators, especially when optimizing database queries and performance. An understanding of Big O notation helps in evaluating the efficiency of different query strategies and identifying potential bottlenecks. The course's emphasis on understanding scalability and identifying more performant code directly addresses the database administrator's need to maintain efficient database operations. Knowledge of algorithms with Exponential, Quadratic, and Linear complexity may assist optimization efforts.

See salaries and explore the career path for Database Administrator

Quality Assurance Engineer

A quality assurance engineer tests software to identify defects and ensure that it meets quality standards. This course may be useful for quality assurance engineers who need to assess the performance and scalability of software. Big O notation helps in designing effective performance tests and identifying potential bottlenecks. The course's emphasis on understanding scalability and identifying more performant code directly supports a quality assurance engineer's ability to evaluate the performance characteristics of software. The course's coverage of Exponential, Quadratic, Linear, and Logarithmic Complexity Functional Classes may be helpful in test design.

See salaries and explore the career path for Quality Assurance Engineer

Big O Notation for Algorithms in plain English

What's inside

Learning objectives

Syllabus

Traffic lights

Save this course

Reviews summary

Clear, plain english big o introduction

Activities

Career center

Reading list

Share

Similar courses