Advanced Algorithms in Java
Understand Algorithms and Data structure at a deep level. Grow your career and be ready to answer interview questions!
Once you know the basics of Java, you will want to start figuring out Algorithms and Data structures.
Used correctly, your code will run faster, and use less memory, and be more stable, with the efficient use of the right Algorithms and data structures.
But the reverse is also true. When used incorrectly, you can find your code consuming more memory and running slower!
Programmers who understand how to use and implement Algorithms and data structures correctly, are in high demand. Until now, acquiring the knowledge of how to do things the right way has been a painful process of learning by trial and error.
All that has changed with the release of this brand-new course – Advanced Algorithms in Java.
Marcos Costa, is an expert Java developer with 18 years of experience. Early in his career he realised the importance of understanding algorithms at a deep level.
Soon he began to get noticed by his peers for his knowledge and rose to Tech Lead Engineer.
His skills took him to positions all over the world, including Australia and the USA where he now resides.
Now he created a course designed to help Java programmers to really understand algorithms at a deep level.
What will you learn in this course?
You’ll learn to become a better problem solver, by using better implementations and making better decisions with your coding.
Marcos will explain to you in an easy to follow and understandable way, how to implement a number of algorithms that you can put to good use in your own projects.
Follow along, line by line as the algorithms are developed, and watch it execute, and get a deep understanding of how the algorithms work.
Unlike most other courses, you will actually understand how to put together and use these algorithms in your own code. This course is heavily practical – its not just boring theory and slides that you see in many other courses that target the same topics.
What topics are covered in the course?
You will learn five different Pattern Matching algorithms.
You will implement two version of Boyer Moore algorithm (the simplest and easiest and the more complex).
And then implement the Suffix Tree from O(n2) to only O(n).
This is a very long, complex and interesting implementation!
What benefits will you get out of the course?
You will learn and understand complex algorithms.
Improve your confidence in interviews as a result of what you have learned in the course.
Write better Java code, that is more efficient and optimized, factoring in your newly found understanding of memory vs processor trade-offs.
Quite literally, you will take your Java skills to the next level.
Why enrolling in this course is the best decision you can make.
This course helps you to understand how to implement a number of core algorithms. You will come away with a detailed understanding of how they work, and how to apply what you have learned into your own programs.
You’ll be able to write better Java code, and as a result your programs will be better optimized for execution and use less resources.
After completing this course, you will be able to add the algorithms you have learned into your arsenal of skills, giving you more opportunities to further your career.
The sooner you sign up for this course, the sooner you will have the skills and knowledge you need to increase your job or consulting opportunities. Your new job or consulting opportunity awaits!
- Have an understand of how algorithms work, at a deep level
- Write better Java code that is more optimised
Installation and Setup
1 Introduction to the Course
2 Creating Maven Project with JUNIT
3 Learning Unit Testing with JUNIT
4 How to Get the Most from this Course
5 Which version of Java should you use
6 Install JDK 10 on Windows
7 Install and Configure Intellij on Windows
8 Install JDK 10 on a Mac
9 Install and Configure Intellij on a Mac
10 Install JDK 10 on Linux
11 Install and Configure Intellij on Linux
Pattern Matching Algorithms
12 Euclid Augorithm Introduction
13 KMP Longest Suffix Preffix Table Test
14 Knuth Morris Pratt (KMP) Coding
15 Knuth Morris Pratt (KMP) Test
16 Rabin-Karp Introduction
17 Rabin-Karp Coding
18 Rabin-Karp Test
19 Boyer Moore Horspool Introduction
20 Boyer Moore Horspool Coding
21 Boyer Moore Horspool Test
22 Boyer Moore Introduction
23 Euclid Algorithm Coding
24 Boyer Moore Coding Part 1
25 Boyer Moore Coding Part 2
26 Boyer Moore Coding Part 3
27 Z Algorithm Introduction
28 Z Algorithm Coding Part1
29 Z Algorithm Coding Part2
30 Euclid Algorithm Unit Test
31 Brute Force Introduction
32 Brute Force Coding
33 Brute Force Unit Test
34 Knuth Morris Pratt (KMP) Introduction
35 KMP Longest Suffix Prefix Table Introduction
36 KMP Longest Suffix Preffix Table Coding
Compression Algorithms
37 Huffman Compression Encoding Introduction
38 LZW Lempel-Ziv-Welch Compression Introduction
39 LZW Compression Coding Compression
40 LZW Compression Coding Decompression
41 Huffman Compression Encoding Coding Part 1
42 Huffman Compression Encoding Coding Part 2
43 Huffman Compression Encoding Coding Part 3
44 Huffman Compression Encoding Coding Part 4
45 Huffman Compression Decode Introduction
46 Huffman Compression Decode Coding Part 1
47 Huffman Compression Decode Coding Part 2
48 Huffman Compression Decode Coding Part 3
Exploring Trie Trees
49 Prefix Tree Introduction
50 Suffix Tree Naive Implementation
51 Suffix Tree Ukkonen’s Ticks
52 Suffix Tree Ukkonen’s Suffix Links
53 Suffix Tree Ukkonnen’s Active Points 1
54 Suffix Tree Ukkonnen’s Active Points 2
55 Suffix Tree Ukkonnen’s Edge Index
56 Suffix Tree Ukkonnen’s Coding Part 1
57 Suffix Tree Ukkonnen’s Testing Part 1
58 Suffix Tree Ukkonnen’s Coding Part 2
59 Suffix Tree Ukkonnen’s Coding Part 3
60 Prefix Tree Coding Part 1
61 Suffix Tree Ukkonnen’s Coding Part 4
62 Suffix Tree Ukkonnen’s Coding Part 5
63 Suffix Tree Ukkonnen’s Coding Part 6
64 Prefix Tree Coding Part 2
65 Prefix Tree Coding Part 3
66 Suffix Trie Introduction
67 Suffix Trie Coding Part 1
68 Suffix Trie Coding Part 2
69 Suffix Trie Coding Part 3
70 Suffix Trie Coding Part 4
Bonus Material
71 Bonus – Please Watch!
72 Check out Our Other 36 Udemy Courses!
73 Source Code
Resolve the captcha to access the links!
Advanced Algorithms in Java
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 11 hours to completely but I highly suggest you typing these algorithms out several times in order to get a good grasp of it. You can download the source code of the whole course at the last lecture.
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 path algorithms: there are several applications which we are going to be familiar with from image processing to FOREX arbitrage. The next chapter is about minimum spanning trees and clustering algorithms. Then, we are going to learn about the maximum flow problem, maybe the most important algorithm in this course. The last chapter is about how to solve NP problems such as the travelling salesman problem with simulated annealing.
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.
- Learn about the applications of data structures
- Implement advanced algorithms efficiently
- Able to move towards advanced topics such as machine learning or big data analysis
- Get a good grasp of algorithmic thinking
- Get to know graph algorithms: BFS, DFS, shortest paths and spanning trees
Introduction
1 Introduction
2 Graph theory introduction
3 Complexity theory
Breadth-First Search
4 Breadth-first search introduction
5 BFS implementation
6 BFS – WebCrawler (core of search engines)
7 BFS – WebCrawler implementation
Depth-First Search
8 Depth-first search introduction
9 DFS implementation I – with stack
10 DFS implementation II – with recursion
11 Topological ordering introduction
12 Topological ordering implementation I
13 Topological ordering implementation II
14 Cycle detection introduction
15 Cycle detection implementation I
16 Cycle detection implementation II
17 Maze solving algorithm implementation
18 Memory management_ BFS vs DFS
Shortest Path Algorithms
19 Dijkstra algorithm introduction – basics
20 Dijkstra algorithm introduction – algorithm
21 Dijkstra algorithm introduction – example
22 Bellman-Ford algorithm introduction
23 Dijkstra algorithm introduction – with adjacency matrix
24 Shortest path algorithms applications
25 Dijkstra algorithm implementation I
26 Dijkstra algorithm implementation II
27 Bellman-Ford algorithm implementation I
28 Bellman-Ford algorithm implementation II
29 DAG shortest path implementation
30 Arbitrage situations on FOREX introduction
31 Arbitrage situations on FOREX implementation
32 Longest path implementation
Spanning Trees
33 Union-find data structure (disjoint sets)
34 Union-find data structure illustration
35 Spanning trees introduction – Kruskal algorithm
36 Kruskal algorithm implementation I
37 Kruskal algorithm implementation II – disjoint set
38 Kruskal algorithm implementation III
39 Spanning trees introduction – lazy Prim’s algorithm
40 Prims lazy algorithm implementation I
41 Prims lazy algorithm implementation II – the core
42 Spanning trees introduction – eager Prim’s algorithm
43 Eager Prim’s algorithm implementation
44 Applications of spanning trees
Strongly Connected Components
45 Strongly connected components introduction
46 Kosaraju algorithm introduction
47 Kosaraju implementation I – the Graph class
48 Kosaraju implementation II
49 Kosaraju algorithm implementation III – test
50 Tarjan algorithm introduction
51 Tarjan implementation I
52 Tarjan implementation II – test
53 Applications of strongly connected components
Maximum Flow Problem
54 Maximum flow introduction – basics
55 Maximum flow introduction – properties
56 Maximum flow introduction – cuts
57 Maximum flow introduction – residual networks
58 Maximum flow introduction – Ford-Fulkerson algorithm
59 Maximum flow introduction – example
60 Maximum flow introduction – applications
61 Maximum flow implementation I – Edge_ Vertex
62 Maximum flow implementation II – FlowNetwork class
63 Maximum flow implementation III – Ford-Fulkerson algorithm
64 Maximum flow implementation IV – augmentation
65 Maximum flow implementation V – testing
66 Bipartite matching problem introduction
67 Bipartite matching implementation
Travelling Salesman Problem (TSP)
68 Travelling salesman problem introduction
69 TSP implementation with simulated annealing I – city
70 TSP implementation with simulated annealing II – tour
71 TSP implementation with simulated annealing III – algorithm
72 TSP implementation with simulated annealing IV – testing
73 Tabu search introduction
74 Tabu search introduction II
Euler cycle – Chinese Postman Problem
75 Euler’s cycles introduction
Source Code & Slides
76 Source code
77 Slides
78 DISCOUNT FOR OTHER COURSES!
Resolve the captcha to access the links!
Advanced Algorithms in Java
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 basic graph traversal algorithm
- breadth-first search algorithm
- depth-first search algorithm
- what are spanning trees
- union find data structures
- Kruskal’s algorithm
- Prim’s algorithm
- the famous maximum flow problem
- how to reduce most of the hard problems to maximum flow problem
- Ford-Fulkerson algorithm
- bipartite matching problem
- travelling salesman problem (TSP)
- how to deal with NP-hard problems
- using meta-heuristics: tabu search and simulated annealing
The course is going to take approximately 10 hours to completely but I highly suggest you typing these algorithms out several times in order to get a good grasp of it. You can download the source code of the whole course at the last lecture.
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.
Thanks for joining the course, let’s get started!
- This course is meant for everyone from scientists to software developers who want to get closer to algorithmic thinking in the main
Created by Holczer Balazs
Last updated 11/2017
English
Size: 1.20 GB