Data Structures And Algorithms Cplusplus For Interviews

Covers Algorithmic Problems in C++ That range a variety of data structures which often pop up during a coding interview.

Last updated 2022-01-10 | 4.5

- Solve Easy to Medium Difficulty problems that address different data strutures
- Have an understanding of how to systematically approach coding problems in a step by step manner

What you'll learn

Solve Easy to Medium Difficulty problems that address different data strutures
Have an understanding of how to systematically approach coding problems in a step by step manner

* Requirements

* C++ Beginner to Intermediate Level (Loops/If Statements/Templates)
* Basic Understanding of BIg Oh Notation (What does O(n) mean
* what does O(nlogn) mean
* etc)
* Very Basic Understanding of Recursion (Factorial example suffices)

Description

Welcome to Data Structures and Algorithms in C++ For Coding Interview!

This is the most comprehensive online course to help you with your coding interviews and solving algorithmic problems with Data Structures! This course utilizes C++'s strong standard library to efficiently teach you what you need to know to solve basic algorithmic and data structures interview problems in the coding interview!

This course will teach you everything you need to know about utilizing data structures in your algorithms. We discuss data structures and algorithmic techniques such as:

  • Array/Strings Sequences

  • Stacks

  • Recursion

  • Hash Maps

  • Binary Trees

  • Searching and Sorting Algorithms

  • Heaps

  • Several Assignments to solidify your understanding

PLEASE NOTE: 

If You're a complete beginner to C++, this course is not for you. Please make sure you satisfy the requirements before joining the course.

Who this course is for:

  • Any one interested in learning more about Data Structures and Algorithms
  • Any one who wants to know how to implement solutions to algorithmic problems in C++ using data structures
  • Any one who is preparing for a coding interview
  • Any one who is thinking to become a software engineer and interviewing with Large companies

Course content

19 sections • 71 lectures

Introduction to Course Preview 03:44

What is LeetCode, and How will we use it? Preview 00:22

Two Sum problem Statement and O(n^2) Solution Preview 08:03

Implementation of O(n^2) naive solution Preview 03:11

Optimizing Further for O(nlogn) Solution Preview 11:06

Implementing the O(nlogn) Solution Preview 10:12

Problem Statement Preview 01:40

O(n^2) Naive Solution Preview 06:42

O(n^2) Naive Solution Implementation Preview 05:09

O(n) Solution idea and optimizations Preview 09:13

O(n) Solution Implementation Preview 04:57

Problem Statement Preview 02:18

O(n^3) Naive Solution Preview 06:13

O(nlogn) Improved Solution Preview 08:28

Implementation of O(nlogn) solution Preview 05:35

Optimizing further and reaching O(n) Solution Preview 14:06

Implementation of O(n) Solution Preview 08:14

Problem Statement Preview 03:08

Incorrect Approaches/Algorithms to the Problem Preview 05:35

Recursive Algorithm Solution That runs in O(n^2) Time Preview 17:50

Implementation of O(n^2) Recursive Algorithm Preview 05:00

Optimizing further With Stacks to get O(n) Solution Idea Preview 11:39

O(n) Solution Implementation Preview 09:58

Problem Statement and Example Preview 05:30

Naive O(n^2) Solution with additional boolean array Preview 12:53

Implementation of O(n^2) Solution Preview 15:55

Optimizing on the last algorithm to an O(n) Solution Preview 11:45

Implementation of O(n) Solution Preview 06:37

Problem Statement Preview 03:39

Bruteforce Algorithm Idea: O(nk) Solution Preview 08:33

Bruteforce Implementation and Time Limit Exceeded Preview 04:36

Optimizing Using Hashmaps to get O(n) Solution on average Preview 13:45

Implementing the O(n) Solution Preview 04:32

Problem Statement Preview 04:28

O(n!) Brute force Solution Preview 05:38

O(n^2) Solution idea for Valid anagram Preview 11:40

O(n^2) Solution Implementation Preview 07:26

O(nlogn) Solution by Optimizing bottleneck Preview 05:39

O(nlogn) Solution Implementation Preview 03:22

O(n) Solution Idea, The final optimization with Hashtable Preview 08:11

O(n) Solution Implementation Preview 09:14

Problem Statement Preview 01:26

O(nlogn) Naive Solution Idea Preview 05:18

O(nlogn) Naive Solution Implementation Preview 02:00

O(nlogk) Optimized Solution Using a Heap Preview 12:51

Implementation of O(nlogk) Heap Solution Preview 03:06

Problem Statement Preview 02:23

Idea of O(n^2Logn) Naive Solution and O(n^2logk) Optimized Solution using Heap Preview 14:49

Implementation of O(n^2Logn) and O(n^2Logk) Solutions Preview 19:06

Problem Statement Preview 02:00

O(n) Recursive Solution Idea Preview 12:14

O(n) Solution implementation Preview 02:10

Problem Statement Preview 01:43

O(n) Recursive Solution Idea Preview 06:55

O(n) Solution Implementation Preview 04:19

Problem Statement Preview 02:00

O(n) Recursive Solution Idea Preview 07:46

O(n) Solution Implementation Preview 02:46

Arrays and Strings Data Structure Assignment 1

This is an Assignment for the Problem Three Sum

Arrays and Strings Data Structure Assignment 2

Solve the problem (https://leetcode.com/problems/valid-palindrome/description/). Can you come up with a O(n) Solution using a similar method we used in the lecture videos?

Stack Data Structure Assignment 1

Solve the problem Next Greater Element (https://leetcode.com/problems/next-greater-element-i/description/) using a Stack.

Hash Table Assignment 1

Solve the Problem Distributing Candies

Heaps Assignment 1

Solve the problem Kth Smallest Element in a Sorted Matrix (https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/description/)

Binary Trees Assignment 1

Solve the Problem sum of left leaves (https://leetcode.com/problems/sum-of-left-leaves/description/)

Binary Trees Assignment 2

Solve the problem symmetric trees (https://leetcode.com/problems/symmetric-tree/description/) recursively.

Binary Trees Assignment 3

Solve the Problem count complete tree nodes (https://leetcode.com/problems/count-complete-tree-nodes/description/) recursively in linear time