## Java Data Structures Algorithms LEETCODE Exercises

### What you’ll learn

<> 99 Coding Exercises with Detailed Explanations

Learn DSA Faster with Animated Examples

Mastery of Data Structures and Algorithms

Confidently Answer Technical Interview Questions

Time and Space Complexity of Data Structures and Algorithms

Strengthen Your Skills as a Developer

### Requirements

Basic programming

No experience with data structures or algorithms required

### Description

Welcome to Data Structures & Algorithms in Java This course makes learning to code fun and makes hard concepts easy to understand. How did I do this? By using animations!Animating the Data Structures & Algorithms makes everything more visually engaging and allows students to learn more material – in less time – with higher retention (a pretty good combination).I will use these visuals to guide you, step-by-step, through the entire course.The course also includes dozens-and-dozens of Coding Exercises. So you can immediately put everything into practice as soon as you learn it (a very important step).All of this will help you to feel more confident and prepared when you walk into a coding interview.I have made several Free Sample Videos available for the course so you can see the difference the animations make.Also, I am very active on the Q&A, so I will be with you every_step_of _the_way._____________________________What you will get in this course…Over 100 hand-crafted animated HD videos to illustrate the Data Structures & Algorithms.Here are the topics we will cover:TechnicalBig O notationData StructuresArraysArray ListsLinked ListsDoubly Linked ListsStacks & QueuesBinary TreesHash TablesHeapsGraphsAlgorithmsSorting Bubble SortSelection SortInsertion SortMerge SortQuick SortSearchingBreadth First SearchDepth First SearchDon’t just take my word for it though, check out what existing students have to say about my courses:5-Star Review:”In order to describe this course accurately, we need the definition of the word Beautiful. beau·ti·ful: adjective 1.- pleasing the senses or mind aesthetically. 2.- of a very high standard; excellent.” – Josue Hernandez Amezcua5-Star Review:”The best course on DSA on Udemy” – Enlai Li5-Star Review:”One of the best courses on DSA. The animations do make a huge impact. All the points are explained in detail. The only problem is that I can’t give it more than a 5-star rating.” – Nikita Sarkar5-Star Review:”Amazing Course. My words cannot describe how much animations helped me to understand the concepts. 100% Recommended.” – Simarjeet Singh5-Star Review:Being a visual learner this is BY FAR the BEST course ever. The way the instructor presents this topic makes it so easy to understand.” – Eduardo SN5-Star Review:”The animations were really helpful for an easy understanding, but the best thing about this course for me is that it will not waste your time! It is perfectly optimized, covers the important topics that I wanted, and at the same time perfectly clear. Thank you so much.” – Fatemeh Moghaddam5-Star Review:”This course is very well done! … the animations in each video take the explanation and understanding of the material to a new level.” – Luis Felipe Posada5-Star Review:”This course has seriously been amazing. The animations have worked wonders for my understanding and I have made significant progress from the beginning of the course until now.” – Dakota Fabro5-Star Review:”I can follow as a beginner, amazing.” – Sabrina Fung5-Star Review:”This is the best course I have ever seen” – Luong Viet TriREMEMBER… I’m so confident that you’ll love this course that we’re offering a FULL money-back guarantee for 30 days! So it’s a complete no-brainer, sign up today with ZERO risk and EVERYTHING to gain.So what are you waiting for? Click the “Buy now” button and join the best Java Data Structures & Algorithms course on Udemy.I look forward to seeing you in the course. Now let’s get started! 🙂

### Overview

Section 1: Introduction

Lecture 1 Introduction

Lecture 2 Overview (Please Watch)

Lecture 3 Code Editor

Section 2: Big O

Lecture 4 Big O: Intro

Lecture 5 Big O: Worst Case

Lecture 6 Big O: O(n)

Lecture 7 Big O: Drop Constants

Lecture 8 Big O: O(n^2)

Lecture 9 Big O: Drop Non-Dominants

Lecture 10 Big O: O(1)

Lecture 11 Big O: O(log n)

Lecture 12 Big O: Different Terms for Inputs

Lecture 13 Big O: Array Lists

Lecture 14 Big O: Wrap Up

Section 3: Classes & Pointers

Lecture 15 Classes

Lecture 16 Pointers

Section 4: Linked Lists

Lecture 17 Linked List: Intro

Lecture 18 LL: Big O

Lecture 19 LL: Under the Hood

Lecture 20 LL: Constructor

Lecture 21 Coding Exercises (Important)

Lecture 22 LL: Print List

Lecture 23 LL: Append

Lecture 24 LL: Remove Last (Intro)

Lecture 25 LL: Remove Last (Code)

Lecture 26 LL: Prepend

Lecture 27 LL: Remove First

Lecture 28 LL: Get

Lecture 29 LL: Set

Lecture 30 LL: Insert

Lecture 31 LL: Remove

Lecture 32 LL: Reverse

Section 5: <> LL: Coding Exercises

Section 6: <> LL: Interview / LeetCode Exercises

Section 7: Doubly Linked Lists

Lecture 33 DLL: Constructor

Lecture 34 DLL: Append

Lecture 35 DLL: Remove Last

Lecture 36 DLL: Prepend

Lecture 37 DLL: Remove First

Lecture 38 DLL: Get

Lecture 39 DLL: Set

