Data Structures and Algorithms in Swift: Implement Stacks, Queues, Dictionaries, and Lists in Your Apps

Download as pdf or txt
Download as pdf or txt
You are on page 1of 11

Data Structures and

Algorithms in Swift
Implement Stacks, Queues,
Dictionaries, and Lists
in Your Apps

Elshad Karimov
Data Structures and Algorithms in Swift: Implement Stacks, Queues,
Dictionaries, and Lists in Your Apps
Elshad Karimov
New York, New York, USA

ISBN-13 (pbk): 978-1-4842-5768-5 ISBN-13 (electronic): 978-1-4842-5769-2


https://doi.org/10.1007/978-1-4842-5769-2

Copyright © 2020 by Elshad Karimov


This work is subject to copyright. All rights are reserved by the Publisher, whether the whole
or part of the material is concerned, specifically the rights of translation, reprinting, reuse of
illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical
way, and transmission or information storage and retrieval, electronic adaptation, computer
software, or by similar or dissimilar methodology now known or hereafter developed.
Trademarked names, logos, and images may appear in this book. Rather than use a
trademark symbol with every occurrence of a trademarked name, logo, or image we use the
names, logos, and images only in an editorial fashion and to the benefit of the trademark
owner, with no intention of infringement of the trademark.
The use in this publication of trade names, trademarks, service marks, and similar terms,
even if they are not identified as such, is not to be taken as an expression of opinion as to
whether or not they are subject to proprietary rights.
While the advice and information in this book are believed to be true and accurate at the
date of publication, neither the authors nor the editors nor the publisher can accept any
legal responsibility for any errors or omissions that may be made. The publisher makes no
warranty, express or implied, with respect to the material contained herein.
Managing Director, Apress Media LLC: Welmoed Spahr
Acquisitions Editor: Aaron Black
Development Editor: James Markham
Coordinating Editor: Jessica Vakili
Distributed to the book trade worldwide by Springer Science+Business Media New York,
233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201)
348-4505, e-mail [email protected], or visit www.springeronline.com. Apress
Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business
Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation.
For information on translations, please e-mail [email protected], or visit http://www.
apress.com/rights-permissions.
Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook
versions and licenses are also available for most titles. For more information, reference our
Print and eBook Bulk Sales web page at http://www.apress.com/bulk-sales.
Any source code or other supplementary material referenced by the author in this book is
available to readers on GitHub via the book’s product page, located at www.apress.com/
978-1-4842-5768-5. For more detailed information, please visit http://www.apress.com/
source-code.
Printed on acid-free paper
Table of Contents
About the Author���������������������������������������������������������������������������������xi

About the Technical Reviewer�����������������������������������������������������������xiii

Chapter 1: Arrays����������������������������������������������������������������������������������1
Introduction������������������������������������������������������������������������������������������������1
Main Features of Arrays�����������������������������������������������������������������������������2
Retrieving Elements from an Array������������������������������������������������������������4
Adding Elements to an Array����������������������������������������������������������������������5
Removing Elements from an Array�������������������������������������������������������������6
Built-in Functions and Properties���������������������������������������������������������������6
isEmpty�������������������������������������������������������������������������������������������������6
First and Last����������������������������������������������������������������������������������������7
Reversed and Reverse��������������������������������������������������������������������������7
Count�����������������������������������������������������������������������������������������������������7
Conclusion��������������������������������������������������������������������������������������������������8

Chapter 2: Dictionaries�������������������������������������������������������������������������9
Introduction������������������������������������������������������������������������������������������������9
Accessing Values in a Dictionary��������������������������������������������������������������11
Adding/Modifying to a Dictionary�������������������������������������������������������������13
Removing a Value from a Dictionary��������������������������������������������������������14

iii
Table of Contents

Built-in Functions and Properties�������������������������������������������������������������14


isEmpty�����������������������������������������������������������������������������������������������14
First�����������������������������������������������������������������������������������������������������14
Count���������������������������������������������������������������������������������������������������15
Keys�����������������������������������������������������������������������������������������������������15
Conclusion������������������������������������������������������������������������������������������������15

