• Post category:StudyBullet-16
  • Reading time:14 mins read


Data Structures and Algorithms in Java | Leetcode + Video Solutions | Animated Explanation | Ace Coding Inteviews

What you will learn

Understand Data Structures and Algorithms & How to Implement and Use them in Java

Understand Big O Notation and How to Calculate Space & Time Complexities

Improve your Problem Solving Skills

Enhance your Programming Skills

Leetcode Challenges with Video Solutions

Understand How to Decide When to Use a Specific Algorithm or Data Structure for Different Use Cases

Ace Coding Interviews

Description

Welcome to the Data Structures and Algorithms in Java Course!

Are you a Java programmer who wants to write efficient code and improve your programming and problem solving skills ?

Do you have an upcoming coding interview and you want to ace it with confidence ?

If the answer is yes, then this course is the right choice for you!

In this course you will learn everything about Data Structures and Algorithms and how to implement and use them in Java.

The concepts are explained with animations which makes it much more easier to understand and memorize.

You will also apply your knowledge throughout the course via coding exercises and Leetcode coding challenges with video solutions.


Get Instant Notification of New Courses on our Telegram channel.


The course covers the following topics:

General

  • Why Should You Learn Data Structures and Algorithms ?
  • What are Data Structures ?
  • What are Algorithms ?

Big O Notation

  • Linear Complexity – O(n)
  • Constant Complexity – O(1)
  • Quadratic Complexity – O(n^2)
  • Logarithmic Complexity – O(logn)
  • Constants in Big O
  • Dominant and Non-Dominant Factors in Big O
  • Complexities Comparison

Data Structures

  • Linked Lists
  • Doubly Linked Lists
  • Stacks
  • Queues
  • Sets
  • Trees
  • Tries
  • Heaps
  • Hash Tables
  • Graphs

Algorithms

  • Linear Search
  • Binary Search
  • Bubble Sort
  • Insertion Sort
  • Selection Sort
  • Merge Sort
  • Recursion
  • Tree Traversal
  • Graph Traversal

I’m confident that you will enjoy this course, but if you for some reason are not happy with the course it’s backed by Udemy’s 30 day money back guarantee, so nothing to lose!

I’m excited to see you in the course, hit that enroll button and start your mastering Data Structures & Algorithms journey 🙂

English
language

Content

Introduction

Why Should You Learn Data Structures and Algorithms ?
What are Data Structures ?
What are Algorithms ?

Big O Notation

Introduction to Big O Notation
Linear Complexity – O(n)
Constant Complexity – O(1)
Quadratic Complexity – O(n^2)
Logarithmic Complexity – O(logn)
Constants in Big O
Dominant and Non-Dominant Factors in Big O
Complexities Comparison

Big O Notation: Practical

Big O Notation’s Quiz
Big O Calculation

Linked Lists

Introduction to Linked Lists
Linked List Class Implementation
Linked List: Add Element
Linked List: Append Implementation
Linked List: Prepend Implementation
Linked List: Iterating
Linked List: Iterating Implementation
Linked List: Removing Elements
Linked List: Removing Elements Implementation
Time Complexity of Linked Lists Operations
When to Use Linked Lists

Linked Lists: Practical

Linked List’s Quiz
Append/Prepend Implementation
Leetcode Challenge – Reverse Linked List
(Solution) Leetcode Challenge – Reverse Linked List

Stacks

Introduction to Stacks
Stack Implementation: Stack and Node Classes
Stack Implementation: Push
Stack Implementation: Pop & isEmpty

Stacks: Practical

Stack’s Quiz
Stack Implementation
Leetcode Challenge – Valid Parentheses
(Solution) Leetcode Challenge – Valid Parentheses

Queues

Introduction to Queues
Queue Implementation: Queue and Node Classes
Queue Implementation: Enqueue
Queue Imeplementation: Dequeue

Queues: Practical

Queue’s Quiz
Queue Implementation
Leetcode Challenge – Implement Queue using Stacks
(Solution) Leetcode Challenge – Implement Queue using Stacks

Sets

Introduction to Sets
Creating and Initializing Sets
Set’s Methods and Operations
Sets Big O

Sets Practical

Set’s Quiz
Remove Duplicates

Trees

Introduction to Trees
Binary Trees
Complete Binary Trees
Binary Search Trees
Binary Search Trees: Insert Operation
Binary Search Trees: Class Implementation
Binary Search Trees: Insert Operation Implementation
Binary Search Trees: Search Operation Implementation

Trees: Practical

Tree’s Quiz
Tree Insert/Search Implementation
Leetcode Challenge – Search in a Binary Search Tree
(Solution) Leetcode Challenge – Search in a Binary Search Tree

Heaps

Introduction to Heaps
Heaps: Insert
Heaps: Pop
Heap Implementation: Class and Helper Functions
Heap Implementation: insert()
Heap Implementation: remove()
Heap Implementation: Heapify Down
Heap Operations Time Complexities

Heaps: Practical

Heap’s Quiz
MaxHeap Insert Implementation
Leetcode Challenge – Kth Largest Element in a Stream
(Solution) Leetcode Challenge – Kth Largest Element in a Stream

Hash Tables

Introduction to Hash Tables
HashMap Class in Java
Hash Tables Time & Space Complexities

Hash Tables: Practical

Hash Table’s Quiz
Leetcode Challenge – Two Sum
(Solution) Leetcode Challenge – Two Sum

Graphs

Introduction to Graphs
Graphs: Adjacency Matrix
Graphs: Adjacency List
Graph Implementation
Graph Time & Space Complexities

Graphs: Practical

Graph’s Quiz
Undircted Graph Implementation

Tries

Introduction to Tries
Trie Operations: Insert
Trie Operations: Search
Trie Implementation: Class
Trie Implementation: Insert
Trie Implementation: Search
Trie Big O

Tries: Practical

Trie’s Quiz
Trie Implementation

Searching Algorithms

Linear Search
Linear Search Implementation
Binary Search
Binary Search Implementation
Searching Algorithms Big O

Searching Algorithms: Practical

Searching Algorithms Quiz
Linear Search
Binary Search

Sorting Algorithms

Bubble Sort
Bubble Sort Implementation
Insertion Sort
Insertion Sort Implementation
Selection Sort
Selection Sort Implementation
Merge Sort
Merge Sort Implementation
Sorting Algorithms Big O

Sorting Algorithms: Practical

Sorting Algorithms Quiz
Bubble Sort
Insertion Sort

Recursion

Introduction to Recursion
Call Stack
Recursion Example: Factorial
Recursion Big O
Stack Overflow

Recursion: Practical

Recursion’s Quiz
Factorial

Tree Traversal

Introduction to Tree Traversal
Inorder
Inorder Implementation
Preorder
Preorder Implementation
Postorder
Postorder Implementation
Tree Traversal Big O

Tree Traversal: Practical

Tree Traversal Quiz
Tree Traversal Implementation

Graph Traversal

Introduction to Graph Traversal
BFS
BFS Implementation
DFS
DFS Implementation
Graph Traversal Big O

Graph Traversal: Practical

Graph Traversal Quiz
BFS

Conclusion

Final Thoughts