Lecture 40 DLL: Insert

Lecture 41 DLL: Remove

Section 8: <> DLL: Coding Exercises

Section 9: <> DLL: Interview / LeetCode Exercises

Section 10: Stacks & Queues

Lecture 42 Stack: Intro

Lecture 43 Stack: Constructor

Lecture 44 Stack: Push

Lecture 45 Stack: Pop

Lecture 46 Queue: Intro

Lecture 47 Queue: Constructor

Lecture 48 Queue: Enqueue

Lecture 49 Queue: Dequeue

Section 11: <> S&Q: Coding Exercises

Section 12: <> S&Q: Interview / LeetCode Exercises

Section 13: Trees

Lecture 50 Trees: Intro & Terminology

Lecture 51 Binary Search Trees: Example

Lecture 52 BST: Big O

Lecture 53 BST: Constructor

Lecture 54 BST: Insert – Intro

Lecture 55 BST: Insert – Code

Lecture 56 BST: Contains – Intro

Lecture 57 BST: Contains – Code

Section 14: <> BST: Coding Exercises

Section 15: Hash Tables

Lecture 58 Hash Table: Intro

Lecture 59 HT: Collisions

Lecture 60 HT: Constructor

Lecture 61 HT: Hash Method

Lecture 62 HT: Set

Lecture 63 HT: Get

Lecture 64 HT: Keys

Lecture 65 HT: Big O

Lecture 66 HT: Interview Question

Section 16: <> HT: Coding Exercises

Section 17: <> HT: Interview / LeetCode Exercises

Lecture 67 Introduction to Sets

Section 18: Graphs

Lecture 68 Graph: Intro

Lecture 69 Graph: Adjacency Matrix

Lecture 70 Graph: Adjacency List

Lecture 71 Graph: Big O

Lecture 72 Graph: Add Vertex

Lecture 73 Graph: Add Edge

Lecture 74 Graph: Remove Edge

Lecture 75 Graph: Remove Vertex

Section 19: <> Graph: Coding Exercises

Section 20: Heaps

Lecture 76 Heap: Intro

Lecture 77 Heap: Insert (Intro)

Lecture 78 Heap: Helper Methods

Lecture 79 Heap: Insert (Code)

Lecture 80 Heap: Remove

Lecture 81 Heap: Sink Down

Lecture 82 Heap: Priority Queues & Big O

Section 21: <> Heap: Coding Exercises

Section 22: <> Heap: Interview / LeetCode Exercises

Section 23: Recursion

Lecture 83 Recursion: Intro

Lecture 84 Call Stack

Lecture 85 Factorial

Section 24: Recursive Binary Search Trees

Lecture 86 rBST: Contains

Lecture 87 rBST: Insert

Lecture 88 rBST: Delete Intro

Lecture 89 rBST: Delete Code (1 of 3)

Lecture 90 rBST: Delete Code (2 of 3)

Lecture 91 rBST: Minimum Value

Lecture 92 rBST: Delete Code (3 of 3)

Section 25: <> rBST: Coding Exercises

Section 26: Tree Traversal

Lecture 93 Tree Traversal: Intro

Lecture 94 BFS (Breadth First Search): Intro

Lecture 95 BFS: Code

Lecture 96 DFS (Depth First Search): PreOrder – Intro

Lecture 97 DFS: PreOrder – Code

Lecture 98 DFS: PostOrder – Intro

Lecture 99 DFS: PostOrder – Code

Lecture 100 DFS: InOrder – Intro

Lecture 101 DFS: InOrder – Code

Section 27: <> BST Traversal: Coding Exercises

Section 28: BST Traversal: <> BST Traversal: Interview / LeetCode Exercises

Section 29: Basic Sorts

Lecture 102 Bubble Sort: Intro

Lecture 103 Bubble Sort: Code

Lecture 104 Selection Sort: Intro

Lecture 105 Selection Sort: Code

Lecture 106 Insertion Sort: Intro

Lecture 107 Insertion Sort: Code

Lecture 108 Insertion Sort: Big O

Section 30: <> Basic Sorts: Coding Exercises

Section 31: <> Basic Sorts: Interview / LeetCode Exercise

Section 32: Merge Sort

Lecture 109 Merge Sort: Overview

Lecture 110 Merge: Intro

Lecture 111 Merge: Code

Lecture 112 Merge Sort: Intro

Lecture 113 Merge Sort: Code

Lecture 114 Merge Sort: Big O

Section 33: <> Merge Sort: Coding Exercises

Section 34: <> Merge: Interview / LeetCode Exercise

Section 35: Quick Sort

Lecture 115 Quick Sort: Intro

Lecture 116 Pivot: Intro

Lecture 117 Pivot: Code

Lecture 118 Quick Sort: Code

Lecture 119 Quick Sort: Big O

Section 36: <> Quick Sort: Coding Exercises

Section 37: <> Array: Interview / LeetCode Exercises

Section 38: Coding Exercises

Lecture 120 Coding Exercises Have Moved! – (CLICK HERE)

Java programmers preparing for an interview,University students taking a data structures and algorithms course,Any self taught programmer who missed out on a computer science degree

#### Course Information:

Udemy | English | 9h 7m | 1.80 GB

Created by: Scott Barrett

You Can See More Courses in the Developer >> Greetings from CourseDown.com