Chapter 3: Sets�����������������������������������������������������������������������������������17
Accessing, Adding, and Removing an Element of a Set���������������������������17
Accessing an Element������������������������������������������������������������������������������17
Adding an Element�����������������������������������������������������������������������������������19
Removing Elements����������������������������������������������������������������������������������19
Set Operations������������������������������������������������������������������������������������������20
Comparison Operations�����������������������������������������������������������������������20
Membership and Equality Operations������������������������������������������������������24
Set Equality�����������������������������������������������������������������������������������������24
Set Membership����������������������������������������������������������������������������������24
Conclusion������������������������������������������������������������������������������������������������26

Chapter 4: Stacks�������������������������������������������������������������������������������27
Using Swift with Stacks���������������������������������������������������������������������������28
Stack Structures���������������������������������������������������������������������������������������31
Stack Extensions��������������������������������������������������������������������������������������32
Conclusion������������������������������������������������������������������������������������������������32
Chapter 5: Queue��������������������������������������������������������������������������������33
Implementation����������������������������������������������������������������������������������������35
Conclusion������������������������������������������������������������������������������������������������40

iv
Table of Contents

Chapter 6: Linked Lists�����������������������������������������������������������������������41


Implementation����������������������������������������������������������������������������������������42
Node����������������������������������������������������������������������������������������������������43
Singly Linked List�������������������������������������������������������������������������������������43
Adding New Values to a Linked List���������������������������������������������������������44
Append������������������������������������������������������������������������������������������������45
Insert���������������������������������������������������������������������������������������������������46
Removing New Values from a Linked List������������������������������������������������47
removeLast������������������������������������������������������������������������������������������48
remove(at:)������������������������������������������������������������������������������������������49
Doubly Linked List������������������������������������������������������������������������������������50
Append������������������������������������������������������������������������������������������������52
Remove Node Method�������������������������������������������������������������������������53
Remove(at:)�����������������������������������������������������������������������������������������53
Summary��������������������������������������������������������������������������������������������������54

Chapter 7: Hash Table�������������������������������������������������������������������������55


Creating Hash Table����������������������������������������������������������������������������������56
Retrieving Data from a Hash Table������������������������������������������������������57
Updating a Value in a Hash Table�������������������������������������������������������������58
Removing a Value from a Hash Table�������������������������������������������������������59
Summary��������������������������������������������������������������������������������������������������60

Chapter 8: Trees����������������������������������������������������������������������������������61
Creation����������������������������������������������������������������������������������������������������62
Insertion����������������������������������������������������������������������������������������������63
Searching Data������������������������������������������������������������������������������������64
Conclusion������������������������������������������������������������������������������������������������66

v
Table of Contents

Chapter 9: Trie Data Structure������������������������������������������������������������67


Why a Trie?�����������������������������������������������������������������������������������������������67
How It Works��������������������������������������������������������������������������������������������68
Implementation����������������������������������������������������������������������������������������69
Insert���������������������������������������������������������������������������������������������������70
Query���������������������������������������������������������������������������������������������������71
Remove�����������������������������������������������������������������������������������������������72
Conclusion������������������������������������������������������������������������������������������������75

Chapter 10: Binary Tree����������������������������������������������������������������������77


Binary Tree Primer������������������������������������������������������������������������������������77
Properties of Binary Tree���������������������������������������������������������������������78
Types of Binary Trees��������������������������������������������������������������������������78
Implementation����������������������������������������������������������������������������������������81
Tree Traversal (Also Known As Tree Search)���������������������������������������������81
In-Order Traversal��������������������������������������������������������������������������������82
Pre-Order Traversal�����������������������������������������������������������������������������83
Post-Order Traversal����������������������������������������������������������������������������85
Conclusion������������������������������������������������������������������������������������������������86

Chapter 11: Binary Search Tree����������������������������������������������������������87


Implementation����������������������������������������������������������������������������������������88
Insert��������������������������������������������������������������������������������������������������������89
Search������������������������������������������������������������������������������������������������������92
Example�����������������������������������������������������������������������������������������������94

vi
Table of Contents

Delete�������������������������������������������������������������������������������������������������������94
Deleting a Leaf������������������������������������������������������������������������������������94
Deleting a Node with One Child�����������������������������������������������������������95
Deleting a Node with Two Children�����������������������������������������������������96
Conclusion����������������������������������������������������������������������������������������������100

