Learning Path:Learning Functional Data Structure & Algorithm

Unlock complex data structures and algorithms and get the most out of functional programming

What you'll 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

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.

Overview

Section 1: Functional Data Structures and Algorithms

Lecture 1 The Course Overview

Lecture 2 The Imperative Way and a Higher Level of Abstraction

Lecture 3 Functional Programming and Boilerplate

Lecture 4 Higher Order Functions

Lecture 5 Recursion Aids Immutability

Lecture 6 Copy-On-Write, Laziness, and Deferred Execution

Lecture 7 Composing Functions

Lecture 8 The Big O Notation

Lecture 9 Space/Time Trade-Off

Lecture 10 Referential Transparency

Lecture 11 Vectors Versus Lists

Lecture 12 Complexities and Collections

Lecture 13 First Steps

Lecture 14 List Head and Tail

Lecture 15 Drop Elements

Lecture 16 Concatenating Lists

Lecture 17 Persistent Data Structures and Tail Call Optimization

Lecture 18 List Append and Prepend

Lecture 19 Getting the Value at Index

Lecture 20 Modifying a List Value

Lecture 21 Node Definitions

Lecture 22 Building the Tree

Lecture 23 Comparing Trees

Lecture 24 The Accumulator Idiom

Lecture 25 Binary Search Trees

Lecture 26 Binary Numbers

Lecture 27 Greedy Algorithms and Backtracking

Section 2: Advanced Functional Data Structures and Algorithms

Lecture 28 The Course overview

Lecture 29 Reversing a List

Lecture 30 Exploring More About Graph Algorithms

Lecture 31 Cycle Detection

Lecture 32 Incrementing a Binary Number

Lecture 33 List of Tree Roots

Lecture 34 FIFO Queues

Lecture 35 Invariants

Lecture 36 Priority Queue

Lecture 37 Leftist Trees

Lecture 38 Functional Heaps

Lecture 39 Program Evaluation

Lecture 40 Argument Evaluation

Lecture 41 Memoization – Remembering Past Results

Lecture 42 Streams

Lecture 43 Some Algorithms on Stream

Lecture 44 Imperative Implementations and Amortization

Lecture 45 Strict Versus Lazy

Lecture 46 Streams

Lecture 47 Amortized Deques

Lecture 48 Concept of Red-Black Trees

Lecture 49 Working with Red-Black Trees

Lecture 50 Verifying the Transformation

Lecture 51 Binomial Trees

Lecture 52 A Binomial Heap

Lecture 53 Binary Number Equivalence

Lecture 54 Stable and Unstable Sorting

Lecture 55 Bubble Sort

Lecture 56 Selection Sort

Lecture 57 Insertion Sort

Lecture 58 Merge Sort

Lecture 59 Quick Sort

This Learning Path is for developers who have some experience in functional programming language,especially Scala.