Advanced Algorithms in Java
course's star rating by considering a number of different factors
such as the number of ratings, the age of ratings, and the
likelihood of fraudulent ratings.
Find online courses made by experts from around the world.
Take your courses with you and learn anywhere, anytime.
Learn and practice realworld skills and achieve your goals.
This course is about advanced algorithms focusing on graph traversal, shortest path problems, spanning trees and maximum flow problems and a lots of its applications from Google Web Crawler to taking advantage of stock market arbitrage situations.
The course is going to take approximately 7 hours to completely but I highly suggest you typing these algorithms out several times in order to get the grasp of it. You can download the source code of the whole lecture at the last video.
In the first section we are going to talk about the main graph traversal algorithms (BFS, DFS) and its applications of course such as WebCrawler or topological ordering. The next section is about shortest pathalgorithms: there are several applications which we are going to be familiar with from image processing to FOREX market. The third chapter is about minimum spanning trees and clustering algorithms. Lastly, we are going to learn about the maximum flow problem, maybe the most important algorithm in this course. The last chapters are about how to solve NP problems with simulated annealing or genetic algorithms.
You should definitely take this course if you are interested in advanced topics concerning algorithms. There are a bunch of fields where these methods can be used: from software engineering to scientific research.
Not for you? No problem.
30 day money back guarantee.
Forever yours.
Lifetime access.
Learn on the go.
Desktop, iOS and Android.
Get rewarded.
Certificate of completion.
Section 1: Introduction  

Lecture 1 
Introduction
Preview

03:29  
Lecture 2 
Graph theory  Hamiltonian and Eulerian cycles

06:54  
Section 2: Complexity Theory  
Lecture 3 
Complexity notations

09:31  
Lecture 4 
Complexity notations example

09:10  
Lecture 5 
Algorithm running times

09:37  
Lecture 6 
Complexity classes

07:13  
Section 3: Breadth First Search  
Lecture 7 
Breadthfirst search introduction
Preview

09:30  
Lecture 8 
BFS implementation

12:10  
Lecture 9 
BFS  WebCrawler (core of search engines)

05:44  
Lecture 10 
BFS  WebCrawler implementation

15:00  
Section 4: Depth First Search  
Lecture 11  10:21  
Lecture 12 
DFS implementation I  with stack

11:28  
Lecture 13 
DFS implementation II  with recursion
Preview

04:17  
Lecture 14 
Topological ordering introduction

10:31  
Lecture 15 
Topological ordering implementation I

05:49  
Lecture 16 
Topological ordering implementation II

06:07  
Lecture 17 
Cycle detection introduction

06:30  
Lecture 18 
Cycle detection implementation

09:38  
Lecture 19 
Maze solving algorithm implementation

14:50  
Lecture 20 
Memory management: BFS vs DFS

05:23  
Section 5: Shortest Path Algorithms  
Lecture 21 
Dijkstra algorithm introduction  basics

05:35  
Lecture 22 
Dijkstra algorithm introduction  algorithm

05:44  
Lecture 23 
Dijkstra algorithm introduction  example

10:27  
Lecture 24 
BellmanFord algorithm introduction

08:59  
Lecture 25 
Dijkstra algorithm introduction  with adjacency matrix

09:22  
Lecture 26 
Shortest path algorithms applications

08:37  
Lecture 27 
Dijkstra algorithm implementation I

09:28  
Lecture 28 
Dijkstra algorithm implementation II

10:57  
Lecture 29 
BellmanFord algorithm implementation I

14:43  
Lecture 30 
BellmanFord algorithm implementation II

06:05  
Lecture 31 
DAG shortest path implementation

09:42  
Lecture 32 
Arbitrage situations on FOREX introduction

03:47  
Lecture 33 
Arbitrage situations on FOREX implementation

06:37  
Lecture 34 
Longest path implementation

03:50  
Section 6: Spanning Trees  
Lecture 35 
Unionfind data structure (disjoint sets)

10:56  
Lecture 36 
Unionfind data structure illustration

