Data Structures & Algorithms in Kotlin: Implementing Practical Data Structures in Kotlin

✍ Scribed by raywenderlich Tutorial Team, Irina Galata, Matei Suica

• Publisher: Razeware LLC
• Year: 2019
• Tongue: English
• Leaves: 404
• Edition: 1
• Category: Library

✦ Synopsis

Learn Data Structures & Algorithms in Kotlin!

Data structures and algorithms are fundamental tools every developer should have. In this book, you'll learn how to implement key data structures in Kotlin, and how to use them to solve a robust set of algorithms. This book is for intermediate Kotlin or Android developers who already know the basics of the language and want to improve their knowledge.

Topics Covered in This Book

Introduction to Kotlin: If you're new to Kotlin, you can learn the main constructs and begin writing code.

Complexity: When you study algorithms, you need a way to compare their performance in time and space. Learn about the Big-O notation to help you do this.

Elementary Data Structures**: Learn how to implement Linked List, Stacks, and Queues in Kotlin.

Trees: Learn everything you need about Trees — in particular, Binary Trees, AVL Trees, as well as Binary Search and much more.

Sorting Algorithms: Sorting algorithms are critical for any developer. Learn to implement the main sorting algorithms, using the tools provided by Kotlin.

Graphs: Have you ever heard of Dijkstra and the calculation of the shortest path between two different points? Learn about Graphs and how to use them to solve the most useful and important algorithms.

About the Tutorial Team

The Tutorial Team is a group of app developers and authors who write tutorials at the popular website raywenderlich.com. We take pride in making sure each tutorial we write holds to the highest standards of quality. We want our tutorials to be well written, easy to follow, and fun. If you've enjoyed the tutorials we've written in the past, you're in for a treat. The tutorials we've written for this book are some of our best yet — and this book contains detailed technical knowledge you simply won't be able to find anywhere else.

✦ Table of Contents

Book License
Who This Book Is For
What You Need
Book Source Code & Forums
About the Cover
Chapter 1: Kotlin & Kotlin Standard Library
Introduction to Kotlin
The Kotlin Standard Library
Key points
Chapter 2: Complexity
Time complexity
Other time complexities
Comparing time complexity
Space complexity
Key points
Chapter 3: Linked List
Node
LinkedList
Adding values to the list
Removing values from the list
Kotlin collection interfaces
Becoming a Kotlin mutable collection
Challenges
Key points
Chapter 4: Stack Data Structures
Stack operations
Implementation
push and pop operations
Challenges
Key points
Chapter 5: Queues
Common operations
Example of a queue
List-based implementation
Doubly linked list implementation
Ring buffer implementation
Double-stack implementation
Challenges
Key points
Chapter 6: Trees
Terminology
Implementation
Traversal algorithms
Challenges
Key points
Chapter 7: Binary Trees
Implementation
Traversal algorithms
Challenges
Key points
Chapter 8: Binary Search Trees
Case study: array vs. BST
Implementation
Challenges
Key points
Chapter 9: AVL Trees
Understanding balance
Implementation
Challenges
Key points
Chapter 10: Tries
Example
Implementation
Challenges
Key points
Chapter 11: Binary Search
Example
Implementation
Challenges
Key points
Chapter 12: The Heap Data Structure
What is a heap?
The heap property
Heap applications
Common heap operations
Sorting and comparing
How do you represent a heap?
Inserting into a heap
Removing from a heap
Removing from an arbitrary index
Searching for an element in a heap
Heapify an array
Testing
Challenges
Key points
Chapter 13: Priority Queues
Applications
Common operations
Implementation
Challenges
Key points
Chapter 14: O(n²) Sorting Algorithms
Bubble sort
Selection sort
Insertion sort
Generalization
Challenges
Key points
Chapter 15: Merge Sort
Implementation
Performance
Challenges
Key points
Chapter 16: Radix Sort
Example
Implementation
Challenges
Key points
Chapter 17: Heap Sort
Getting started
Example
Implementation
Performance
Challenges
Key points
Chapter 18: Quicksort
Example
Partitioning strategies
Effects of a bad pivot choice
Challenges
Key points
Chapter 19: Graphs
Weighted graphs
Common operations
Defining a vertex
Defining an edge
Adjacency list
Implementation
Adjacency matrix
Implementation
Graph analysis
Challenges
Key points
Chapter 20: Breadth-First Search
Example
Implementation
Performance
Challenges
Key points
Chapter 21: Depth-First Search
DFS example
Implementation
Performance
Challenges
Key points
Chapter 22: Dijkstra’s Algorithm
Example
Implementation
Trying out your code
Performance
Challenges
Key points
Chapter 23: Prim’s Algorithm
Example
Implementation
Testing your code
Performance
Challenges
Key points
Conclusion

✦ Subjects

Kotlin