Java Data Structures & Algorithms: Ace Coding Interviews!

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

What you'll 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

Requirements

Basic Java programming

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.The course covers the following topics:GeneralWhy Should You Learn Data Structures and Algorithms ?What are Data Structures ?What are Algorithms ?Big O NotationLinear Complexity - O(n)Constant Complexity - O(1)Quadratic Complexity - O(n^2)Logarithmic Complexity - O(logn)Constants in Big ODominant and Non-Dominant Factors in Big OComplexities ComparisonData StructuresLinked ListsDoubly Linked ListsStacksQueuesSetsTreesTriesHeapsHash TablesGraphsAlgorithmsLinear SearchBinary SearchBubble SortInsertion SortSelection SortMerge SortRecursionTree TraversalGraph TraversalI'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 :)

Overview

Section 1: Introduction

Lecture 1 Why Should You Learn Data Structures and Algorithms ?

Lecture 2 What are Data Structures ?

Lecture 3 What are Algorithms ?

Section 2: Big O Notation

Lecture 4 Introduction to Big O Notation

Lecture 5 Linear Complexity - O(n)

Lecture 6 Constant Complexity - O(1)

Lecture 7 Quadratic Complexity - O(n^2)

Lecture 8 Logarithmic Complexity - O(logn)

Lecture 9 Constants in Big O

Lecture 10 Dominant and Non-Dominant Factors in Big O

Lecture 11 Complexities Comparison

Section 3: Big O Notation: Practical

Section 4: Linked Lists

Lecture 12 Introduction to Linked Lists

Lecture 13 Linked List Class Implementation

Lecture 14 Linked List: Add Element

Lecture 15 Linked List: Append Implementation

Lecture 16 Linked List: Prepend Implementation

Lecture 17 Linked List: Iterating

Lecture 18 Linked List: Iterating Implementation

Lecture 19 Linked List: Removing Elements

Lecture 20 Linked List: Removing Elements Implementation

Lecture 21 Time Complexity of Linked Lists Operations

Lecture 22 When to Use Linked Lists

Section 5: Linked Lists: Practical

Section 6: Stacks

Lecture 23 Introduction to Stacks

Lecture 24 Stack Implementation: Stack and Node Classes

Lecture 25 Stack Implementation: Push

Lecture 26 Stack Implementation: Pop & isEmpty

Section 7: Stacks: Practical

Section 8: Queues

Lecture 27 Introduction to Queues

Lecture 28 Queue Implementation: Queue and Node Classes

Lecture 29 Queue Implementation: Enqueue

Lecture 30 Queue Imeplementation: Dequeue

Section 9: Queues: Practical

Section 10: Sets

Lecture 31 Introduction to Sets

Lecture 32 Creating and Initializing Sets

Lecture 33 Set's Methods and Operations

Lecture 34 Sets Big O

Section 11: Sets Practical

Section 12: Trees

Lecture 35 Introduction to Trees

Lecture 36 Binary Trees

Lecture 37 Complete Binary Trees

Lecture 38 Binary Search Trees

Lecture 39 Binary Search Trees: Insert Operation

Lecture 40 Binary Search Trees: Class Implementation

Lecture 41 Binary Search Trees: Insert Operation Implementation

Lecture 42 Binary Search Trees: Search Operation Implementation

Section 13: Trees: Practical

Section 14: Heaps

Lecture 43 Introduction to Heaps

Lecture 44 Heaps: Insert

Lecture 45 Heaps: Pop

Lecture 46 Heap Implementation: Class and Helper Functions

Lecture 47 Heap Implementation: insert()

Lecture 48 Heap Implementation: remove()

Lecture 49 Heap Implementation: Heapify Down

Lecture 50 Heap Operations Time Complexities

Section 15: Heaps: Practical

Section 16: Hash Tables

Lecture 51 Introduction to Hash Tables

Lecture 52 HashMap Class

Lecture 53 Hash Tables Time & Space Complexities

Section 17: Hash Tables: Practical

Section 18: Graphs

Lecture 54 Introduction to Graphs

Lecture 55 Graphs: Adjacency Matrix

Lecture 56 Graphs: Adjacency List

Lecture 57 Graph Implementation

Lecture 58 Graph Time & Space Complexities

Section 19: Graphs: Practical

Section 20: Tries

Lecture 59 Introduction to Tries

Lecture 60 Trie Operations: Insert

Lecture 61 Trie Operations: Search

Lecture 62 Trie Implementation: Class

Lecture 63 Trie Implementation: Insert

Lecture 64 Trie Implementation: Search

Lecture 65 Trie Big O

Section 21: Tries: Practical

Section 22: Searching Algorithms

Lecture 66 Linear Search

Lecture 67 Linear Search Implementation

Lecture 68 Binary Search

Lecture 69 Binary Search Implementation

Lecture 70 Searching Algorithms Big O

Section 23: Searching Algorithms: Practical

Section 24: Sorting Algorithms

Lecture 71 Bubble Sort

Lecture 72 Bubble Sort Implementation

Lecture 73 Insertion Sort

Lecture 74 Insertion Sort Implementation

Lecture 75 Selection Sort

Lecture 76 Selection Sort Implementation

Lecture 77 Merge Sort

Lecture 78 Merge Sort Implementation

Lecture 79 Sorting Algorithms Big O

Section 25: Sorting Algorithms: Practical

Section 26: Recursion

Lecture 80 Introduction to Recursion

Lecture 81 Call Stack

Lecture 82 Recursion Example: Factorial

Lecture 83 Recursion Big O

Lecture 84 Stack Overflow

Section 27: Recursion: Practical

Section 28: Tree Traversal

Lecture 85 Introduction to Tree Traversal

Lecture 86 Inorder

Lecture 87 Inorder Implementation

Lecture 88 Preorder

Lecture 89 Preorder Implementation

Lecture 90 Postorder

Lecture 91 Postorder Implementation

Lecture 92 Tree Traversal Big O

Section 29: Tree Traversal: Practical

Section 30: Graph Traversal

Lecture 93 Introduction to Graph Traversal

Lecture 94 BFS

Lecture 95 BFS Implementation

Lecture 96 DFS

Lecture 97 DFS Implementation

Lecture 98 Graph Traversal Big O

Section 31: Graph Traversal: Practical

Section 32: Conclusion

Lecture 99 Final Thoughts

Java Programmers Who Want to Master Data Structures and Algorithms,Java Programmers Preparing for Coding Interviews,Java Programmers Who Want to Write More Efficient Code and Improve Their Problem-Solving Skills