Data Structures And Algorithms In Java - Hands On!

Algorithms and data strucutres + implementation in java | Time complexity and space complexity | Leetcode examples

What you'll learn

Understand, implement and use different type of data structures

Be able to decide which data structure can be used for solving a problem or optimising an application

Understand, implement and use different type of algorithms

How to solve coding problems in technical interviews

How to calculate space and time complexities for your code

Requirements

Basic Java programming knowledge

Description

In this course we will dive deep into data structures and algorithms and learn how to do they work, how to implement them in Java and how to use them for implementing and optimizing your application. we will also learn how to calculate time complexity and space complexity and how to decide which data structure or algorithm should be used for solving a specific problem.We will also solve coding challenges from Leetcode to reinforce the data structures and algorithms knowledge and to explain how they can be used for solving coding problems efficiently.Data structures and algorithms are two of the most important aspects of computer science, learning data structures and algorithms will help you become a better programmer, write more efficient code and solve problems quicker, that's why Tech companies focus on data structures and algorithms in the technical interviews.Throughout this course we will cover everything you need to master data structures and algorithms, including:Big O notation (time complexity and space complexity)ArraysLinked listsStacksHeapsQueuesHashmapsTriesTrees (and tree traversal algorithms)GraphsBreadth first search and depth first searchLinear searchBinary searchBubble sortQuick sortSelection sortInsertion sortMerge sortRecursionI am confident that you will like this course and that you will be a different programmer once you finish it, join me in this course and master data structures and algorithms!

Overview

Section 1: Introduction

Lecture 1 Introduction

Lecture 2 What is an algorithm

Lecture 3 What are Data structures

Lecture 4 Why programmers need algorithms and data structures

Section 2: BigO Notation - time and space complexity

Lecture 5 Time complexity

Lecture 6 Space complexity

Section 3: Array

Lecture 7 Introduction to arrays

Lecture 8 Arrays example in Java

Lecture 9 When to use arrays

Lecture 10 Two dimentional arrays

Lecture 11 Two dimensional array example in Java

Lecture 12 Time complexity of array's operations

Lecture 13 Array's coding challenge (with solution)

Section 4: Linked list

Lecture 14 Introduction to linked lists

Lecture 15 Types of linked lists

Lecture 16 Linked list's operations and their time complexity

Lecture 17 Linked list implementation in Java

Lecture 18 Arrays vs linked lists and when to use each

Lecture 19 Linked list's coding challenge (with solution)

Section 5: Stack

Lecture 20 Introduction to stacks

Lecture 21 Stack implementation in Java

Lecture 22 Stack's operations time complexity

Lecture 23 Stack's coding challenge (with solution)

Section 6: Queue

Lecture 24 Introduction to queues

Lecture 25 Queue implementation in Java

Lecture 26 Queue's operations time complexity

Lecture 27 Queue's coding challenge (with solution)

Section 7: Hashmap

Lecture 28 Introduction to hashmaps

Lecture 29 Hashmap's operations time complexity

Lecture 30 When to use hashmaps

Lecture 31 Hashmap usecase in Java

Lecture 32 Hashmap's coding challenge (with solution)

Section 8: Tree

Lecture 33 Introduction to trees

Lecture 34 Types of tree

Lecture 35 Tree's depth

Lecture 36 Tree's traversal algorithms

Lecture 37 Implementation of the tree and it's traversal algorithms in Java

Lecture 38 Tree's coding challenge (with solution)

Section 9: Heap

Lecture 39 Introduction to heaps

Lecture 40 Heap implementation in Java

Lecture 41 Heap's operations time complexity

Lecture 42 When to use heaps

Lecture 43 Priority Queue in Java

Lecture 44 Heap's coding challenge (with solution)

Section 10: Graph

Lecture 45 Introduction to graphs

Lecture 46 Types of graphs

Lecture 47 Time complexity of BFS and DFS for graphs

Lecture 48 Applications of graphs

Lecture 49 Graph implementation and usecase in Java

Lecture 50 DFS implementation in Java

Lecture 51 BFS implementation in Java

Lecture 52 Graph's coding challenge (with solution)

Section 11: Trie

Lecture 53 Introduction to tries

Lecture 54 Trie implementation in Java

Lecture 55 Space and time complexity of the trie's operations

Lecture 56 Trie's coding challenge (with solution)

Section 12: Searching algorithms

Lecture 57 Introduction to searching algorithms

Lecture 58 Linear search

Lecture 59 Binary search

Lecture 60 Linear search vs Binary search

Lecture 61 Searching algorithms coding challenge (with solution)

Section 13: Sorting algorihtms

Lecture 62 Introduction to sorting algorithms

Lecture 63 Bubble sort

Lecture 64 Quick sort

Lecture 65 Selection sort

Lecture 66 Insertion sort

Lecture 67 Merge sort

Lecture 68 Sorting algorithms coding challenge (with solution)

Section 14: Recursion

Lecture 69 Introduction to recursion

Lecture 70 Recursion's coding challenge (with solution)

Section 15: What's next ?

Lecture 71 Conclusion and next steps

Programmers who want to master data structures and algorithms and implement/use them to develop efficient applications,Programmers that want to improve their programming skills and become better at programming,Programmers who want to become better at solving coding problems and writing more efficient code,Computer science students,Self-taught programmers,Programmers who are preparing for a coding interviews