Learning Path:Learning Functional Data Structure & Algorithm
0.0 (0 ratings)
Instead of using a simple lifetime average, Udemy calculates a 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.
0 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Learning Path:Learning Functional Data Structure & Algorithm to your Wishlist.

Add to Wishlist

Learning Path:Learning Functional Data Structure & Algorithm

Unlock complex data structures and algorithms and get the most out of functional programming
New
0.0 (0 ratings)
Instead of using a simple lifetime average, Udemy calculates a 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.
0 students enrolled
Created by Packt Publishing
Last updated 9/2017
English
English [Auto-generated]
Current price: $10 Original price: $200 Discount: 95% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 5.5 hours on-demand video
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Learn about the O notation
  • Get familiar with runtime and space complexities
  • Learn to drop, concatenate, append, and prepend lists
  • Understand what backtracking algorithm is
  • Learn to build cost-efficient applications
  • Learn how ADTs are implemented in a functional setting
  • Understand functional features such as lazy evaluation and recursion
  • Get to know Scala’s best practices and idioms
View Curriculum
Requirements
  • Working knowledge of functional language especially Scala is required.
Description

Data structures and algorithms are the fundamentals of computer programming. Functional data structures have the power to improve the code base of an application and improve efficiency. With the advent of functional programming and powerful functional languages such as Scala, Clojure, and Elixir becoming part of important enterprise applications, functional data structures have gained an important place in the developer toolkit.

So if you've got some prior knowledge on functional languages and wish to get acquainted with data structures and algorithms with simple functional implementation, then go for this Learning Path.

Packt’s Video Learning Path is a series of individual video products put together in a logical and stepwise manner such that each video builds on the skills learned in the video before it.

Let's take a quick look at your learning journey. This Learning Path begins with an introduction to functional programming. You will learn about Lists, the work horse data type for most functional languages. You will then understand structural sharing and how it helps to make immutable data structures efficient and practical. Next, you will learn about binary trees wherein you will build complete trees, greedy algorithms, and backtracking. Moving ahead, you will seehow to use abstract data types (ADTs) such as stacks, queues, trees, and graphs and will learn to implement them in functional programming. Finally, you will learn implementation techniques such as amortization and lazy evaluation to ensure code efficiency.

By the end of this Learning Path, you will be able to write efficient functional data structures and algorithms for your applications.

About the Author:

For this course, we have combined the best works of this esteemed author:

  • Atul S. Khot is a self-taught programmer. He started writing software in C and C++. A Linux aficionado and a command-line guy at heart, Atul has always been a polyglot programmer. Having extensively programmed in Java and dabbled in multiple languages, these days he is getting increasingly hooked on Scala, Clojure, and Erlang. Atul is a frequent speaker at software conferences, and a past Dr. Dobb's product award judge.
  • Raju Kumar Mishra is a consultant and corporate trainer for big data and programming. After completing his B.Tech from the Indian Institute of Technology Dhanbad, he worked for Tata Steel. His deep passion for mathematics, data science, and programming took him to the Institute of Science (IISc). After graduating from IISc in computational science, he worked for Oracle as a performance engineer and software developer. He is an Oracle-certified associate for Java 7. He is a Hortonworks-certified Apache Hadoop Java developer, and holds a developer certification for Apache Spark (O'Reilly School of Technology and Databriks), and revolution R enterprise-certified specialist certifications.
Who is the target audience?
  • This Learning Path is for developers who have some experience in functional programming language,especially Scala.
Compare to Other Java Algorithms Courses
Curriculum For This Course
59 Lectures
05:28:34
+
Functional Data Structures and Algorithms
27 Lectures 02:00:06

This video gives an overview of the entire course.

Preview 04:20

In this video, we will print all the elements of an array and then apply higher level programming abstractions. Finally, you will learn about ABT.

Preview 06:24

In this video, we will first count even elements from the input list to show that functional programming is declarative and then show that there is no boiler plate in functional programming.

Functional Programming and Boilerplate
04:29

Higher order functions help us succinctly express logic. In this video, you will learn about higher order functions.

Higher Order Functions
03:13

Instead of writing a loop using a mutable loop variable, functional languages advocate recursion as an alternative. In this video, we will see how recursion aids immutability.

Recursion Aids Immutability
02:05

In this video, you will first learn about copy-on-write, then to deal with excessive copying, we can resort to a feature called deferred processing.

Copy-On-Write, Laziness, and Deferred Execution
03:53

In this video, you will learn to compose functions.

Composing Functions
04:18

The big O notation is used to describe how fast an algorithm will run. In this video, we will describe the growth of the algorithm's running time versus the size of input data in Scala.

The Big O Notation
03:14

In this video, we will see how trading off some space by caching known results saves time and avoids needless computations. 

Space/Time Trade-Off
06:07

In this video, we will show you that mathematical functions are not referentially transparent. 

Referential Transparency
03:06

In this video, you will learn about the advantage of vectors over list. Also, you will learn to update elements in an array of elements.

Vectors Versus Lists
05:54

In this video, we will look at collections and see how complexity helps us to see how they will perform in different situations. Also, we will look at commonly used collections and idioms with examples.            

Complexities and Collections
09:20

This video introduces you to the basics of list.

First Steps
06:43

In this video, you will learn about the head and tail method.

List Head and Tail
02:24

This video shows us how to drop elements from the list.

Drop Elements
02:28

This video deals with joining of two lists into a single list.

Concatenating Lists
02:19

The main objective of this video is to teach you about persistent data structures and tail call optimization.

Persistent Data Structures and Tail Call Optimization
04:16

This video deals with appending and prepending of lists.

List Append and Prepend
03:32

We cannot do random indexing on a linked list. So here in this video, we will get the value at index.

Getting the Value at Index
02:05

In this video, we will take a look at how to modify a list value.

Modifying a List Value
02:32

This video deals with the basics of node.

Node Definitions
01:53

This video shows us how to build a binary tree.

Building the Tree
04:14

This video deals with comparing trees. Here we will also flip trees.

Comparing Trees
07:51

This video deals with eliminating list concatenating with the help of an accumulator argument and then trace the growth of the accumulator.

The Accumulator Idiom
02:32

This video deals with implementation of dictionaries using binary search trees.

Binary Search Trees
07:24

This video deals with various operations which can be performed using binary numbers.

Binary Numbers
07:26

This video teaches us about the algorithm that matches the longest possible part and also teaches us to find alternate possibilities in case of failure.

Greedy Algorithms and Backtracking
06:04
+
Advanced Functional Data Structures and Algorithms
32 Lectures 03:28:28

This video gives overview of the entire course.

Preview 04:24

In this video, we are going to reverse a list.

Reversing a List
03:29

In this video, we will be looking at directed graphs, also known as digraphs.

Exploring More About Graph Algorithms
12:38

In this video, we will check whether a cycle has been introduced and then print the cycle.

Cycle Detection
04:17

In this video, we will look at the binary operations related to list implementation and then add two binary numbers.       

Incrementing a Binary Number
05:41

The binary trees' lookup and update operations are fast. So in this video, we will look at all the roots linked up in a list.

List of Tree Roots
16:23

In this video, you will first understand about FIFO queues and then learn about functional FIFO queues.

FIFO Queues
04:15

This video deals with the concept of an invariant.

Invariants
01:50

This video deals with the implementation of the priority queues and then we will look at the min-heap data structure first and then the functional version.

Priority Queue
07:43

A leftist tree is a data structure that we can use to implement the priority queue ADT.

Leftist Trees
02:06

This video deals with development of the functional heaps using leftist tree.

Functional Heaps
08:06

An expression is executed whenever it comes on the way of program execution. This evaluation strategy is known as eager evaluation.

Program Evaluation
03:45

In this video, you will first learn about argument evaluation and then learn about lazy evaluation in Scala and Clojure.

Argument Evaluation
13:09

Memoization is the art of computer program optimization to speed up functions.

Memoization – Remembering Past Results
09:59

A stream is generally a lazy and linear sequence collection. Stream elements are evaluated only when needed. In this video, we will look at streams in Scala and Clojure.

Streams
12:31

In this video, we will look at some mathematical series based algorithms.

Some Algorithms on Stream
09:07

In this video, we will take a quick look at how deques are implemented imperatively. Next, we will look at the amortization algorithm technique that underlies this implementation.

Imperative Implementations and Amortization
04:38

The aim of this video is to highlight the difference between strict versus lazy lists.

Strict Versus Lazy
01:34

In this video, we will play a bit with Stream, that is, Scala's lazy lists.

Streams
07:08

In this video, we will implement dequeues.

Amortized Deques
04:36

In this video, we will get familiarized with some commonly used terms and learn about the almost balanced trees.

Concept of Red-Black Trees
03:44

In this video, we will look at the core black tree.

Working with Red-Black Trees
11:04

In this video, we will verify the transformation and find the complexity of the nodes.

Verifying the Transformation
02:58

In this video, you will learn what binomial tree is.

Binomial Trees
03:08

A heap-ordered binomial tree is one in which every parent value is less than or equal to its children.

A Binomial Heap
03:50

There is a surprising equivalent in the processes of binomial heap insertion and incrementing a binary number.

Binary Number Equivalence
07:52

In this video, you will understand the stable and unstable sorting.

Stable and Unstable Sorting
02:34

Bubble sort is one of the simplest and oldest algorithms. Each element is compared with the next element.

Bubble Sort
07:39

Selection sort is another simple sorting algorithm. It is a stable sorting algorithm.

Selection Sort
05:36

Insertion sort is simple to implement and a stable sorting algorithm. During the process of sorting, it creates a sorted subsequence.

Insertion Sort
06:30

Merge sort uses the divide and conquer philosophy

Merge Sort
08:20

Quick sort is about dividing a problem into approximately similar sub problems, solving each sub problem separately, and combining the results of the sub problems to deliver the final result.

Quick Sort
07:54
About the Instructor
Packt Publishing
3.9 Average rating
8,197 Reviews
58,853 Students
687 Courses
Tech Knowledge in Motion

Packt has been committed to developer learning since 2004. A lot has changed in software since then - but Packt has remained responsive to these changes, continuing to look forward at the trends and tools defining the way we work and live. And how to put them to work.

With an extensive library of content - more than 4000 books and video courses -Packt's mission is to help developers stay relevant in a rapidly changing world. From new web frameworks and programming languages, to cutting edge data analytics, and DevOps, Packt takes software professionals in every field to what's important to them now.

From skills that will help you to develop and future proof your career to immediate solutions to every day tech challenges, Packt is a go-to resource to make you a better, smarter developer.

Packt Udemy courses continue this tradition, bringing you comprehensive yet concise video courses straight from the experts.