06:35  
Lecture 37 
Spanning trees introduction  Kruskal algorithm

10:36  
Lecture 38 
Kruskal algorithm implementation I

08:04  
Lecture 39 
Kruskal algorithm implementation II  disjoint set

15:40  
Lecture 40 
Kruskal algorithm implementation III

10:07  
Lecture 41 
Spanning trees introduction  lazy Prim's algorithm

07:10  
Lecture 42 
Prims lazy algorithm implementation I

11:38  
Lecture 43 
Prims lazy algorithm implementation II  the core

07:06  
Lecture 44 
Spanning trees introduction  eager Prim's algorithm

11:02  
Lecture 45 
Eager Prim's algorithm implementation

10:45  
Lecture 46 
Applications of spanning trees

07:36  
Section 7: Strongly Connected Components  
Lecture 47 
Strongly connected components introduction

06:57  
Lecture 48 
Kosaraju algorithm introduction

08:19  
Lecture 49  07:28  
We create the helper classes and again, the Graph class. We transpose our directed graph inside this Graph class, because in Kosaraju algorithm we have to do the first DFS (topological ordering) in the transposed graph. (transposing a graph is just to reverse each edge: startVertex will be targetVertex and targetVertex will be the startVertex) 

Lecture 50  07:41  
We create our class in which we will perform the first DFS on the transposed graph 

Lecture 51  01:01  
In this video we make sure the our Kosaraju implementation gives the right results 

Lecture 52  09:06  
DFS is a robust but not so fast algorithm, so Tarjan algorithm tries to get rid of the DFS. 

Lecture 53 
Tarjan implementation II  test

00:44  
Lecture 54 
Applications of strongly connected components

06:48  
Section 8: Maximum Flow Problem  
Lecture 55 
Maximum flow introduction  basics

06:55  
Lecture 56 
Maximum flow introduction  properties

09:30  
Lecture 57 
Maximum flow introduction  cuts

05:13  
Lecture 58 
Maximum flow introduction  residual networks

06:49  
Lecture 59 
Maximum flow introduction  FordFulkerson algorithm

04:50  
Lecture 60 
Maximum flow introduction  example

08:35  
Lecture 61 
Maximum flow introduction  applications

03:08  
Lecture 62 
Maximum flow implementation I  Edge, Vertex

11:58  
Lecture 63 
Maximum flow implementation II  FlowNetwork class

05:26  
Lecture 64 
Maximum flow implementation III  FordFulkerson algorithm

08:03  
Lecture 65 
Maximum flow implementation IV  augmentation

06:43  
Lecture 66 
Maximum flow implementation V  testing

02:55  
Lecture 67 
Bipartite matching problem introduction

03:50  
Lecture 68 
Bipartite matching implementation

02:37  
Section 9: Travelling Salesman Problem (TSP)  
Lecture 69 
Travelling salesman problem introduction

10:52  
Lecture 70 
TSP implementation  with simulated annealing

14:17  
Lecture 71 
Tabu search introduction

09:47  
Section 10: Euler cycle  Chinese Postman Problem  
Lecture 72 
Euler cycles introduction

10:49  
Section 11: Outro  
Lecture 73 
Final words

02:16  
Section 12: Source Code  
Lecture 74 
Source code

Article  
Lecture 75  Article  
You can download the slides here!


Lecture 76 
Coupon codes  get any of my other courses for a discounted price

Article 
Hi!
My name is Balazs Holczer. I am from Budapest, Hungary. I am qualified as a physicist and later on I decided to get a master degree in applied mathematics. At the moment I am working as a simulation engineer at a multinational company. I have been interested in algorithms and data structures and its implementations especially in Java since university. Later on I got acquainted with machine learning techniques, artificial intelligence, numerical methods and recipes such as solving differential equations, linear algebra, interpolation and extrapolation. These things may prove to be very very important in several fields: software engineering, research and development or investment banking. I have a special addiction to quantitative models such as the BlackScholes model, or the Mertonmodel. Quantitative analysts use these algorithms and numerical techniques on daily basis so in my opinion these topics are definitely worth learning.