OpenCourser
Learn skills that shape your future
Visit OpenCourser.com
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.
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.
Lempel-Ziv-Welch Algorithm
Huffman Compression
Prefix Tree or Trie Tree
Suffix Trie
Suffix Tree
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.
Why not get started today?
Click the Signup button to sign up for the course.
In this video we will create a unit test to test the implementation of the brute force class. We will test both methods
In this video we you will learn the Knuth-Morris-Pratt or KMP algorithm. It is a two step algorithm so this is the first introduction which talks mainly about the algorithm. The next introduction we will talk about the Longest Prefix Suffix table part of the algorithm
In this video you will learn the second part of the Knuth-Morris-Pratt or KMP algorithm. It is the support table that will carry the information about the longes suffix that maches the prefix of the pattern.
In this video we will code the computation of the longest Suffix Prefix table method
In this video we will create a unit test with a few scenarious to assure that our method is working as expected. The source code will be attached to the "KMP Longest Suffix Preffix Table Coding" video.
This video is the introduction of the whole course.
In this video I will show you how you can get the most of this course.
In this video you will create your first project using Maven. You will also add Junit dependecy to prepare for the next video
In this video you will create a enum and utils class with some methods so we can unit test it. You will also create a unit test and lean the advantages of using it on your projects.
In this video you are going to learn about euclid algorithm.
In this video we will implement the euclid algorithm. We will also implement the recursion and non recursion version of it.
In this video we will create a test class and write the appropriate unit tests to be sure that we get the expected result for the number and divisor that we played with while we were developing
In this video you will undestand how the brute force algorithm works.
In this video we will code the brute force algorithm the simple way. We will also create a version that will return all the matches as a bonus.
In this video we will code the search method of the Knuth-Morris-Pratt algorithm which will use the computeLSPTable method developed on the previous lecture. The source code will be attached to the "KMP Longest Suffix Preffix Table Coding" video.
In this video we will create a unit test with a few scenarious to test the complete algorithm implementation. The source code will be attached to the "KMP Longest Suffix Preffix Table Coding" video.
In this video you will learn how the Rabin-Karp algorithm works. You will also understand what is the rolling hash function and how it calculates the new hashcode without recalculate the whole string
In this video we will implement the Ribin-Karp algorithm. We will write line by line and I will explain as we develop.
In this video we will create unit test to test all the methods created to support the search method
In this video you will learn the Boyer Moore algorithm. You will understand in detail the how this algorithms finds a pattern into an array. Also you will understand how the Bad Character Rule is applied to the algorithm and help it to perform better than other algorithms.
In this video we will implement the Boyer Moore Horspool algorithm while I talk through the logic.
In this video we will create unit tests for our Boyer Moore Horspool implementation
In this video you will learn the Boyer Moore algorithm. You will understand in detail the how this algorithms finds a pattern into an array. Also you will understand how the Good Suffix Rule is applied to the algorithm and how it helps to improve performance.
In this video we will code and test the two methods that will help the goodFuffixTable method to preprocess the table.
In this video we will code and test the GoodSufix method and use the other two methods we developed on the previous video
In this video we will code the Boyer Moore Algorithm which will use the GoodSufix table created on the previous video
In this video you will understand how the Z algorithm work. You will learn how to create the Z Table and how to make the computation of the Z table more efficiently using Z Box
In this video we will implement the Z-Table which will be used by the 2nd part of this algorithm. We will code and test
In this video we will implement the Z Algorithm and use the z-table methods we created on the previous video. We will also create some unit tests to validate our search.As a bonus we will implement a searchAll method which will search all ocurrences into the string
In this video you will leran how the Encoding part of the Huffman Compression Algorithm works. You will understand the basics of compression for files like .zip or .mp3
In this video we will start the implementation of the Huffman Compression Algorithm. We will develop createFrequencyTable and Test that. We will also develop CreatePriorityQueue method and test on the next video
In this video we will test the createPriorityQueue and create two more methos being them the createHuffmanTree and pullLeastUsed. We will also test the pullLeastUsed and the CreateHuffmanTree will be tested on the next video
In this video we will teste the createHuffmanTree method and also implement a few more methods that will make all the encode easy to the user. We will create another method that will actually store the compressed bites for each character. On the next and final video we will implement one final method and test all of it
In this video we will refactore one method and create the last method for this implementation. We will also unit test those
In this video you will leran how the Decode part of the Huffman Compression Algorithm works. You will understand the basics of compression for files like .zip or .mp3
In this video we will start the implementation for the decode part of the Huffman Algorithm. We will start by adding the header when encoding it and test that part. After that we will implement the decode part where it reads the header and make the frequency table out of it
In this video we will test the method which parses the header as frequency table. We will also finish the implementation of the decompress method and a couple more methods needed to get this algorithm working.
In this video we will complete the tests for the the methods left to test and complete this algoritn
In this video you will learn how the LZW compression compressed data
In this video you will learn how to implement and test the compression method of the LZW Compression Algorithm
In this video you will learn how to implement and test the decompress method of the LZW algorithm
In this video you will learn how Trie Trees are created and how does a Prefix Tree works.
In this video we will implement the prefix tree and use the trie trees as a data structure. We will implement the node, the tree and the insert method. The find method will be implemented on the next video
In this video we will implement the find method and test it. The delete method will be implemented on the next video
In this video you will learn hiw Suffix Tries are built and how fast it will search for question such as if q is substring or suffix of a specific string or even how many times a substring occurs into a longer string. Assume q is the substring to be searched.
In this video you will learn how to implement the insert method fo the Suffix Trie. We will implement using array instead of Map. We will also implement a toString method to see what the results are.
In this video we will create a new TieNode class called TrieNodeMap and we will refactor it replacing the usage of array into a Map
In this video we will implement the serach method and a couple more methods to help us identify with boolean results if it is a substring or a suffix
In this video we will implement the serach method and the other two helper methods isSuffix and isSubstring into the SuffisTrieMap version of our implementation. This will be very quick since the logic is the same.
In this video you will understand how the naive implementation of the Suffix Tree works
In this video you will lean three tricks we will use to improve the runtime complexity. This implementation is also called Ukkonen's Algorithm
In this video you will learn how suffix links will be implemented into our Suffix Tree and how it will help us to go from O(m^3) to O(m)
In this video you will understand the last part of our implementation which are the active points
In this video we will go through a simpler example to reinforce what was learned.
In this last video you will learn how to add the indexes to the edge nodes.
In this vide we will implement the SuffixNode and ActiveNodes classes. We will also start implementing our SuffixTree Class.
In this video we will unit test some of the methods that we have implemented on the previous video
In this video we will implement the buildSuffixTree method and also the method which will execute each phase i.
In this video we will keep implementing the startPhase method. We will also create the walkDown method
In this video we will print the steps as they happen so we can follow it
In this vide we will finish the implementation of the getNextCharacter and make a small refactor. We will also create the dfs traversal method
In this video we will create the method to populate the indexes into the SuffixTree
Save
Instructor codes line by line clearly.
Focuses heavily on coding algorithms.
Valuable for interviews and jobs.
Explores challenging and advanced algorithms.
Includes in-depth O(n) Suffix Tree.
OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.
Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.
Find this site helpful? Tell a friend about us.
We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.
Your purchases help us maintain our catalog and keep our servers humming without ads.
Thank you for supporting OpenCourser.