Chapter 12: Red–Black Tree�������������������������������������������������������������101


Implementation��������������������������������������������������������������������������������������102
Rotation���������������������������������������������������������������������������������������������105
Insertion��������������������������������������������������������������������������������������������109
Deletion���������������������������������������������������������������������������������������������115
Conclusion����������������������������������������������������������������������������������������������120

Chapter 13: Big O������������������������������������������������������������������������������121


Time Complexity�������������������������������������������������������������������������������������121
Space Complexity�����������������������������������������������������������������������������������124
Drop the Constants and Nondominant Terms�����������������������������������������125
How to Calculate Complexities?�������������������������������������������������������������126
Add vs. Multiply��������������������������������������������������������������������������������������128
Amortized Time��������������������������������������������������������������������������������������129
Log N Runtimes���������������������������������������������������������������������������������130
Recursive Runtimes��������������������������������������������������������������������������131
Conclusion����������������������������������������������������������������������������������������������132

Chapter 14: Sorting Algorithms��������������������������������������������������������133


Bubble Sort���������������������������������������������������������������������������������������������133
Implementation���������������������������������������������������������������������������������136

vii
Table of Contents

Selection Sort�����������������������������������������������������������������������������������������137
Implementation���������������������������������������������������������������������������������139
Insertion Sort������������������������������������������������������������������������������������������140
Implementation���������������������������������������������������������������������������������142
Merge Sort���������������������������������������������������������������������������������������������143
Implementation���������������������������������������������������������������������������������146
Quick Sort�����������������������������������������������������������������������������������������������148
Implementation���������������������������������������������������������������������������������151
Pivot Selection����������������������������������������������������������������������������������152
Conclusion����������������������������������������������������������������������������������������������153

Chapter 15: Search Algorithms��������������������������������������������������������155


Linear Search�����������������������������������������������������������������������������������������155
Implementation���������������������������������������������������������������������������������157
Binary Search�����������������������������������������������������������������������������������������158
Implementation���������������������������������������������������������������������������������160
Conclusion����������������������������������������������������������������������������������������������161

Chapter 16: Graph Algorithms����������������������������������������������������������163


Directed Graphs��������������������������������������������������������������������������������������164
Undirected Graphs����������������������������������������������������������������������������������164
Weighted Graphs������������������������������������������������������������������������������������165
Breadth-First Search (BFS)��������������������������������������������������������������������166
Implementation���������������������������������������������������������������������������������171
Depth-First Search (DFS)������������������������������������������������������������������������174
Implementation���������������������������������������������������������������������������������179

viii
Table of Contents

Dijkstra’s Algorithm��������������������������������������������������������������������������������182
Implementation���������������������������������������������������������������������������������190
Algorithm�������������������������������������������������������������������������������������������191
Conclusion����������������������������������������������������������������������������������������������194

Chapter 17: Choosing the Best Algorithm����������������������������������������195


Sorting Algorithms����������������������������������������������������������������������������������196
Bubble Sort���������������������������������������������������������������������������������������196
Selection Sort������������������������������������������������������������������������������������196
Insertion Sort�������������������������������������������������������������������������������������197
Merge Sort����������������������������������������������������������������������������������������197
Quick Sort������������������������������������������������������������������������������������������197
Search Algorithms����������������������������������������������������������������������������������198
Linear Search vs. Binary Search�������������������������������������������������������198
Graph Search Algorithms (GSA)��������������������������������������������������������������200
Dijkstra’s Algorithm��������������������������������������������������������������������������������201

Index�������������������������������������������������������������������������������������������������203

ix
About the Author
Elshad Karimov is an experienced programmer with more than 8 years
experience of different programming languages and a solid background in
iOS development as well as Oracle, SQL, C#, Java, Python and HTML/CSS.
He’s familiar with the performance limits and characteristics of Swift and
the nature and function of embedded databases and system datastores.

xi
About the Technical Reviewer
Felipe Laso is a Senior Systems Engineer working at Lextech Global
Services. He’s also an aspiring game designer/programmer. You can follow
him on Twitter @iFeliLM or on his blog.

xiii

You might also like