Algorithms and Data Structures Easy Way Java - job interview

At the end of this lecture you will have a maven project created with JUNIT dependency ready to work.

You will also have a basic understanding of what maven is and how it works.

At the end of this lecture you will understand what is JUNIT and how to write a JUNIT test.

It will be easier to show how recursion works implementing an algorithm. We will implement Euclid's algorithm. I incentive you to write the code a few times then it will get stuck on your mind and easier to write and explain.

At the end of this lecture you will be able to write Euclid's algorithm and be able to explain if someone aske you this question.

On this video you will learn Linear Search algorithm.

This lecture will teach you how to code a Linear Search. You will understand how it works and we will code it from scratch.

On this video we will create a unit test for the Linear Search algorithm. We will test the code that we just wrote on the previous lecture.

I will also exhaust a little bit about JUNIT debugging and explaining in detail how you run multiple unit test at once and check which tests worked and which tests failed.

After this class you will understand how Insert Sort algorithm works.

After this lecture you will be able to understand and code an Insert Sort algorithm.

After this lecture you will test and play with the results of the InsertSort class that we created on the lecture 9. We will use a new Assertion to test the arrays. We will also use a toString from the java.util.Arrays class to help us illustrate what our code is doing.

After this lecture you will understand what is Binary Search Algorithm and how it works.

On this lecture you will learn how to code a Binary Search Algorithm. This will be coded using a non recursive way and after unit testing we will code using recursion.

On this lecture we will unit test our Binary Search Algorithm coded on the previous lecture. We will also add some code to demonstrate what the code is doing and how many iterations are happening for the search to be completed.

On this lecture you will learn how to code the Binary Search Algorithm using recursion. We will also explore the differences between the two classes (non using recursion and using it)

On this lecture we will test the Binary Search Algorithm written using recursion. More important we will quickly debug and show the recursive calls happening.

After this lecture you will understand what is Quick Sort Algorithm and how it works.

On this lecture you will learn how to code a Quick Sort Algorithm. It will be coded using recursion. Each functionality will be explained and we will go through some more detail over the next lecture while unit testing.

On this lecture we will test the Quick Sort Algorithm written using recursion. We will quickly debug the code to understand a little better.

After this lecture you will have a clear understanding of what is a BinaryTree and how it works.

On this lecture you will learn how to code a BinaryTree. We will also implement pre and post order traversal of the tree to print the elements in sort ordered or reverse ordered. We will use recursion.

At the end you will understand what it is and how to code it.

On this lecture we will test the BinaryTree coded using recursion. We will quickly debug the code to understand a little better.

We will also use the library from Apache common lang to use ArrayUtils

After this lecture you will understand what is a Linked List and how it works.

On this lecture you will learn how to implement a LinkedList.

On this lecture we will test the LinkedList created on the previous lecture. We will also debug to have a better understanding of the code.

After this lecture you will understand what is a DoublyLinkedList and what is the difference between DoublyLinkedList and LinkedList and you will also be able to understand how it works.

On this lecture you will code and understand line by line what happens on this implementation of the DoublyLinkedList.

We will develop the remove method and as an nice extra we will override the toString method to get a nice String when we print our DoublyLinkedList

On this lecture we will unit test our DoublyLinkedList methods add and remove. We will also see the result expected by the toString that we implemented.

After this lecture you will understand what is a Prefix or Trie Tree and you will also be able to understand how it works.

On this lecture you will learn how to code a Prefix or Trie Tree and we will implement the insert method which will break a String into the nodes of the tree. The search method will be implemented on the next lecture so you can have some time do drink some water.

On this lecture you will learn how to implement the search method of a Prefix or Trie Tree

On this lecture we will test the Prefix or Trie Tree implemented on the last two lectures. We will also debug the insert method so you have a better understanding of what it is doing and how it is actually working. I broke the test in two parts to make is easier to understand.

On this lecture we will test the Prefix or Trie implemented on the lectures 30th and 31st and we will also debug the search method so you have a good understanding of what it is doing and how it is actually working.

On this lecture you will understand what is a Stack and how it works.

On this lecture you will learn how to implement a Stack and this implementation will be using Object as the object being stored. The next lecture we will refactor this code to implement generics.

On this lecture we will test the Stack implemented on the previous lecture and we will also debug so you have a better understanding of what it is doing and how it is actually working. A refactor using Generics will be done on the next lecture.

On this lecture we will refactor the stack developed on the previous lecture and refactor to implement generics

On this lecture we will test the Stack with Generics implemented on the previous lecture and we will also debug so you have a better understanding of what it is doing and how it is actually working.

On this lecture we will code the interview question to print the odd numbers. We will also implement a second way to the problem.

On this lecture we will unit test the print odd numbers interview question. We will also debug and do a small refactor to make it fancier and cleaner.

On this lecture you will understand what is this question all about and how we are going to proceed to implement it on the next lecture.

On this lecture we will implement this interview question that returns the number of characters and comment through the code.

On this lecture we will refactor the code implemented on the previous lecture to also make available the sequence of characters and not just the count. We will also comment as we code for you to have a better understanding.

On this lecture we will unit test our interview exercise find the longest substring without repeating characters. We will also debug the code to get it in a bit more detail

Sudoku was broken in two coding parts to make it easier for you. On this lecture we will implement the first part of the Sudoku interview question and comment through the code.

On this lecture we will implement the second part of the Sudoku interview question and comment through the code. We will implement all the methods necessary to have the solve method working properly.

On this lecture we will create unit test for all the methods that we developed to have the sudoku working. We will test solve and printMe on the next lecture.

On this lecture we will test the solve method, debug through the code and check the output using the printMe method implemented.