Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
100% found this document useful (7 votes)
24 views

JavaScript Data Structures and Algorithms An Introduction to Understanding and Implementing Core Data Structure and Algorithm Fundamentals 1st Editon by Sammie Bae ISBN 1484239873 9781484239872 - The complete ebook is available for download with one click

The document provides information about the book 'JavaScript Data Structures and Algorithms' by Sammie Bae, including its ISBN and a link to download the full version. It also lists several other recommended books on data structures and algorithms, along with their respective download links. Additionally, it includes details about the book's copyright, contributors, and a brief overview of its contents.

Uploaded by

bolsomaiol
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
100% found this document useful (7 votes)
24 views

JavaScript Data Structures and Algorithms An Introduction to Understanding and Implementing Core Data Structure and Algorithm Fundamentals 1st Editon by Sammie Bae ISBN 1484239873 9781484239872 - The complete ebook is available for download with one click

The document provides information about the book 'JavaScript Data Structures and Algorithms' by Sammie Bae, including its ISBN and a link to download the full version. It also lists several other recommended books on data structures and algorithms, along with their respective download links. Additionally, it includes details about the book's copyright, contributors, and a brief overview of its contents.

Uploaded by

bolsomaiol
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 80

Visit ebookball.

com to download the full version and


explore more ebook or textbook

JavaScript Data Structures and Algorithms An


Introduction to Understanding and Implementing
Core Data Structure and Algorithm Fundamentals 1st
Editon by Sammie Bae ISBN 1484239873
9781484239872
_____ Click the link below to download _____
https://ebookball.com/product/javascript-data-structures-
and-algorithms-an-introduction-to-understanding-and-
implementing-core-data-structure-and-algorithm-
fundamentals-1st-editon-by-sammie-bae-
isbn-1484239873-9781484239872-15798/

Explore and download more ebook or textbook at ebookball.com


Here are some recommended products that we believe you will be
interested in. You can click the link to download.

A Practical Introduction to Data Structures And Algorithm


Analysis 3rd Edition by Clifford Shaffer

https://ebookball.com/product/a-practical-introduction-to-data-
structures-and-algorithm-analysis-3rd-edition-by-clifford-
shaffer-15310/

Data Structures and Algorithms Made Easy Data Structure


and Algorithmic Puzzles 5th Edition by Careermonk
Publications, Narasimha Karumanchi ISBN 9788193245279
https://ebookball.com/product/data-structures-and-algorithms-made-
easy-data-structure-and-algorithmic-puzzles-5th-edition-by-careermonk-
publications-narasimha-karumanchi-isbn-9788193245279-15800/

Data Structures and Algorithms 1st Edition by Alfred Aho


ISBN 0201000237 9780201000238

https://ebookball.com/product/data-structures-and-algorithms-1st-
edition-by-alfred-aho-isbn-0201000237-9780201000238-25072/

Data Structures and Algorithm Analysis in JavaTM 3rd


edition by Mark Weiss 9780133465013 0133465012

https://ebookball.com/product/data-structures-and-algorithm-analysis-
in-javatm-3rd-edition-by-mark-weiss-9780133465013-0133465012-18710/
Data Structures And Algorithm Analysis in C 4th Edition by
Mark Weiss 013284737X 9780132847377

https://ebookball.com/product/data-structures-and-algorithm-analysis-
in-c-4th-edition-by-mark-weiss-013284737x-9780132847377-15292/

Data Structures and Algorithms in Java 1st Edition by


Peter Drake ISBN 0131469142 9780131469143

https://ebookball.com/product/data-structures-and-algorithms-in-
java-1st-edition-by-peter-drake-isbn-0131469142-9780131469143-12422/

Data Structures and Algorithms in C 1st edition by Adam


Drozdek ASIN B002WLXMBY

https://ebookball.com/product/data-structures-and-algorithms-in-c-1st-
edition-by-adam-drozdek-asin-b002wlxmby-25076/

Data Structures and Algorithm Analysis in C++ 3rd edition


by Clifford Shaffer ISBN 048648582X 978-0486485829

https://ebookball.com/product/data-structures-and-algorithm-analysis-
in-c-3rd-edition-by-clifford-shaffer-
isbn-048648582x-978-0486485829-16486/

Data Structures Algorithms and Applications in C++ 1st


edition by Adam Drozdek ISBN 1133608426 9781133608424

https://ebookball.com/product/data-structures-algorithms-and-
applications-in-c-1st-edition-by-adam-drozdek-
isbn-1133608426-9781133608424-17250/
JavaScript Data
Structures and
Algorithms
An Introduction to Understanding and
Implementing Core Data Structure and
Algorithm Fundamentals

Sammie Bae
JavaScript Data Structures
and Algorithms
An Introduction to Understanding
and Implementing Core Data
Structure and Algorithm
Fundamentals

Sammie Bae
JavaScript Data Structures and Algorithms
Sammie Bae
Hamilton, ON, Canada

ISBN-13 (pbk): 978-1-4842-3987-2 ISBN-13 (electronic): 978-1-4842-3988-9


https://doi.org/10.1007/978-1-4842-3988-9
Library of Congress Control Number: 2019930417

Copyright © 2019 by Sammie Bae


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: Louise Corrigan
Development Editor: Chris Nelson
Coordinating Editor: Nancy Chen
Cover designed by eStudioCalamar
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 orders-ny@springer-
sbm.com, 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 rights@apress.com, or visit 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 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/9781484239872. For more
detailed information, please visit www.apress.com/source-code.
Printed on acid-free paper
This book is dedicated to Dr. Hamid R. Tizhoosh for inspiring
me in my studies and to my mother, Min Kyoung Seo, for her
kindness and support.
Table of Contents
About the Author �����������������������������������������������������������������������������������������������������xv

About the Technical Reviewer �������������������������������������������������������������������������������xvii

Acknowledgments ��������������������������������������������������������������������������������������������������xix

Introduction ������������������������������������������������������������������������������������������������������������xxi

Chapter 1: Big-O Notation ����������������������������������������������������������������������������������������� 1


Big-O Notation Primer ������������������������������������������������������������������������������������������������������������������� 1
Common Examples ������������������������������������������������������������������������������������������������������������������ 2
Rules of Big-O Notation����������������������������������������������������������������������������������������������������������������� 4
Coefficient Rule: “Get Rid of Constants”���������������������������������������������������������������������������������� 5
Sum Rule: “Add Big-Os Up” ����������������������������������������������������������������������������������������������������� 6
Product Rule: “Multiply Big-Os” ���������������������������������������������������������������������������������������������� 7
Polynomial Rule: “Big-O to the Power of k”����������������������������������������������������������������������������� 8
Summary��������������������������������������������������������������������������������������������������������������������������������������� 8
Exercises ��������������������������������������������������������������������������������������������������������������������������������������� 9
Answers��������������������������������������������������������������������������������������������������������������������������������� 11

Chapter 2: JavaScript: Unique Parts ����������������������������������������������������������������������� 13


JavaScript Scope ������������������������������������������������������������������������������������������������������������������������ 13
Global Declaration: Global Scope������������������������������������������������������������������������������������������� 13
Declaration with var: Functional Scope ��������������������������������������������������������������������������������� 13
Declaration with let: Block Scope ������������������������������������������������������������������������������������������ 15

v
Table of Contents

Equality and Types���������������������������������������������������������������������������������������������������������������������� 16


Variable Types������������������������������������������������������������������������������������������������������������������������ 16
Truthy/Falsey Check�������������������������������������������������������������������������������������������������������������� 17
=== vs ==���������������������������������������������������������������������������������������������������������������������������� 18
Objects���������������������������������������������������������������������������������������������������������������������������������� 18
Summary������������������������������������������������������������������������������������������������������������������������������������ 20

Chapter 3: JavaScript Numbers������������������������������������������������������������������������������ 21


Number System�������������������������������������������������������������������������������������������������������������������������� 21
JavaScript Number Object���������������������������������������������������������������������������������������������������������� 23
Integer Rounding������������������������������������������������������������������������������������������������������������������� 23
Number.EPSILON������������������������������������������������������������������������������������������������������������������� 24
Maximums����������������������������������������������������������������������������������������������������������������������������� 24
Minimums������������������������������������������������������������������������������������������������������������������������������ 25
Size Summary����������������������������������������������������������������������������������������������������������������������� 26
Number Algorithms���������������������������������������������������������������������������������������������������������������� 26
Prime Factorization��������������������������������������������������������������������������������������������������������������� 28
Random Number Generator�������������������������������������������������������������������������������������������������������� 29
Exercises������������������������������������������������������������������������������������������������������������������������������������� 29
Summary������������������������������������������������������������������������������������������������������������������������������������ 34

Chapter 4: JavaScript Strings��������������������������������������������������������������������������������� 35


JavaScript String Primitive��������������������������������������������������������������������������������������������������������� 35
String Access������������������������������������������������������������������������������������������������������������������������� 35
String Comparison����������������������������������������������������������������������������������������������������������������� 36
String Search������������������������������������������������������������������������������������������������������������������������� 36
String Decomposition������������������������������������������������������������������������������������������������������������ 38
String Replace����������������������������������������������������������������������������������������������������������������������� 38
Regular Expressions������������������������������������������������������������������������������������������������������������������� 38
Basic Regex��������������������������������������������������������������������������������������������������������������������������� 39
Commonly Used Regexes������������������������������������������������������������������������������������������������������ 39
Encoding������������������������������������������������������������������������������������������������������������������������������������� 41
Base64 Encoding������������������������������������������������������������������������������������������������������������������� 42

vi
Table of Contents

String Shortening������������������������������������������������������������������������������������������������������������������������ 43
Encryption����������������������������������������������������������������������������������������������������������������������������������� 45
RSA Encryption���������������������������������������������������������������������������������������������������������������������� 46
Summary������������������������������������������������������������������������������������������������������������������������������� 50

Chapter 5: JavaScript Arrays��������������������������������������������������������������������������������� 53


Introducing Arrays����������������������������������������������������������������������������������������������������������������������� 53
Insertion�������������������������������������������������������������������������������������������������������������������������������� 53
Deletion��������������������������������������������������������������������������������������������������������������������������������� 54
Access����������������������������������������������������������������������������������������������������������������������������������� 54
Iteration��������������������������������������������������������������������������������������������������������������������������������������� 54
for (Variables; Condition; Modification)��������������������������������������������������������������������������������� 55
for ( in )���������������������������������������������������������������������������������������������������������������������������������� 56
for ( of )���������������������������������������������������������������������������������������������������������������������������������� 56
forEach( )�������������������������������������������������������������������������������������������������������������������������������� 56
Helper Functions������������������������������������������������������������������������������������������������������������������������� 57
.slice(begin,end)�������������������������������������������������������������������������������������������������������������������� 57
.splice(begin,size,element1,element2…)������������������������������������������������������������������������������ 58
.concat()��������������������������������������������������������������������������������������������������������������������������������� 59
.length Property��������������������������������������������������������������������������������������������������������������������� 59
Spread Operator�������������������������������������������������������������������������������������������������������������������� 60
Exercises������������������������������������������������������������������������������������������������������������������������������������� 60
JavaScript Functional Array Methods����������������������������������������������������������������������������������������� 67
Map��������������������������������������������������������������������������������������������������������������������������������������� 67
Filter�������������������������������������������������������������������������������������������������������������������������������������� 68
Reduce���������������������������������������������������������������������������������������������������������������������������������� 68
Multidimensional Arrays������������������������������������������������������������������������������������������������������������� 68
Exercises������������������������������������������������������������������������������������������������������������������������������������� 71
Summary������������������������������������������������������������������������������������������������������������������������������������ 81

vii
Table of Contents

Chapter 6: JavaScript Objects�������������������������������������������������������������������������������� 83


JavaScript Object Property��������������������������������������������������������������������������������������������������������� 83
Prototypal Inheritance����������������������������������������������������������������������������������������������������������������� 84
Constructor and Variables����������������������������������������������������������������������������������������������������������� 85
Summary������������������������������������������������������������������������������������������������������������������������������������ 86
Exercises������������������������������������������������������������������������������������������������������������������������������������� 87

Chapter 7: JavaScript Memory Management��������������������������������������������������������� 89


Memory Leaks���������������������������������������������������������������������������������������������������������������������������� 89
Reference to an Object���������������������������������������������������������������������������������������������������������� 89
Leaking DOM������������������������������������������������������������������������������������������������������������������������� 90
Global window Object������������������������������������������������������������������������������������������������������������ 91
Limiting Object References��������������������������������������������������������������������������������������������������� 92
The delete Operator��������������������������������������������������������������������������������������������������������������� 92
Summary������������������������������������������������������������������������������������������������������������������������������������ 93
Exercises������������������������������������������������������������������������������������������������������������������������������������� 93

Chapter 8: Recursion���������������������������������������������������������������������������������������������� 99
Introducing Recursion����������������������������������������������������������������������������������������������������������������� 99
Rules of Recursion�������������������������������������������������������������������������������������������������������������������� 100
Base Case���������������������������������������������������������������������������������������������������������������������������� 100
Divide-and-Conquer Method����������������������������������������������������������������������������������������������� 101
Classic Example: Fibonacci Sequence�������������������������������������������������������������������������������� 101
Fibonacci Sequence: Tail Recursion������������������������������������������������������������������������������������ 102
Pascal’s Triangle������������������������������������������������������������������������������������������������������������������ 103
Big-O for Recursion������������������������������������������������������������������������������������������������������������������� 105
Recurrence Relations���������������������������������������������������������������������������������������������������������� 105
Master Theorem������������������������������������������������������������������������������������������������������������������ 106
Recursive Call Stack Memory��������������������������������������������������������������������������������������������������� 107
Summary���������������������������������������������������������������������������������������������������������������������������������� 109
Exercises����������������������������������������������������������������������������������������������������������������������������������� 109

viii
Table of Contents

Chapter 9: Sets����������������������������������������������������������������������������������������������������� 117


Introducing Sets������������������������������������������������������������������������������������������������������������������������ 117
Set Operations�������������������������������������������������������������������������������������������������������������������������� 117
Insertion������������������������������������������������������������������������������������������������������������������������������ 118
Deletion������������������������������������������������������������������������������������������������������������������������������� 118
Contains������������������������������������������������������������������������������������������������������������������������������� 118
Other Utility Functions�������������������������������������������������������������������������������������������������������������� 119
Intersection�������������������������������������������������������������������������������������������������������������������������� 119
isSuperSet��������������������������������������������������������������������������������������������������������������������������� 119
Union����������������������������������������������������������������������������������������������������������������������������������� 120
Difference���������������������������������������������������������������������������������������������������������������������������� 120
Summary���������������������������������������������������������������������������������������������������������������������������������� 121
Exercises����������������������������������������������������������������������������������������������������������������������������������� 122

Chapter 10: Searching and Sorting���������������������������������������������������������������������� 125


Searching���������������������������������������������������������������������������������������������������������������������������������� 125
Linear Search���������������������������������������������������������������������������������������������������������������������� 125
Binary Search���������������������������������������������������������������������������������������������������������������������� 127
Sorting�������������������������������������������������������������������������������������������������������������������������������������� 129
Bubble Sort�������������������������������������������������������������������������������������������������������������������������� 129
Selection Sort���������������������������������������������������������������������������������������������������������������������� 131
Insertion Sort����������������������������������������������������������������������������������������������������������������������� 132
Quicksort����������������������������������������������������������������������������������������������������������������������������� 134
Quickselect�������������������������������������������������������������������������������������������������������������������������� 137
Mergesort���������������������������������������������������������������������������������������������������������������������������� 138
Count Sort���������������������������������������������������������������������������������������������������������������������������� 140
JavaScript’s Built-in Sort����������������������������������������������������������������������������������������������������� 141
Summary���������������������������������������������������������������������������������������������������������������������������������� 142
Exercises����������������������������������������������������������������������������������������������������������������������������������� 143

ix
Table of Contents

Chapter 11: Hash Tables��������������������������������������������������������������������������������������� 151


Introducing Hash Tables������������������������������������������������������������������������������������������������������������ 151
Hashing Techniques������������������������������������������������������������������������������������������������������������������ 152
Prime Number Hashing������������������������������������������������������������������������������������������������������� 152
Probing�������������������������������������������������������������������������������������������������������������������������������� 154
Rehashing/Double-Hashing������������������������������������������������������������������������������������������������� 155
Hash Table Implementation������������������������������������������������������������������������������������������������������� 156
Using Linear Probing����������������������������������������������������������������������������������������������������������� 156
Using Quadratic Probing������������������������������������������������������������������������������������������������������ 158
Using Double-Hashing with Linear Probing������������������������������������������������������������������������� 160
Summary���������������������������������������������������������������������������������������������������������������������������������� 161

Chapter 12: Stacks and Queues���������������������������������������������������������������������������� 163


Stacks��������������������������������������������������������������������������������������������������������������������������������������� 163
Peek������������������������������������������������������������������������������������������������������������������������������������� 165
Insertion������������������������������������������������������������������������������������������������������������������������������ 165
Deletion������������������������������������������������������������������������������������������������������������������������������� 166
Access��������������������������������������������������������������������������������������������������������������������������������� 166
Search��������������������������������������������������������������������������������������������������������������������������������� 167
Queues�������������������������������������������������������������������������������������������������������������������������������������� 167
Peek������������������������������������������������������������������������������������������������������������������������������������� 169
Insertion������������������������������������������������������������������������������������������������������������������������������ 169
Deletion������������������������������������������������������������������������������������������������������������������������������� 169
Access��������������������������������������������������������������������������������������������������������������������������������� 170
Search��������������������������������������������������������������������������������������������������������������������������������� 171
Summary���������������������������������������������������������������������������������������������������������������������������������� 171
Exercises����������������������������������������������������������������������������������������������������������������������������������� 172

Chapter 13: Linked Lists��������������������������������������������������������������������������������������� 179


Singly Linked Lists�������������������������������������������������������������������������������������������������������������������� 179
Insertion������������������������������������������������������������������������������������������������������������������������������ 180
Deletion by Value����������������������������������������������������������������������������������������������������������������� 181

x
Table of Contents

Deletion at the Head������������������������������������������������������������������������������������������������������������ 182


Search��������������������������������������������������������������������������������������������������������������������������������� 183
Doubly Linked Lists������������������������������������������������������������������������������������������������������������������� 184
Insertion at the Head����������������������������������������������������������������������������������������������������������� 185
Insertion at the Tail�������������������������������������������������������������������������������������������������������������� 185
Deletion at the Head������������������������������������������������������������������������������������������������������������ 186
Deletion at the Tail��������������������������������������������������������������������������������������������������������������� 187
Search��������������������������������������������������������������������������������������������������������������������������������� 188
Summary���������������������������������������������������������������������������������������������������������������������������������� 189
Exercises����������������������������������������������������������������������������������������������������������������������������������� 190

Chapter 14: Caching��������������������������������������������������������������������������������������������� 193


Understanding Caching������������������������������������������������������������������������������������������������������������� 193
Least Frequently Used Caching������������������������������������������������������������������������������������������������� 194
Least Recently Used Caching���������������������������������������������������������������������������������������������������� 199
Summary���������������������������������������������������������������������������������������������������������������������������������� 203

Chapter 15: Trees�������������������������������������������������������������������������������������������������� 205


General Tree Structure�������������������������������������������������������������������������������������������������������������� 205
Binary Trees������������������������������������������������������������������������������������������������������������������������������ 206
Tree Traversal���������������������������������������������������������������������������������������������������������������������������� 207
Pre-order Traversal�������������������������������������������������������������������������������������������������������������� 207
In-Order Traversal���������������������������������������������������������������������������������������������������������������� 209
Post-order Traversal������������������������������������������������������������������������������������������������������������ 211
Level-Order Traversal���������������������������������������������������������������������������������������������������������� 212
Tree Traversal Summary������������������������������������������������������������������������������������������������������ 214
Binary Search Trees������������������������������������������������������������������������������������������������������������������ 214
Insertion������������������������������������������������������������������������������������������������������������������������������ 216
Deletion������������������������������������������������������������������������������������������������������������������������������� 218
Search��������������������������������������������������������������������������������������������������������������������������������� 220

xi
Table of Contents

AVL Trees����������������������������������������������������������������������������������������������������������������������������������� 221


Single Rotation�������������������������������������������������������������������������������������������������������������������� 221
Double Rotation������������������������������������������������������������������������������������������������������������������� 225
Balancing the Tree��������������������������������������������������������������������������������������������������������������� 228
Insertion������������������������������������������������������������������������������������������������������������������������������ 229
Putting It All Together: AVL Tree Example����������������������������������������������������������������������������� 231
Summary���������������������������������������������������������������������������������������������������������������������������������� 234
Exercises����������������������������������������������������������������������������������������������������������������������������������� 234

Chapter 16: Heaps������������������������������������������������������������������������������������������������ 245


Understanding Heaps���������������������������������������������������������������������������������������������������������������� 245
Max-Heap���������������������������������������������������������������������������������������������������������������������������� 246
Min-Heap����������������������������������������������������������������������������������������������������������������������������� 247
Binary Heap Array Index Structure�������������������������������������������������������������������������������������������� 248
Percolation: Bubbling Up and Down������������������������������������������������������������������������������������ 250
Implementing Percolation��������������������������������������������������������������������������������������������������� 253
Max-Heap Example������������������������������������������������������������������������������������������������������������� 254
Min-Heap Complete Implementation���������������������������������������������������������������������������������������� 258
Max-Heap Complete Implementation��������������������������������������������������������������������������������������� 259
Heap Sort���������������������������������������������������������������������������������������������������������������������������������� 261
Ascending-Order Sort (Min-Heap)��������������������������������������������������������������������������������������� 261
Descending-Order Sort (Max-Heap)������������������������������������������������������������������������������������ 264
Summary���������������������������������������������������������������������������������������������������������������������������������� 267
Exercises����������������������������������������������������������������������������������������������������������������������������������� 268

Chapter 17: Graphs����������������������������������������������������������������������������������������������� 273


Graph Basics����������������������������������������������������������������������������������������������������������������������������� 273
Undirected Graphs�������������������������������������������������������������������������������������������������������������������� 277
Adding Edges and Vertices�������������������������������������������������������������������������������������������������� 279
Removing Edges and Vertices��������������������������������������������������������������������������������������������� 280
Directed Graphs������������������������������������������������������������������������������������������������������������������������ 282

xii
Table of Contents

Graph Traversal������������������������������������������������������������������������������������������������������������������������� 285


Breadth-First Search����������������������������������������������������������������������������������������������������������� 286
Depth-First Search�������������������������������������������������������������������������������������������������������������� 289
Weighted Graphs and Shortest Path����������������������������������������������������������������������������������������� 293
Graphs with Weighted Edges����������������������������������������������������������������������������������������������� 293
Dijkstra’s Algorithm: Shortest Path�������������������������������������������������������������������������������������� 294
Topological Sort������������������������������������������������������������������������������������������������������������������������ 298
Summary���������������������������������������������������������������������������������������������������������������������������������� 300

Chapter 18: Advanced Strings������������������������������������������������������������������������������ 303


Trie (Prefix Tree)������������������������������������������������������������������������������������������������������������������������ 303
Boyer–Moore String Search������������������������������������������������������������������������������������������������������ 307
Knuth–Morris–Pratt String Search�������������������������������������������������������������������������������������������� 311
Rabin–Karp Search������������������������������������������������������������������������������������������������������������������� 316
The Rabin Fingerprint���������������������������������������������������������������������������������������������������������� 316
Applications in Real Life������������������������������������������������������������������������������������������������������ 319
Summary���������������������������������������������������������������������������������������������������������������������������������� 320

Chapter 19: Dynamic Programming��������������������������������������������������������������������� 321


Motivations for Dynamic Programming������������������������������������������������������������������������������������ 321
Rules of Dynamic Programming����������������������������������������������������������������������������������������������� 323
Overlapping Subproblems��������������������������������������������������������������������������������������������������� 323
Optimal Substructure���������������������������������������������������������������������������������������������������������� 323
Example: Ways to Cover Steps�������������������������������������������������������������������������������������������� 323
Classical Dynamic Programming Examples������������������������������������������������������������������������������ 325
The Knapsack Problem�������������������������������������������������������������������������������������������������������� 325
Longest Common Subsequence������������������������������������������������������������������������������������������ 328
Coin Change������������������������������������������������������������������������������������������������������������������������ 330
Edit (Levenshtein) Distance������������������������������������������������������������������������������������������������� 334
Summary���������������������������������������������������������������������������������������������������������������������������������� 338

xiii
Table of Contents

Chapter 20: Bit Manipulation�������������������������������������������������������������������������������� 339


Bitwise Operators��������������������������������������������������������������������������������������������������������������������� 339
AND�������������������������������������������������������������������������������������������������������������������������������������� 340
OR���������������������������������������������������������������������������������������������������������������������������������������� 340
XOR�������������������������������������������������������������������������������������������������������������������������������������� 341
NOT�������������������������������������������������������������������������������������������������������������������������������������� 341
Left Shift������������������������������������������������������������������������������������������������������������������������������ 342
Right Shift���������������������������������������������������������������������������������������������������������������������������� 342
Zero-Fill Right Shift������������������������������������������������������������������������������������������������������������� 343
Number Operations������������������������������������������������������������������������������������������������������������������� 343
Addition������������������������������������������������������������������������������������������������������������������������������� 343
Subtraction�������������������������������������������������������������������������������������������������������������������������� 344
Multiplication����������������������������������������������������������������������������������������������������������������������� 345
Division�������������������������������������������������������������������������������������������������������������������������������� 347
Summary���������������������������������������������������������������������������������������������������������������������������������� 349

Index��������������������������������������������������������������������������������������������������������������������� 351

xiv
About the Author
Sammie Bae is a data engineer at Yelp and previously
worked for the data platform engineering team at
NVIDIA. He developed a deep interest in JavaScript
during an internship at SMART Technologies (acquired by
Foxconn), where he developed Node.js-based JavaScript
APIs for serial port communication between electronic
board drivers and a web application. Despite how relevant
JavaScript is to the modern software engineering industry,
currently no books besides this one teach algorithms and
data structures using JavaScript. Sammie understands how
difficult these computer science concepts are and aims to
provide clear and concise explanations in this book.

xv
About the Technical Reviewer
Phil Nash is a developer evangelist for Twilio, serving
developer communities in London and all over the world.
He is a Ruby, JavaScript, and Swift developer; Google
Developers Expert; blogger; speaker; and occasional brewer.
He can be found hanging out at meetups and conferences,
playing with new technologies and APIs, or writing open
source code.

xvii
Acknowledgments
Thank you, Phil Nash, for the valuable feedback that helped me improve the technical
content of this book with clear explanations and concise code.
Special thanks to the Apress team. This includes James Markham, Nancy Chen, Jade
Scard, and Chris Nelson. Finally, I want to thank Steve Anglin for reaching out to me to
publish with Apress.

xix
Introduction
The motivation for writing this book was the lack of resources available about data
structures and algorithms written in JavaScript. This was strange to me because
today many of the job opportunities for software development require knowledge of
JavaScript; it is the only language that can be used to write the entire stack, including the
front-end, mobile (native and hybrid) platforms, and back-end. It is crucial for JavaScript
developers to understand how data structures work and how to design algorithms to
build applications.
Therefore, this book aims to teach data structure and algorithm concepts from
computer science for JavaScript rather than for the more typical Java or C++. Because
JavaScript follows the prototypal inheritance pattern, unlike Java and C++ (which follow
the inheritance pattern), there are some changes in writing data structures in JavaScript.
The classical inheritance pattern allows inheritance by creating a blueprint-­like form
that objects follow during inheritance. However, the prototypal inheritance pattern
means copying the objects and changing their properties.
This book first covers fundamental mathematics for Big-O analysis and then lays out
the basic JavaScript foundations, such as primitive objects and types. Then, this book
covers implementations and algorithms for fundamental data structures such as linked
lists, stacks, trees, heaps, and graphs. Finally, more advanced topics such as efficient
string search algorithms, caching algorithms, and dynamic programming problems are
explored in great detail.

xxi
CHAPTER 1

Big-O Notation
O(1) is holy.
—Hamid Tizhoosh

Before learning how to implement algorithms, you should understand how to analyze
the effectiveness of them. This chapter will focus on the concept of Big-O notation for
time and algorithmic space complexity analysis. By the end of this chapter, you will
understand how to analyze an implementation of an algorithm with respect to both time
(execution time) and space (memory consumed).

Big-O Notation Primer


The Big-O notation measures the worst-case complexity of an algorithm. In Big-O
notation, n represents the number of inputs. The question asked with Big-O is the
following: “What will happen as n approaches infinity?”
When you implement an algorithm, Big-O notation is important because it tells you
how efficient the algorithm is. Figure 1-1 shows some common Big-O notations.

1
© Sammie Bae 2019
S. Bae, JavaScript Data Structures and Algorithms, https://doi.org/10.1007/978-1-4842-3988-9_1
Chapter 1 Big-O Notation

Figure 1-1. Common Big-O complexities

The following sections illustrate these common time complexities with some simple
examples.

Common Examples
O(1) does not change with respect to input space. Hence, O(1) is referred to as being
constant time. An example of an O(1) algorithm is accessing an item in the array by its
index. O(n) is linear time and applies to algorithms that must do n operations in the
worst-case scenario.
An example of an O(n) algorithm is printing numbers from 0 to n-1, as shown here:

1 function  exampleLinear(n) {
2                   for  (var  i = 0 ; i <  n; i++ ) {

2
Chapter 1 Big-O Notation

3                              console.log(i);
4                   }
5  }

Similarly, O(n2) is quadratic time, and O(n3) is cubic time. Examples of these
complexities are shown here:

1 function  exampleQuadratic(n) {
2                   for  (var  i = 0 ; i <  n; i++ ) {
3                                 console.log(i);
4                                for  (var  j =  i; j <  n; j++ ) {
5                                             console.log(j);
6                              }
7                   }
8  }

1 function  exampleCubic(n) {
2                   for  (var  i = 0 ; i <  n; i++ ) {
3                                  console.log(i);
4                                for  (var  j =  i; j <  n; j++ ) {
5                                              console.log(j);
6                                                  for  (var  k =  j;
j <  n; j++ ) {
7                                                          console.log(k);
8                                                  }
9                                }
10           }
11 }

Finally, an example algorithm of logarithmic time complexity is printing elements


that are a power of 2 between 2 and n. For example, exampleLogarithmic(10) will print
the following:

2,4,8,16,32,64

3
Chapter 1 Big-O Notation

The efficiency of logarithmic time complexities is apparent with large inputs such
as a million items. Although n is a million, exampleLogarithmic will print only 19
items because log2(1,000,000) = 19.9315686. The code that implements this logarithmic
behavior is as follows:

1 function exampleLogarithmic(n) {
2                   for (var i = 2 ; i <= n; i= i*2 ) {
3                          console.log(i);
4                  }
5 }

Rules of Big-O Notation


Let’s represent an algorithm’s complexity as f(n). n represents the number of inputs,
f(n)time represents the time needed, and f(n)space represents the space (additional
memory) needed for the algorithm. The goal of algorithm analysis is to understand the
algorithm’s efficiency by calculating f(n). However, it can be challenging to calculate f(n).
Big-O notation provides some fundamental rules that help developers compute for f(n).

• Coefficient rule: If f(n) is O(g(n)), then kf(n) is O(g(n)), for any


constant k > 0. The first rule is the coefficient rule, which eliminates
coefficients not related to the input size, n. This is because as n
approaches infinity, the other coefficient becomes negligible.

• Sum rule: If f(n) is O(h(n)) and g(n) is O(p(n)), then f(n)+g(n) is


O(h(n)+p(n)). The sum rule simply states that if a resultant time
complexity is a sum of two different time complexities, the resultant
Big-O notation is also the sum of two different Big-O notations.
• Product rule: If f(n) is O(h(n)) and g(n) is O(p(n)), then f(n)g(n) is
O(h(n)p(n)). Similarly, the product rule states that Big-O is multiplied
when the time complexities are multiplied.

• Transitive rule: If f(n) is O(g(n)) and g(n) is O(h(n)), then f(n) is


O(h(n)). The transitive rule is a simple way to state that the same time
complexity has the same Big-O.

4
Chapter 1 Big-O Notation

• Polynomial rule: If f(n) is a polynomial of degree k, then f(n) is


O(nk). Intuitively, the polynomial rule states that polynomial time
complexities have Big-O of the same polynomial degree.

• Log of a power rule: log(nk) is O(log(n)) for any constant k > 0. With
the log of a power rule, constants within a log function are also
ignored in Big-O notation.

Special attention should be paid to the first three rules and the polynomial rule
because they are the most commonly used. I’ll discuss each of those rules in the
following sections.

Coefficient Rule: “Get Rid of Constants”


Let’s first review the coefficient rule. This rule is the easiest rule to understand. It simply
requires you to ignore any non-input-size-related constants. Coefficients in Big-O are
negligible with large input sizes. Therefore, this is the most important rule of Big-O
notations.

If f(n) is O(g(n)), then kf(n) is O(g(n)), for any constant k > 0.

This means that both 5f(n) and f(n) have the same Big-O notation of O(f(n)).
Here is an example of a code block with a time complexity of O(n):

1   function a(n){
2       var count =0;
3       for (var i=0;i<n;i++){
4           count+=1;
5       }
6       return count;
7   }

This block of code has f(n) = n. This is because it adds to count n times. Therefore,
this function is O(n) in time complexity:

1   function a(n){
2       var count =0;
3       for (var i=0;i<5*n;i++){

5
Chapter 1 Big-O Notation

4           count+=1;
5       }
6       return count;
7   }

This block has f(n) = 5n. This is because it runs from 0 to 5n. However, the first two
examples both have a Big-O notation of O(n). Simply put, this is because if n is close to
infinity or another large number, those four additional operations are meaningless. It is
going to perform it n times. Any constants are negligible in Big-O notation.
The following code block demonstrates another function with a linear time
complexity but with an additional operation on line 6:

1   function a(n){
2       var count =0;
3       for (var i=0;i<n;i++){
4           count+=1;
5       }
6       count+=3;
7       return count;
8   }

Lastly, this block of code has f(n) = n+1. There is +1 from the last operation
(count+=3). This still has a Big-O notation of O(n). This is because that 1 operation is not
dependent on the input n. As n approaches infinity, it will become negligible.

Sum Rule: “Add Big-Os Up”


The sum rule is intuitive to understand; time complexities can be added. Imagine a
master algorithm that involves two other algorithms. The Big-O notation of that master
algorithm is simply the sum of the other two Big-O notations.

If f(n) is O(h(n)) and g(n) is O(p(n)), then f(n)+g(n) is O(h(n)+p(n)).

It is important to remember to apply the coefficient rule after applying this rule.

6
Chapter 1 Big-O Notation

The following code block demonstrates a function with two main loops whose time
complexities must be considered independently and then summed:

1   function a(n){
2       var count =0;
3       for (var i=0;i<n;i++){
4           count+=1;
5       }
6       for (var i=0;i<5*n;i++){
7           count+=1;
8       }
9       return count;
10   }

In this example, line 4 has f(n) = n, and line 7 has f(n) = 5n. This results in 6n.
However, when applying the coefficient rule, the final result is O(n) = n.

Product Rule: “Multiply Big-Os”


The product rule simply states how Big-Os can be multiplied.

If f(n) is O(h(n)) and g(n) is O(p(n)), then f(n)g(n) is O(h(n)p(n)).

The following code block demonstrates a function with two nested for loops for
which the product rule is applied:

1   function (n){
2       var count =0;
3       for (var i=0;i<n;i++){
4           count+=1;
5           for (var i=0;i<5*n;i++){
6               count+=1;
7           }
8       }
9       return count;
10   }

7
Chapter 1 Big-O Notation

In this example, f(n) = 5n*n because line 7 runs 5n times for a total of n iterations.
Therefore, this results in a total of 5n2 operations. Applying the coefficient rule, the result
is that O(n)=n2.

Polynomial Rule: “Big-O to the Power of k”


The polynomial rule states that polynomial time complexities have a Big-O notation of
the same polynomial degree.
Mathematically, it’s as follows:

If f(n) is a polynomial of degree k, then f(n) is O(nk).


The following code block has only one for loop with quadratic time complexity:

1   function a(n){
2       var count =0;
3       for (var i=0;i<n*n;i++){
4           count+=1;
5       }
6       return count;
7   }

In this example, f(n) = nˆ2 because line 4 runs n*n iterations.


This was a quick overview of the Big-O notation. There is more to come as you
progress through the book.

Summary
Big-O is important for analyzing and comparing the efficiencies of algorithms.
The analysis of Big-O starts by looking at the code and applying the rules to simplify
the Big-O notation. The following are the most often used rules:

• Eliminating coefficients/constants (coefficient rule)

• Adding up Big-Os (sum rule)


• Multiplying Big-Os (product rule)

• Determining the polynomial of the Big-O notation by looking at loops


(polynomial rule)

8
Chapter 1 Big-O Notation

Exercises
Calculate the time complexities for each of the exercise code snippets.

EXERCISE 1

1   function someFunction(n) {
2
3       for (var i=0;i<n*1000;i++) {
4           for (var j=0;j<n*20;j++) {
5               console.log(i+j);
6           }
7       }
8
9   }

EXERCISE 2

1   function someFunction(n) {
2
3       for (var i=0;i<n;i++) {
4           for (var j=0;j<n;j++) {
5               for (var k=0;k<n;k++) {
6                   for (var l=0;l<10;l++) {
7                       console.log(i+j+k+l);
8                   }
9               }
10           }
11       }
12
13   }

9
Chapter 1 Big-O Notation

EXERCISE 3

1   function someFunction(n) {
2
3       for (var i=0;i<1000;i++) {
4           console.log("hi");
5       }
6
7   }

EXERCISE 4

1   function someFunction(n) {
2
3       for (var i=0;i<n*10;i++) {
4           console.log(n);
5       }
6
7   }

EXERCISE 5

1   function someFunction(n) {
2
3       for (var i=0;i<n;i*2) {
4           console.log(n);
5       }
6
7   }

10
Chapter 1 Big-O Notation

EXERCISE 6

1   function someFunction(n) {
2
3       while (true){
4           console.log(n);
5       }
6   }

Answers
1. O(n2)
There are two nested loops. Ignore the constants in front of n.

2. O(n3)
There are four nested loops, but the last loop runs only until 10.

3. O(1)
Constant complexity. The function runs from 0 to 1000. This does
not depend on n.

4. O(n)
Linear complexity. The function runs from 0 to 10n. Constants are
ignored in Big-O.
5. O(log2n)
Logarithmic complexity. For a given n, this will operate only log2n
times because i is incremented by multiplying by 2 rather than
adding 1 as in the other examples.

6. O(∞)

Infinite loop. This function will not end.

11
CHAPTER 2

JavaScript: Unique Parts


This chapter will briefly discuss some exceptions and cases of JavaScript’s syntax and
behavior. As a dynamic and interpreted programming language, its syntax is different
from that of traditional object-oriented programming languages. These concepts are
fundamental to JavaScript and will help you to develop a better understanding of the
process of designing algorithms in JavaScript.

J avaScript Scope
The scope is what defines the access to JavaScript variables. In JavaScript, variables
can belong to the global scope or to the local scope. Global variables are variables that
belong in the global scope and are accessible from anywhere in the program.

Global Declaration: Global Scope


In JavaScript, variables can be declared without using any operators. Here’s an example:

1  test = "sss";
2  console.log(test); // prints "sss"

However, this creates a global variable, and this is one of the worst practices in
JavaScript. Avoid doing this at all costs. Always use var or let to declare variables.
Finally, when declaring variables that won’t be modified, use const.

Declaration with var: Functional Scope


In JavaScript, var is one keyword used to declare variables. These variable declarations
“float” all the way to the top. This is known as variable hoisting. Variables declared at the
bottom of the script will not be the last thing executed in a JavaScript program during
runtime.
13
© Sammie Bae 2019
S. Bae, JavaScript Data Structures and Algorithms, https://doi.org/10.1007/978-1-4842-3988-9_2
Chapter 2 JavaScript: Unique Parts

Here’s an example:

1  function scope1(){
2          var top = "top";
3          bottom = "bottom";
4          console.log(bottom);
5
6          var bottom;
7  }
8  scope1(); // prints "bottom" - no error

How does this work? The previous is the same as writing the following:

1  function scope1(){
2          var top = "top";
3          var  bottom;
4          bottom = "bottom"
5          console.log(bottom);
6  }
7  scope1(); // prints "bottom" - no error

The bottom variable declaration, which was at the last line in the function, is floated
to the top, and logging the variable works.
The key thing to note about the var keyword is that the scope of the variable is the
closest function scope. What does this mean?
In the following code, the scope2 function is the function scope closest to the print
variable:

1  function scope2(print){
2          if(print){
3                   var insideIf = '12';
4          }
5          console.log(insideIf);
6  }
7  scope2(true); // prints '12' - no error

14
Chapter 2 JavaScript: Unique Parts

To illustrate, the preceding function is equivalent to the following:

1  function scope2(print){
2          var insideIf;
3
4          if(print){
5                   insideIf = '12';
6          }
7          console.log(insideIf);
8  }
9  scope2(true); // prints '12' - no error

In Java, this syntax would have thrown an error because the insideIf variable is
generally available only in that if statement block and not outside it.
Here’s another example:

1  var a = 1;
2  function four() {
3    if (true) {
4      var a = 4;
5    }
6
7    console.log(a); // prints '4'
8  }

4 was printed, not the global value of 1, because it was redeclared and available in
that scope.

Declaration with let: Block Scope


Another keyword that can be used to declare a variable is let. Any variables declared
this way are in the closest block scope (meaning within the {} they were declared in).

1  function scope3(print){
2          if(print){
3                   let insideIf = '12';
4          }

15
Chapter 2 JavaScript: Unique Parts

5          console.log(insideIf);
6  }
7  scope3(true); // prints ''

In this example, nothing is logged to the console because the insideIf variable is
available only inside the if statement block.

Equality and Types


JavaScript has different data types than in traditional languages such as Java. Let’s
explore how this impacts things such as equality comparison.

Variable Types
In JavaScript, there are seven primitive data types: boolean, number, string, undefined,
object, function, and symbol (symbol won’t be discussed). One thing that stands out
here is that undefined is a primitive value that is assigned to a variable that has just been
declared. typeof is the primitive operator used to return the type of a variable.

1  var is20 = false; // boolean


2  typeof is20; // boolean
3
4  var  age = 19;
5  typeof age; // number
6
7  var  lastName = "Bae";
8  typeof lastName; // string
9
10  var fruits = ["Apple", "Banana", "Kiwi"];
11  typeof fruits; // object
12
13  var me = {firstName:"Sammie", lastName:"Bae"};
14  typeof me; // object
15
16  var nullVar = null;
17  typeof nullVar; // object
18
16
Chapter 2 JavaScript: Unique Parts

19  var function1 = function(){


20          console.log(1);
21  }
22  typeof function1 // function
23
24  var blank;
25  typeof blank; // undefined

Truthy/Falsey Check
True/false checking is used in if statements. In many languages, the parameter inside
the if() function must be a boolean type. However, JavaScript (and other dynamically
typed languages) is more flexible with this. Here’s an example:

1  if(node){
2          ...
3  }

Here, node is some variable. If that variable is empty, null, or undefined, it will be
evaluated as false.
Here are commonly used expressions that evaluate to false:

• false

• 0

• Empty strings ('' and "")


• NaN

• undefined

• null

Here are commonly used expressions that evaluate to true:

• true

• Any number other than 0

• Non-empty strings

• Non-empty object

17
Chapter 2 JavaScript: Unique Parts

Here’s an example:

1  var printIfTrue = ";


2
3  if (printIfTrue) {
4          console.log('truthy');
5  } else {
6          console.log('falsey'); // prints 'falsey'
7  }

=== vs ==
JavaScript is a scripting language, and variables are not assigned a type during
declaration. Instead, types are interpreted as the code runs.
Hence, === is used to check equality more strictly than ==. === checks for both the
type and the value, while == checks only for the value.

1  "5" == 5 // returns true


2  "5" === 5 // returns false

"5" == 5 returns true because "5" is coerced to a number before the comparison.
On the other hand, "5" === 5 returns false because the type of "5" is a string, while 5 is
a number.

Objects
Most strongly typed languages such as Java use isEquals() to check whether two objects
are the same. You may be tempted to simply use the == operator to check whether two
objects are the same in JavaScript.
However, this will not evaluate to true.

1  var o1 = {};
2  var o2 = {};
3
4  o1 == o2 // returns false
5  o1 === o2 // returns false

18
Chapter 2 JavaScript: Unique Parts

Although these objects are equivalent (same properties and values), they are not
equal. Namely, the variables have different addresses in memory.
This is why most JavaScript applications use utility libraries such as lodash1 or
underscore,2 which have the isEqual(object1, object2) function to check two objects
or values strictly. This occurs via implementation of some property-based equality
checking where each property of the object is compared.
In this example, each property is compared to achieve an accurate object equality result.

1  function isEquivalent(a, b) {
2      // arrays of property names
3      var aProps = Object.getOwnPropertyNames(a);
4      var bProps = Object.getOwnPropertyNames(b);
5
6      // If their property lengths are different, they're different objects
7      if (aProps.length != bProps.length) {
8          return false;
9      }
10
11      for (var  i = 0; i < aProps.length; i++) {
12          var propName = aProps[i];
13
14          // If the values of the property are different, not equal
15          if (a[propName] !== b[propName]) {
16              return false;
17          }
18      }
19
20     // If everything matched, correct
21     return  true;
22  }
23  isEquivalent({'hi':12},{'hi':12}); // returns true

1
h ttps://lodash.com/
2
http://underscorejs.org/

19
Chapter 2 JavaScript: Unique Parts

However, this would still work for objects that have only a string or a number as the
property.

1  var obj1 = {'prop1': 'test','prop2': function (){} };


2  var obj2 = {'prop1': 'test','prop2': function (){} };
3
4  isEquivalent(obj1,obj2); // returns false

This is because functions and arrays cannot simply use the == operator to check for
equality.

1  var function1 = function(){console.log(2)};


2  var function2 = function(){console.log(2)};
3  console.log(function1 == function2); // prints 'false'

Although the two functions perform the same operation, the functions have
different addresses in memory, and therefore the equality operator returns false.
The primitive equality check operators, == and ===, can be used only for strings and
numbers. To implement an equivalence check for objects, each property in the object
needs to be checked.

Summary
JavaScript has a different variable declaration technique than most programming
languages. var declares the variable within the function scope, let declares the variable
in the block scope, and variables can be declared without any operator in the global
scope; however, global scope should be avoided at all times. For type checking, typeof
should be used to validate the expected type. Finally, for equality checks, use == to check
the value, and use === to check for the type as well as the value. However, use these only
on non-object types such as numbers, strings, and booleans.

20
CHAPTER 3

JavaScript Numbers
This chapter will focus on JavaScript number operations, number representation, Number
objects, common number algorithms, and random number generation. By the end of
this chapter, you will understand how to work with numbers in JavaScript as well as how
to implement prime factorization, which is fundamental for encryption.
Number operations of a programming language allow you to compute numerical
values. Here are the number operators in JavaScript:

+ : addition
- : subtraction
/ : division
* : multiplication
% : modulus

These operators are universally used in other programming languages and are not
specific to JavaScript.

N
 umber System
JavaScript uses a 32-bit floating-point representation for numbers, as shown in Figure 3-­1.
In this example, the value is 0.15625. The sign bit (the 31st bit) indicates that the number
is negative if the sign bit is 1. The next 8 bits (the 30th to 23rd bits) indicate the exponent
value, e. Finally, the remaining 23 bits represent the fraction value.

Figure 3-1. The 32-bit floating-point number system


21
© Sammie Bae 2019
S. Bae, JavaScript Data Structures and Algorithms, https://doi.org/10.1007/978-1-4842-3988-9_3
Chapter 3 JavaScript Numbers

With the 32 bits, the value is computed by this esoteric formula:

æ 23
ö
value = ( -1) ´ 2e -127 ´ ç 1 + åb23 -t 2 -t ÷
sign

è t =1 ø

Figure 3-1 shows the following break down of the 32 bits:


sign = 0
e = (0111100)2 = 124 (in base 10)
23
1 + åb23 -i 2 -i = 1 + 0 + 0.25 + 0
i =1

This results in the following:

value = 1 x 2124-127 x 1.25 = 1 x 2-3 x 1.25 = 0.15625

With decimal fractions, this floating-point number system causes some rounding
errors in JavaScript. For example, 0.1 and 0.2 cannot be represented precisely.
Hence, 0.1 + 0.2 === 0.3 yields false.

1  0.1 + 0.2 === 0.3; // prints 'false'

To really understand why 0.1 cannot be represented properly as a 32-bit floating-­


point number, you must understand binary. Representing many decimals in binary
requires an infinite number of digits. This because binary numbers are represented by 2n
where n is an integer.
While trying to calculate 0.1, long division will go on forever. As shown in Figure 3-­2,
1010 represents 10 in binary. Trying to calculate 0.1 (1/10) results in an indefinite
number of decimal points.

22
Chapter 3 JavaScript Numbers

Figure 3-2. Long division for 0.1

JavaScript Number Object


Luckily, there are some built-in properties of the Number object in JavaScript that help
work around this.

Integer Rounding
Since JavaScript uses floating point to represent all numbers, integer division does not work.
Integer division in programming languages like Java simply evaluates division
expressions to their quotient.
For example, 5/4 is 1 in Java because the quotient is 1 (although there is a remainder
of 1 left). However, in JavaScript, it is a floating point.

1  5/4; // 1.25
23
Chapter 3 JavaScript Numbers

This is because Java requires you to explicitly type the integer as an integer.
Hence, the result cannot be a floating point. However, if JavaScript developers want to
implement integer division, they can do one of the following:

Math.floor - rounds down to nearest integer


Math.round - rounds to nearest integer
Math.ceil  - rounds up to nearest integer

Math.floor(0.9); // 0
Math.floor(1.1); // 1

Math.round(0.49); // 0
Math.round(0.5); // 1

Math.round(2.9); // 3
Math.ceil(0.1); // 1 Math.ceil(0.9); // 1 Math.ceil(21);
// 21 Math.ceil(21.01); // 22

Number.EPSILON
Number.EPSILON returns the smallest interval between two representable numbers.
This is useful for the problem with floating-point approximation.

1  function numberEquals(x, y) {
2      return Math.abs(x - y) < Number.EPSILON;
3  }
4
5  numberEquals(0.1 + 0.2, 0.3); // true

This function works by checking whether the difference between the two numbers
are smaller than Number.EPSILON. Remember that Number.EPSILON is the smallest
difference between two representable numbers. The difference between 0.1+0.2 and 0.3
will be smaller than Number.EPSILON.

Maximums
Number.MAX_SAFE_INTEGER returns the largest integer.

1  Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true

24
Chapter 3 JavaScript Numbers

This returns true because it cannot go any higher. However, it does not work for
floating-point decimals.

1  
Number.MAX_SAFE_INTEGER + 1.111 === Number.MAX_SAFE_INTEGER + 2.022;
// false

Number.MAX_VALUE returns the largest floating-point number possible.


Number.MAX_VALUE is equal to 1.7976931348623157e+308.

1  Number.MAX_VALUE + 1 === Number.MAX_VALUE + 2; // true

Unlike like Number.MAX_SAFE_INTEGER, this uses double-precision floating-point


representation and works for floating points as well.

1  Number.MAX_VALUE + 1.111 === Number.MAX_VALUE + 2.022; // true

Minimums
Number.MIN_SAFE_INTEGER returns the smallest integer.
Number.MIN_SAFE_INTEGER is equal to -9007199254740991.

1  Number.MIN_SAFE_INTEGER - 1 === Number.MIN_SAFE_INTEGER - 2; // true

This returns true because it cannot get any smaller. However, it does not work for
floating-point decimals.

1  Number.MIN_SAFE_INTEGER - 1.111 === Number.MIN_SAFE_INTEGER - 2.022;


// false

Number.MIN_VALUE returns the smallest floating-point number possible.


Number.MIN_VALUE is equal to 5e-324. This is not a negative number since it is the
smallest floating-point number possible and means that Number.MIN_VALUE is actually
bigger than Number.MIN_- SAFE_INTEGER.
Number.MIN_VALUE is also the closest floating point to zero.

1  Number.MIN_VALUE - 1 == -1; // true

This is because this is similar to writing 0 - 1 == -1.

25
Chapter 3 JavaScript Numbers

Infinity
The only thing greater than Number.MAX_VALUE is Infinity, and the only thing smaller
than Number.MAX_SAFE_INTEGER is -Infinity.

1  Infinity > Number.MAX_SAFE_INTEGER; // true


2  -Infinity < Number.MAX_SAFE_INTEGER // true;
3  -Infinity -32323323 == -Infinity -1; // true

This evaluates to true because nothing can go smaller than -Infinity.

Size Summary
This inequality summarizes the size of JavaScript numbers from smallest (left) to
largest (right):

-Infinity < Number.MIN_SAFE_INTEGER < Number.MIN_VALUE < 0 < Number.MAX_


SAFE_IN- TEGER < Number.MAX_VALUE < Infinity

Number Algorithms
One of the most discussed algorithms involving numbers is for testing whether a number
is a prime number. Let’s review this now.

Primality Test
A primality test can be done by iterating from 2 to n, checking whether modulus division
(remainder) is equal to zero.

1  function isPrime(n){
2      if (n <= 1) {
3              return false;
4      }
5
6      // check from 2 to n-1
7      for (var i=2; i<n; i++) {
8              if (n%i == 0) {
9                      return false;
10          }
26
Chapter 3 JavaScript Numbers

11      }
12
13      return true;
14  }

Time Complexity: O(n)


The time complexity is O(n) because this algorithm checks all numbers from 0 to n.
This is an example of an algorithm that can be easily improved. Think about how this
method iterates through 2 to n. Is it possible to find a pattern and make the algorithm
faster? First, any multiple of 2s can be ignored, but there is more optimization possible.
Let’s list some prime numbers.

2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97

This is difficult to notice, but all primes are of the form 6k ± 1, with the exception of
2 and 3 where k is some integer. Here’s an example:

5 = (6-1) , 7 = ((1*6) + 1), 13 = ((2*6) + 1) etc

Also realize that for testing the prime number n, the loop only has to test until the
square root of n. This is because if the square root of n is not a prime number, n is not a
prime number by mathematical definition.

1  function isPrime(n){
2      if (n <= 1) return false;
3      if (n <= 3) return true;
4
5      // This is checked so that we can skip
6      // middle five numbers in below loop
7      if (n%2 == 0 || n%3 == 0) return false;
8
9      for (var i=5; i*i<=n; i=i+6){
10          if (n%i == 0 || n%(i+2) == 0)
11             return false;
12      }
13
14      return true;
15  }

27
Chapter 3 JavaScript Numbers

Time Complexity: O(sqrt(n))


This improved solution cuts the time complexity down significantly.

P
 rime Factorization
Another useful algorithm to understand is for determining prime factorization of a
number. Prime numbers are the basis of encryption (covered in Chapter 4) and hashing
(covered in Chapter 11), and prime factorization is the process of determining which
prime numbers multiply to a given number. Given 10, it would print 5 and 2.

1  function primeFactors(n){
2          // Print the number of 2s that divide n
3          while (n%2 == 0) {
4              console.log(2);
5              n = n/2;
6          }
7
8          // n must be odd at this point. So we can skip one element
(Note i = i +2)
9          for (var i = 3; i*i <= n; i = i+2) {
10             // While i divides n, print i and divide n
11              while (n%i == 0) {
12                  console.log(i);
13                  n = n/i;
14              }
15          }
16          //This condition is to handle the case when n is a prime number
17          //greater than 2
18          if (n > 2) {
19                  console.log(n);
20          }
21  }
22  primeFactors(10); // prints '5' and '2'

28
Chapter 3 JavaScript Numbers

Time Complexity: O(sqrt(n))


This algorithm works by printing any number that is divisible by i without a
remainder. In the case that a prime number is passed into this function, it would be
handled by printing whether n is greater than 2.

Random Number Generator


Random number generation is important to simulate conditions. JavaScript has a built-­in
function for generating numbers: Math.random().

Math.random() returns a float between 0 and 1.

You may wonder how you get random integers or numbers greater than 1.
To get floating points higher than 1, simply multiply Math.random() by the range.
Add or subtract from it to set the base.

Math.random() * 100; // floats between 0  and  100


Math.random() * 25 + 5; // floats between 5  and  30
Math.random() * 10 - 100; // floats between -100 and -90

To get random integers, simply use Math.floor(), Math.round(), or Math.ceil() to


round to an integer.

Math.floor(Math.random() * 100); // integer between 0 and 99


Math.round(Math.random() * 25) + 5; // integer between 5 and 30
Math.ceil(Math.random() * 10) - 100; // integer between -100 and -90

Exercises
1. Given three numbers x, y, and p, compute (xˆy) % p. (This is
modular exponentiation.)
Here, x is the base, y is exponent, and p is the modulus.
Modular exponentiation is a type of exponentiation performed
over a modulus, which is useful in computer science and used in
the field of public-key encryption algorithms.
At first, this problem seems simple. Calculating this is a one-line
solution, as shown here:
29
Chapter 3 JavaScript Numbers

1  function modularExponentiation ( base, exponent, modulus ) {


2          return Math.pow(base,exponent) % modulus;
3  }

This does exactly what the question asks. However, it cannot


handle large exponents.
Remember that this is implemented with encryption algorithms.
In strong cryptography, the base is often at least 256 bit (78 digits).
Consider this case, for example:
Base: 6x1077, Exponent: 27, Modulus: 497
In this case, (6x1077)27 is a very large number and cannot be stored
in a 32-bit floating point.
There is another approach, which involves some math. One must
observe the following mathematical property:
For arbitrary a and b,

c % m = (a  b) % m
c % m = [(a % m)  (b % m)] % m

Using this mathematical property, you can iterate 1 to the


exponent, recalculating each time by multiplying the current
modulus value with the last.

Here is the pseudocode:

1  Set value = 1, current exponent = 0.


2  Increment current exponent by 1.
3  Set value = (base  value) mod modulus until current
exponent is reached exponent

Example: Base: 4, Exponent: 3, Modulus: 5

4ˆ3 % 5 = 64 % 5 = 4

value = (lastValue x base ) % modulus:


value = (1 x 4) % 5 = 4 % 5 = 4

30
Chapter 3 JavaScript Numbers

value = (4 x 4) % 5 = 16 % 5 = 1

value = (1 x 4) % 5 = 4 % 5 = 4

Finally, here is the code:

1  function modularExponentiation ( base, exponent, modulus ) {


2          if (modulus == 1) return 0;
3
4          var value = 1;
5
6          for ( var i=0; i<exponent; i++ ){
7                  value = (value * base) % modulus;
8          }
9          return value;
10  }

Time Complexity: O(n)

The time complexity is O(n) where n is equal to the exponent value.

2. Print all primes less than n.

To do this, use the isPrime function covered in this chapter.


Simply iterate from 0 to n and print any prime numbers where
isPrime() evaluates to true.

1  function allPrimesLessThanN(n){
2          for (var i=0; i<n; i++) {
3                  if (isPrime(i)){
4                          console.log(i);
5                  }
6          }
7  }
8
9  function isPrime(n){
10      if (n <= 1) return false;
11      if (n <= 3) return true;
12

31
Chapter 3 JavaScript Numbers

13      // This is checked so that we can skip


14      // middle five numbers in below loop
15      if (n%2 == 0 || n%3 == 0) return false;
16
17      for (var i=5; i*i<=n; i=i+6){
18          if (n%i == 0 || n%(i+2) == 0)
19             return false;
20      }
21
22      return true;
23  }
24
25  allPrimesLessThanN(15);
26
27  // prints 2, 3, 5, 7, 11, 13

Time Complexity: O(nsqrt(n))

This is because isPrime (covered earlier in this chapter) with a


time complexity of O(sqrt(n)) is run n times.

3. Check for a set of prime factors.

Let’s define ugly numbers as those whose only prime factors are
2, 3, or 5. The sequence 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, … shows the
first 11 ugly numbers. By convention, 1 is included.
To do this, divide the number by the divisors (2, 3, 5) until it
cannot be divided without a remainder. If the number can be
divided by all the divisors, it should be 1 after dividing everything.

1  function maxDivide (number, divisor) {


2          while (number % divisor == 0) {
3                  number /= divisor;
4          }
5          return number;
6  }
7
8  function isUgly (number){
9          number = maxDivide(number, 2);
32
Chapter 3 JavaScript Numbers

10          number = maxDivide(number, 3);


11          number = maxDivide(number, 5);
12          return number === 1;
13  }

Iterate this over n, and now the list of ugly numbers can be
returned.

1  function arrayNUglyNumbers (n) {


2          var counter = 0, currentNumber = 1,
uglyNumbers = [];
3
4          while ( counter != n ) {
5
6                  if ( isUgly(currentNumber) ) {
7                          counter++;
8                          uglyNumbers.push(currentNumber);
9                  }
10
11                  currentNumber++;
12          }
13
14          return uglyNumbers;
15  }

Time Complexity for maxDivide(number, divisor):


O(logdivisor(number))
The time complexity of maxDivide is a logarithmic function which
depends on divisor and the number. When testing primes of 2,
3, and 5, the logarithmic of 2 (log2 (n)) yields the highest time
complexity.

Time Complexity for isUgly: O(log2(n))


Time Complexity for arrayNUglyNumbers: O(n(log2(n)))
The isUgly function is limited by the time complexity of maxDivide(number, 2).
Hence, arrayNUglyNumbers has n times that time complexity.

33
Other documents randomly have
different content
—Mon premier, proposa Bel-Œil, est un métal précieux, mon second
un envoyé des cieux, mon tout un fruit délicieux: un baiser à qui
devinera ma charade!
—Jouons à la main chaude! opina Nougat:

Le petit dieu qui gouverne le monde


Avec un bandeau sur les yeux....

—Eh! houp, Jabadâo! criait Joson, en brandissant son verre de


champagne, c'est mignon, cte petit cidre, monsié el chevâlier. Ej' suis
vot'mâtelot à la vie, à la mort, faut pas mentir.... Mais n'empêche
qu'y a du tâbâc!
—Grenadiers! déclama tout à coup la garde civique, vous êtes la
nation armée! La France libérale vous a confié ses institutions. Si
jamais l'étranger....
—A bas les Anglais!
—Ah! l'Allemagne! fit Bel-Œil, la rêveuse Allemagne. Que Dieu
m'envoie l'auteur de Lottchen ou la Filleule du Rhingrave!»
L'adjoint demanda:
«Jetez-vous vos langues aux chiens? Un des trois moines s'appelait
Chacun.... Bêtes!»
Et il s'affaissa dans un rire homérique. Vincent lui versa une demi-
tasse de café à l'intérieur de sa cravate.
«Celui qui s'appelait Chacun prit une poire, continua l'adjoint qui
essaya de l'embrasser, et de la sorte il restait deux poires.....
Bêtes!.... madame me croit dans mon lit.
—Viens danser, pataud! dit Nougat qui saisit le gendarme à bras-le-
corps. Je n'ai pas mal à l'estomac!
—A la danse! A la danse!
—Garçon, des violons!
—Nous deux, me dit Bel-Œil en se pendant à mon bras, comme si
j'eusse été l'auteur de Lottchen ou la Filleule du Rhingrave,
cherchons un lieu écarté pour parler la seule langue qui convienne
aux cœurs sensibles.»
XXVIII.
L'EPREUVE.

On dansa. Quatre couples, suivis par la galerie, passèrent dans le


salon voisin, où il y avait un piano. Le piano fut touché par un
garçon du restaurant que la dureté des temps avait précipité des
sommets de l'art. Le personnel des Frères-Provençaux éprouvait un
malaise visible. On fit des choses insensées, en vertu du principe: «A
Paris comme à Paris.» Rimassu et la veuve des marins étaient deux
maîtresses femmes, rompues à toutes les excentricités
chorégraphiques; elles enseignèrent le cancan à Nougat, qui ne se
possédait pas de joie. La poissonnière tutoyait tout le monde et
fumait sa pipe en exécutant la pure danse de l'ours, telle qu'on peut
l'admirer, à Lorient, dans les bouges les mieux fréquentés de la rue
du Port. Vincent et elle, en guise de galanteries, se livraient de
véritables combats à coup de poing. Mon pauvre père regardait tout
cela d'un air béat et battait la mesure sur le dos du garçon virtuose
en criant:
«C'est Paris! voilà ce que c'est que Paris!»
L'oncle Bélébon, lâche flatteur, venait de temps en temps lui
chatouiller les flancs par derrière et c'étaient d'interminables éclats
de rire. On se mit à chanter en dansant. Je n'oserais citer même les
titres des poésies exhumées par la coupable Rimassu. Nougat en
voulut des copies. Si le maître et seigneur des Frères-Provençaux
n'avait pas vu avec nous un instant le colonel vicomte de Kervigné,
un de ses habitués les plus respectables, il nous aurait lancés vingt
fois à la porte.
Dans l'intervalle des quadrilles, on se hercaillait, selon l'expression
de la poissonnière. La hercaille est une poussée générale, mêlée de
horions sincères et de cris appropriés. Vincent qui cachait sous un
extérieur grossier des talents de société fort étendus, imitait en ces
occasions la voix de tous les animaux domestiques. On aurait cru
qu'il y avait là des ânes, des vaches, des cochons, des dindons, des
canards et des oies.
Ah! c'était Paris! c'était bien Paris! chacun se promettait d'y revenir.
«Amusez-vous, mes enfants, disait mon père. C'est de votre âge. La
Bretagne fut toujours renommée pour sa franche et cordiale gaieté.
Nous ne sommes pas des Anglais! On va monter les glaces et le
punch. Quand vous voudrez, nous souperons. Voilà Paris!
—Tu es un cœur, toi, ancien marquis!» applaudissait la poissonnière.
Et par-dessus les acclamations, on entendait la voix triomphante de
Nougat qui criait:
Je ne sens pas mon estomac!»
Depuis longtemps, j'aurais pu m'esquiver, mais j'avais peur de
mécontenter mon père et il me semblait que je gagnais auprès de lui
quelque mérite, en subissant ce purgatoire. D'ailleurs, j'attendais
toujours Gérard. A force d'hésiter, je me laissai prendre, comme je
l'ai dit, par ma tante Bel-Œil, et la fuite devint impossible.
Ma tante Bel-Œil ne dansait pas et la gaudriole soulevait son cœur
sensible, mais elle avait soif de théories sentimentales. Son aspect
était un peu effrayant. Ses cheveux grisonnants s'ébouriffaient sous
un bonnet terriblement couronné de fleurs des champs; sa longue
figure se marbrait de tons livides et lilas; son grand zieu restait fixe
et demesurément ouvert, tandis que son petit zieu exécutait des
merveilles de gymnastique.
«Hélas! me dit-elle avec un soupir gastrique, voici donc Paris et les
orgies sans frein de la Babylone moderne! Se peut-il que je m'y
trouve compromise après tant d'années d'une existence virginale!
J'en avais lu la description dans les Exilés de Heilbronn, ou à quoi
sert la vertu? un livre charmant, quoique rempli de dangereuses
peintures. As-tu été à la Chaumière?
—Non, ma tante répondis-je.
—Sois franc. Notre patrie a aussi des auteurs. Je connais les mœurs
vives et dévergondées du pays latin. Je voudrais voir quelques
grisettes de Paul de Kock avant de mourir!»
Elle me serra tout à coup le bras:
«Jeune imprudent, s'interrompit-elle, tu as gâté ta vie! Nous vivons
dans un siècle où l'amour est proscrit. Le démon de l'or s'est emparé
de toutes les consciences. Et tu t'es avisé de chercher un cœur pour
ton cœur! Ce n'est pas moi qui te blâme: la religion naturelle ne
connaît pas de schisme et, du haut de ma philosophie, je vois les
comédiennes au niveau des princesses. Passez le punch, monsieur le
garçon. Ah! qu'il est fort! Remettez-y un peu de rhum pour le
rafraîchir. C'est bien! Nous disions donc que ton Annette Laïs....
D'abord j'aime ce nom: Annette Laïs, ou les secrets de la comédie.
Combien de fois n'ai-je pas été sur le point de composer un livre,
afin d'épancher dans le sein de l'humanité les émotions brûlantes de
mon âme! Ecoute-moi. Et ne te méprends pas sur mes intentions.
C'est la tendresse désintéressée d'une parente qui va dicter mes
paroles. Cette jeune fille avait-elle déjà connu l'amour? ou bien l'as-
tu conduite le premier dans ce sentier émaillé de fleurs fatales où le
dieu qui porte un carquois?...»
Elle me donna un coup sur les doigts, et son petit zieu fit pour le
moins cinquante tours en une seconde.
«Eh! bonhomme? s'interrompit-elle, cessant soudain de traduire
l'allemand, ne crains pas de tout dire. C'est comme si j'étais ton
confesseur. Tu conçois, si je suis contente des détails, je te fourre de
quoi lui faire un mignon cadeau.
—Prenez moi ce gaillard là! ordonna mon père, et qu'on me le fasse
danser de force.»
On fit mine d'obéir, mais Bel-Œil m'entoura de ses deux maigres
bras; prête à défendre par la force le trésor de confidences intimes
qu'elle attendait de moi.
En ce moment, Joson Michais me glissa à l'oreille par derrière:
«Notre monsié Gérard est en bas qui vous attend. Il est pâlot et
blême censé comme un linge, et je ne mens pas! Pour le tâbâc, il y a
du tâbâc!»
Je ne fis qu'un saut jusqu'à la porte et je m'enfuis.
Gérard était bien pâle, en effet. Il m'attendait, appuyé contre
l'entrée du vestibule, sur ce petit trottoir en contre bas qui borde la
rue de Beaujolais. Il semblait avoir peine à se soutenir. L'idée me
saisit qu'il venait de commettre une mauvaise action.
«Ah! me dit-il, te voilà.»
Il posa ses deux mains sur mes épaules et je le sentis chanceler.
«Sois homme! ajouta-t-il en quelque sorte machinalement. Sois
homme!»
Le vertige me monta tout de suite au cerveau. J'eus la pensée
furieuse de lui briser le crâne contre la rampe de fer qui était
derrière nous. Je sentais, à vrai dire, le coup de poignard qu'il venait
de me porter en plein cœur.
«Qu'as-tu fait?....» balbutiai-je d'une voix étranglée.
Il répéta:
«Sois homme! sois homme!»
Je vis que ses yeux étaient rouges et que des larmes roulaient sur sa
joue.
Je ne saurais rendre l'angoisse poignante que j'éprouvai. Ce doit être
ainsi quand on meurt, ma colère tomba, mon énergie aussi. Il fut
obligé de me soutenir à son tour.
Il me porta peut-être, peut-être eus-je la force de marcher. Je n'ai
pas souvenir. Je me retrouvai assis sur un des bancs de pierre collés
aux arcades qui donnaient au jardin du Palais Royal un aspect de
familière hospitalité. Il était tard déjà. De rares promeneurs allaient
et venaient dans les allées. Sous les fenêtres des Frères Provençaux,
il y avait néanmoins un groupe assez nombreux formé par des
badauds qui écoutaient crier nos gens de Vannes.
La première parole de Gérard fut celle-ci:
«Il faut renoncer à elle.»
Puis, comme je ne répondais pas, il ajouta:
«Petit frère, je te jure devant Dieu que je t'aime! Après notre mère,
tu es ce que j'aime le mieux au monde!»
Je gardais toujours le silence. J'étais mort. Je n'aurais pu faire un
mouvement ni prononcer une parole. Seulement il y avait en moi un
sauvage besoin de frapper. Si j'avais eu la force j'aurais tué. Je le dis
comme cela est: je suis sûr que j'aurais tué.
Il me baisa au front. Je sentis ses larmes qui me mouillaient. De quoi
se repentait-il? J'aurais voulu avoir les griffes d'un tigre.
Car on s'était attaqué à elle! On me l'avait frappée! Je ne me serais
pas défendu moi-même, non! Moi-même, je ne me serais pas vengé!
Mais elle!
«C'est un ange! murmura Gérard, c'est un pauvre bel ange!»
Il s'assit auprès de moi, et appuya sa tête contre mon épaule.
Il me faisait horreur, car sa voix sonnait à mon entendement comme
s'il eût parlé d'une morte.
Je devais souffrir encore davantage.
«Je serais vrai, reprit-il, je ne pourrais pas mentir avec toi. J'ai eu
mes amours de jeune homme. On juge les autres par soi-même. Là
bas, en Bretagne, lors de mon arrivée, ils m'ont tous dit: Ce pauvre
René est en train de se casser le cou! Et déjà, j'étais bien mécontent
de toi, frère; tu vas avoir vingt ans. Tu n'es rien. J'avais de l'ambition
pour toi. Est-ce que tu m'entends?»
J'éprouvai une sorte de surprise à pouvoir répondre. Ma langue joua
dans mon palais. Tout le surplus de mon être restait rigide et
perclus, mais je pus dire comme un automate qui parle:
«Oui, je t'entends.
—Eh bien! petit frère, je leur avais promis de t'empêcher de te
casser le cou, en principe et sans rien spécifier. L'oncle Bélébon me
mettait les éperons dans le ventre en me parlant du jeune Sauvagel,
un fils de bourgeois qui est en train de parvenir très haut, à Paris,
par le crédit de la présidente. J'étais jaloux pour toi de ce Sauvagel,
et je me disais: il a un boulet au pied, je l'en débarrasserai, il
reviendra sur l'eau. En voiture, nous n'avons parlé que de toi. Notre
père est le meilleur des hommes, mais il roule dans un cercle d'idées
qui va se rétrécissant, et le métier de ces Bélébons est de l'abrutir.
Quelque jour, je me mêlerai de cela.... Mais non! que le diable
m'emporte s'il m'arrive de me mêler jamais de la moindre des
choses!.... Notre père a donc son tic contre les mésalliances. Moi, je
ne suis pas partisan des mésalliances, mais je ne sais pas ce que je
ferais pour toi. Mon père, c'est indifférent: il m'a dit cent fois, à moi,
qu'il aimerait mieux me voir mort que mésallié. Or, voilà: en
diligence, le vieux Bélébon dit: Le meilleur moyen serait de lui
souffler sa donzelle....»
Je poussai un sourd gémissement.
«Tu vas voir, reprit Gérard. Sur ma foi, j'ai été puni! Nous sommes
fanfarons, en Bretagne, et ce n'est pas le régiment qui corrige de
cela. Tout le monde me poussa, disant: Si le petit se voit trompé, il
est fier, il sera guéri d'emblée. Moi, vois-tu, j'ai rencontré en ma vie
cent présidentes, les unes plus, les autres moins folles qu'Aurélie.
Sous l'uniforme, nous ne sommes peut-être pas aux meilleures
places pour bien voir les femmes. Celles qui nous laissent approcher
savent ce qu'elles font et cachent les autres. Il s'agissait d'une
comédienne qui s'était fait promettre le mariage par un enfant de
dix-huit ans....
—Gérard, l'interrompis-je, mon immobilité cataleptique me donnant
les apparences de la froideur, je souffre beaucoup: dis-moi ce que tu
as fait.»
Il se méprit.
«Te voilà plus calme, murmura-t-il. Pauvre fille!»
Il la plaignait presque de ma résignation.
«Je suis retourné chez M. Laïs, poursuivit-il. J'ai dit que tu m'avais
chargé de la venir prendre....
—Pour la présenter à mon père? devinai-je.
—Oui, pour la présenter à notre père.
—Et ils t'ont cru, car ils croient tout.
—Oui...... ce sont de bonnes âmes. Ils m'ont cru, en effet, la fille, le
père et le fils.
—C'est bien, Gérard, continue.»
Je pensais: «Si je ne peux pas le tuer, M. Laïs ou Philippe se
chargeront de cela.»
Il reprit:
«Annette s'est habillée à la hâte, tremblant un peu, mais souriant
aussi. Au bout de dix minutes, elle était prête. Le père et le fils sont
venus nous conduire jusqu'au fiacre et l'ont aidée à y monter. Le
père a dit: Ne crains rien; celui-là est un gentilhomme de Bretagne
et un soldat français.
Mon cœur qui avait cessé de battre, se prit tout à coup à bondir
dans ma poitrine. Je voyais et j'entendais M. Laïs.
Gérard reprit encore:
«Annette me demanda: Où donc sont-ils? Je répondis: loin d'ici,
dans le faubourg Saint Germain. Et je me mis à songer aux moyens
d'accomplir ma promesse....»
Gérard s'arrêta et passa son mouchoir sur son front.
La sueur froide coulait en ruisseaux le long de mon corps. Je
n'essayais même pas de savoir si je pouvais bouger maintenant. Je
n'avais qu'une pensée: écouter. J'étais avide de chaque mot qui
retournait le poignard dans ma blessure.
Par bouffées, les éclats de rire et les chants sortaient par les fenêtres
ouvertes des Frères-Provençaux.
«Oui, poursuivit Gérard, et Dieu sait si j'avais envie de réussir! C'est
la sottise des gens comme moi, que veux-tu? Ils croient à leurs
mères et ils ne croient pas aux femmes! comme si chacun n'avait
pas sa mère et comme si toutes les mères ne faisaient pas toutes les
femmes! Je ne sais pas si tu es irrité contre moi, depuis que mon
aveu franc et complet te demande pardon, mais je te demande
pardon deux fois que j'eus. Elle me souriait si bien! Je me dis: ce
sera trop facile! Je pris sa main, ou plutôt elle me la donna; je la tirai
vers moi, elle fit les trois quarts du chemin: sur l'étroite banquette
de la voiture, nous eussions tenu quatre! Je lui dis: Annette, je n'ai
point rencontré de femme si belle que vous.....»
Il s'arrêta encore et je voulus parler. Ma langue était de nouveau
frappée. Je vivais seulement par l'atroce angoisse qui me tordait le
cœur. Oh! pourtant, mon intelligence était nette. Je sentais chaque
coup distinctement, et il semblait que mon martyre, arrivant sans
cesse à son comble, pût indéfiniment s'aggraver.
«Je te dis, continua Gérard en se redressant, que je ne connais pas
la femme ainsi faite. La résistance a été pour moi jusqu'ici le
souverain gage de la vertu. Celle-là qui est une angélique créature,
ne m'a point résisté.» Tant mieux! m'a-t-elle dit. J'ai ajouté: Je suis
majeur, moi, je suis colonel, la femme que j'aime, je puis l'épouser.
Et, en parlant ainsi, j'ai voulu porter sa main à mes lèvres. Elle m'a
tendu son front. Puis, attirant à son tour ma main jusqu'à sa bouche,
elle l'a baisée en murmurant: Mon frère.....
Gérard pleurait. Ses larmes attirèrent les miennes. Un délire de joie
remplaça ma torture. Je ne voulais plus son sang; si j'avais pu, je me
serais précipité dans ses bras.
«Avant ce soir, dit-il en essayant de sourire, il y avait bien longtemps
que je n'avais pleuré «Mon frère!» Elle a seulement prononcé ce
mot. La honte m'a pénétré comme une sueur. René! comme elle
t'aime! comme elle t'aime!
Et avec un élan d'enthousiasme:
«J'ai vu qu'il y avait quelque chose au-dessus de la vertu qui s'irrite,
la vertu qui reste calme, tant il est loin de sa pensée qu'elle puisse
être en danger de faillir; la vertu qui pardonne du haut de sa
sainteté miséricordieuse, la vertu angélique, pour employer ce mot
qu'on prodigue si follement, vertu de celle que je te donnerais pour
femme à l'instant même, si Dieu avait voulu que je fusse ton père!»
J'eus froid. Ma joie se glaça. Un instant, j'avais cru que tout était fini
et qu'ici était le dénoûment heureux de mon supplice. Mais les
dernières paroles de Gérard firent entrer en moi une terreur
nouvelle, plus subtile et plus pénétrante, quoiqu'il ne s'y mêlât point
encore de colère.
Je retrouvai la parole pour demander:
«Où est-elle? Ai-je rêvé ou n'as-tu pas dit qu'elle était perdue pour
moi?»
Gérard baissa la tête.
«Nous étions à la porte de l'hôtel de Kervigné.... prononça-t-il
péniblement.
—Ah! fis-je en m'accrochant à ses habits, il y avait un complot! un
odieux complot! contre une enfant!
—Mon frère, ceci n'est plus ma confession, m'interrompit Gérard. Je
t'ai dit toute ma faute. A dater de ce moment, je n'ai fait que remplir
un devoir. Mlle Laïs a agi librement. Nul ne l'a forcée. Son
dévouement s'est accompli dans la plénitude de sa volonté.
—Mais où est-elle? m'écriai-je en luttant contre ma défaillance et
refoulant le râle qui obstruait ma gorge, où est-elle? Qu'avez-vous
fait d'elle? Je la veux! Je serai assassin, s'il le faut, et, si l'on m'y
pousse, parricide! Je la veux! C'est ma vie! Ecoutez! Je ne vous
tuerai pas! Je ferai mieux, je me tuerai devant vous! Vous serez tous
éclaboussés de mon sang! Je la veux! Annette! Annette! mon âme!
Soyez maudits, vous tous qui m'avez arraché le cœur!»
XXIX.
LE COMPLOT.

Je tombai. Gérard me reçut dans ses bras, et j'y restai quelques


minutes sans connaissance. Il y avait eu complot, en effet. On avait
exécuté ici la stricte volonté de mon père, qui avait participé à la
conception du plan et fourni les fonds nécessaires.
Je vais raconter le fait comme je le sus plus tard, car l'explication de
Gérard finit là pour ce soir, et les événements qui suivirent ne
laissèrent point de place aux longs discours.
Annette entra dans la maison du président de Kervigné sans
connaître les noms des maîtres de céans. Au lieu de moi qu'elle
attendait, on la mit en présence d'Aurélie. Elle avait aperçu Aurélie
une seule fois, avec moi, dans la loge du théâtre Beaumarchais; elle
la reconnut, mais cela ne lui apprit rien: j'ai dit qu'elle ignorait le rôle
joué par le président auprès de sa famille.
On se garda bien de lui montrer Laroche.
Elle demanda mon père. Aurélie répondit qu'elle avait mission de
parler pour lui.
Annette et Aurélie étaient seules désormais. Gérard avait passé dans
un appartement voisin, après s'être exprimé ainsi:
«Mademoiselle Laïs mérite plus que des égards. Quelles que soient
les apparences, je déclare que mes sentiments pour elle sont une
tendre affection et un sincère respect.»
Aurélie put être étonnée, mais elle ne le fit point paraître. Elle avait
du cœur et savait vivre. Son ridicule n'était point en jeu. Elle
s'acquitta décemment et bien de la difficile mission qui lui était
confiée.
«Mademoiselle, lui dit-elle en substance, je suis presque une mère
pour celui que vous aimez; néanmoins, je n'aurais point pris sur moi
d'agir comme je vais le faire. Ecoutez mes paroles comme si elles
tombaient de la bouche même de M. le comte de Kervigné, père du
chevalier. Votre mariage avec ce dernier est impossible. M. de
Kervigné n'y consentira jamais de son vivant et il s'arrangera de
manière à ce que sa volonté lui survive. Les raisons de ce refus n'ont
point trait à vous personnellement: c'est pourquoi il n'est pas besoin
de vous les faire connaître. Ce sont des opinions, des préjugés de
caste, si vous voulez, et des arrangements de famille. Le chevalier
doit épouser une de ses cousines, riche et belle; il l'aimait avant de
vous connaître.»
Ce dernier détail, le seul qui fit impression sur Annette, était aussi le
seul qui ft controuvé. Quant au mariage, il était en effet arrangé. Si
je n'en ai point parlé, c'est qu'on avait cru pouvoir en poser les
préliminaires sans me consulter.
Je n'ai pas besoin de peindre la situation d'Annette, isolée et privée
de ses conseils naturels, en face d'une pareille déclaration. Elle n'eut
d'abord à donner que ses larmes.
Aurélie poursuivit.
«La loi française ne nous accorde aucun moyen de vous combattre,
mademoiselle, en dehors des actions criminelles qui nous répugnent
et qui seraient, paraîtrait-il, d'une souveraine injustice, employées
contre vous. Néanmoins, je dois vous dire que le chevalier, mineur et
attiré dans la maison d'une comédienne, par le père et le frère de
celle-ci, fournit à M. de Kervigné un motif légitime d'intervenir.
J'ajoute que cette intervention, si elle avait lieu, ne serait pas sans
danger pour MM. Laïs.»
Annette voulut protester. Aurélie l'arrêta d'un mot.
«Je plaide la cause d'une famille malheureuse, dit-elle. Dieu me
garde d'accuser ni surtout d'insulter ceux qui vous sont chers! Je
veux seulement vous faire comprendre que leur qualité d'étrangers
prête une gravité nouvelle à la situation. Coupables ou non, MM. Laïs
prêtent ici le flanc, et vous savez bien que, pour se défendre, il est
parfois besoin d'attaquer. Mais ne parlons point de ceci,
mademoiselle. Vous êtes en présence d'une femme qui connaît et
qui excuse les entraînements du cœur. Moins jeune que vous et
peut-être moins belle, cette femme possède encore quelque beauté.
Pour être un juge rigoureux dans un procès de cette sorte, il faudrait
avoir passé l'âge des charmantes imprudences et des passions
irrésistibles. Tel n'est point mon cas: vous ne trouverez en moi que
clémence. Je ne veux point vous menacer; je veux vous prier, non
pas tant au nom d'une famille au sein de laquelle vous avez jeté
involontairement le trouble, qu'au nom de René lui-même. Vous ne
pouvez pas être sa femme, vous pouvez seulement briser son avenir
en restant sa maîtresse. Voyez le vrai des choses: René a dix-neuf
ans; il est dans toute la force du terme, en équilibre entre le
bonheur et le malheur. Je vous fais observer, avant de poursuivre,
qu'il n'a pas, comme beaucoup de jeunes gens, la possibilité de
parer par lui-même aux embarras matériels de la vie; il n'est ni
peintre, ni sculpteur, ni écrivain, ni avocat, ni médecin. J'entends en
herbe. Non-seulement il n'a pas d'état, mais il n'a pas même de
vocation. Je le connais aussi bien que vous. Lui retirer l'appui de sa
famille, c'est le plonger matériellement dans une misère dont il
n'aura aucun moyen de sortir. Pour un homme tel que lui, la misère
est une impasse où l'on meurt. Peut-être avez-vous fait ce rêve de
prendre sa place dans la lutte et de combattre la misère par votre
talent. Ce n'est qu'un rêve. On meurt aussi de honte, et un Kervigné
ne vit pas d'une femme. Vous pouvez briser son existence, mais
vous ne pouvez rien pour son salut.»
Annette écoutait atterrée. Les arguments d'Aurélie la frappaient
comme le choc répété d'un marteau qui aurait battu son cœur. Elle
ne pleurait plus; elle regardait avec égarement cette femme qui lui
arrachait une à une toutes ses espérances et toutes ses joies. Elle ne
discutait point en elle-même la valeur de ces diverses affirmations.
Toutes, au même degré, lui semblaient claires comme l'évidence.
Mais, à l'encontre de ce plaidoyer écrasant, il y avait une autre
évidence: l'impossibilité de renoncer à son amour.
Elle restait là, silencieuse et la tête baissée, comme une pauvre
enfant, trahie par son angoisse et qui ne trouve plus de paroles pour
repousser une accusation imméritée. C'était si bien une enfant, une
chère et adorable enfant, elle était si belle et d'une beauté si
touchante, la candeur de son inexpérience parlait si haut, à défaut
de sa voix, que la présidente eut pitié. Parmi les banalités de ce
cœur, il y avait des élans sincères. Elle eut remords de son succès, et
regretta sans doute la mission qu'elle avait acceptée, car elle
rapprocha d'elle Annette et la baisa au front d'un brusque
mouvement.
J'affirme que ce ne dut pas être une comédie, mais cela réussit
comme le plus habile des stratagèmes. Il n'y avait de vaincu chez
Annette que sa raison. Restait l'instinct, que les arguments ne
trompent point. Sans ce baiser, l'instinct d'Annette eût résisté.
«Madame, madame! s'écria-t-elle tandis que les larmes jaillissaient
inondant son visage, vous êtes bonne et j'ai confiance en vous. Il
vaut bien mieux que ce soit moi qui meure! oh! je le laisse libre! Je
lui rends sa parole! Mais s'il revenait, madame, et s'il me disait: Je
souffre....
—Pauvre fille! pauvre fille! murmura Aurélie, qui avait aussi des
larmes dans les yeux.
—Et s'il me disait, poursuivit Annette: J'aime mieux mourir avec toi
que de vivre sans toi!....
Elle joignait ses chères petites mains tremblantes et regardait son
bourreau comme on implore Dieu.
Aurélie s'essuya les yeux. Ah! c'était de bien bon cœur qu'elle
pleurait! Mais les larmes d'Aurélie sont de cette espèce toute
particulière qui coulent à torrents sous les banquettes d'un théâtre,
au cinquième acte d'un mélodrame. Ces larmes viennent aussi du
cœur, je le pense, comme la sueur sort de la peau. C'est l'expulsion
d'un liquide. J'ai connu une brave dame fort à son aise qui plaidait
depuis cinq ans contre sa mère très pauvre, au sujet d'une pension
alimentaire, et qui mouillait comme cela tout d'un coup trois
mouchoirs à ce moment suprême où le premier rôle ouvre ses
robustes bras à l'ingénue, au son de cette musique: «Ma fille! ma
mère! Est-ce bien toi! Mon Dieu! merci!»
Elle perdit son procès et interjeta appel.
Aurélie était loin de là. Néanmoins, les larmes ne lui enlevaient
jamais tout son sang-froid.
«Il vous dira cela, mon enfant, répondit-elle. Comptez-y bien! Ils
disent tous cela! Ah! si vous les connaissiez comme moi! sacrifiée
dès l'âge de quinze ans et livrée à un homme qui était déjà presque
un vieillard, j'ai éprouvé des peines, dont le récit.... Mais il ne s'agit
pas de cela!»
Elle eut la force de ne pas raconter son histoire!
«C'est de vous qu'il s'agit, reprit-elle. Il vous dira cela: c'est le refrain
obligé. On me l'a dit vingt fois, et j'ai su garder mon innocence! Ah!
il faut de la force dans notre sexe! Il ne faut pas qu'il vous dise cela.
Comment l'en empêcher? Je réponds nettement et franchement:
vous devez fuir.
—Fuir!... répéta Annette stupéfaite.
—Il n'y a pas deux manière de trancher la question. C'est à savoir si
vous voulez le perdre ou le sauver.
—Je veux le sauver, madame! Sur tout ce que j'ai de plus cher au
monde, je vous jure que je veux le sauver!
—Vous êtes une chère et digne créature.
—Mais pourquoi fuir? et où fuir? et comment?»
L'accent d'Aurélie devint solennel.
«C'est ici, ma chère demoiselle, dit-elle, que vous allez mesurer par
vous-même toute la gravité des circonstances. Les parents étaient
décidés à tout. Et laissez-moi vous dire, quoique mon intention ne
soit point de marchander, ah! certes, laissez-moi vous dire que vous
n'avez pas ici affaire à des millionnaires. Il se peut que vous ayez
nourri quelque petite illusion à cet égard. Je vous crois le
désintéressement même; cependant l'imagination va, on se fait des
idées: il y a en Bretagne de ces vieilles maisons qui ont l'opulence du
marquis de Carabas.
—Dieu m'est témoin, madame.... voulut l'interrompre Annette.
—Evidemment, ma fille, évidemment. Je suis comme cela. Je n'ai
jamais pu me mettre en tête une idée d'argent. Je gagnerais deux
mille écus par an à savoir marchander. Cela dépend des natures. On
ne se fait pas. Je constate seulement que les Kervigné ont une
fortune honnête et voilà tout. Ils sont trois enfants; René est le
cadet; on a fourré beaucoup aux deux aînés, qui seront avantagés.
Une fortune honnête de Bretagne n'est pas une fortune honnête de
Paris. En somme, s'il y a en tout trente à quarante mille livres de
rente.... c'est encore joli, je suis de votre avis, mais ce n'est pas le
Pérou!»
Annette Laïs était muette maintenant.
«J'arrive à la conclusion, poursuivit Aurélie, car ceci est tout un
raisonnement. Comme je vous le disais, vous allez juger de la gravité
des circonstances par le sacrifice que la famille consent à s'imposer.»
Annette releva la tête involontairement et devint pâle, mais elle
n'interrompit point.
«Le docteur Josaphat trouve cela énorme! continua Aurélie. C'est
notre médecin, et je crois que vous le connaissez. Il a dit le mot:
énorme! La famille offre dix mille francs.»
Annette resta immobile.
Aurélie attendit un instant, puis elle reprit:
«Mademoiselle, j'avoue que vous m'étonnez. La somme est ronde et
l'on ne vous doit rien du tout, puisque René est mineur.»
Ce ne furent pas des larmes, cette fois, ce fut un feu qui jaillit des
prunelles d'Annette Laïs. Aurélie eut peur. Bien que le fond de sa
pensée ne fût pas la délicatesse même, son expression avait été plus
malheureuse encore que sa pensée. Elle le sentit et recula.
«Mon enfant, dit-elle avec bonhomie, nous ne sommes pas ici dans
le joli pays du roman. Je serais au regret de vous avoir blessée, mais
il faut appeler les choses par leur nom. Pour se déplacer, il faut de
l'argent. Nul ne songe à vous payer. Vous n'avez point mérité d'être
humiliée; si vous l'aviez mérité, peut-être ne me serais-je point
chargée de la mission difficile que je remplis auprès de vous. Ces dix
mille francs sont pour les frais de votre voyage.»
Annette répéta:
«Mon voyage!....»
Aurélie eut un geste d'impatience.
«Ne vous fâchez pas, madame, dit Annette avec douceur. Je suis
avec vous contre moi-même. J'ai compris une partie de ce que vous
m'avez expliqué, surtout ceci: je peux lui faire beaucoup de mal. Je
ne veux pas lui faire de mal. Expliquez encore.
—Chère petite! murmura Aurélie, sincèrement touchée. Vous voulez
donc que je leur dise à tous: C'est un ange, cette enfant-là! Je ne
sais plus où j'en suis, moi... Eh bien, oui, votre voyage. Si vous
restiez à Paris, comment empêcher René de vous voir?
—Il ne faut plus qu'il me voie, murmura Annette, c'est juste.»
La présidente lui jeta un regard défiant, tant ceci dépassait les
bornes de la résignation vraisemblable. Annette reprit:
«Mon père et mon frère ne consentiront jamais à cela.
—Si vous leur dites....
—Madame, chez nous, chacun sait lire dans le cœur des autres. J'ai
montré mon amour. J'aurais beau dire moi-même au père et à
Philippe: je ne l'aime plus, ils ne me croiraient pas. Ce sont des
exilés, mais ils sont fiers autant que pas un d'entre vous. Je partirai
seule.»
Aurélie ouvrit de grands yeux.
«Je partirai seule, répéta Annette, dont la voix devenait paisible et
qui essayait de comprimer ses sanglots. Je ne veux pas être entre lui
et le bonheur. Oh! non! Je n'ai rien à lui donner. Vous avez dit la
vérité, madame: il n'accepterait pas le pain qui se gagne au théâtre.
J'en suis sûre. Et en dehors de cela, que puis-je faire? Nous sommes
deux pauvres malheureux, nous ne savons qu'aimer. Je n'avais
jamais pensé à cela. Dites à son père et à sa mère qu'ils me
pardonnent: je n'avais pas la volonté de les offenser.... et à lui....
Oh! à lui, ne lui dites rien, madame. Il saurait bien que vous mentez,
si vous lui disiez que je l'ai oublié!»
Elle se leva et fit un pas vers la porte. Aurélie, presque aussi émue
qu'elle, lui demanda où elle allait.
«Je ne sais pas, répondit Annette.
—Pensez-vous donc, chère enfant, que nous puissions vous
abandonner ainsi?»
Annette appuya ses deux mains contre son front. Elle se sentait
devenir folle.
«René! René!» murmura-t-elle.
Puis, regardant la présidente en face avec une farouche énergie:
«Si j'allais le tuer, au lieu de le sauver!» dit-elle.
Aurélie ouvrait la bouche; elle lui imposa silence d'un geste et
ajouta:
«Est-ce que vous savez comme il m'aime? Il n'y a que moi pour le
savoir, parce que nous nous aimons l'un comme l'autre. Moi, j'en
mourrai, je le sais. S'il allait mourir!
—Ma pauvre chérie, murmura Mme de Kervigné, nos jeunes Français
ne meurent pas de cela! Et quant à vous, le temps, l'absence....»
Son sourire sceptique ne tint pas contre la pâleur indignée d'Annette.
«Dieu veuille donc qu'il n'y en ait que deux à mourir, murmura celle-
ci d'une voix brisée: le père et moi! ceux-là sont condamnés.»
Elle revint d'un pas ferme vers le milieu de la chambre.
«Vous aviez un projet, dit-elle, un plan arrêté. Tout ceci n'a pas été
fait à la légère. La conduite du frère de René prouve qu'on voulait
tenter plus d'un moyen de se défaire de moi. Me voici prête à entrer
dans vos vues, quelles qu'elles soient, pour lui garder sa famille et
son bonheur. Ne craignez pas de parler franchement: j'écoute.
—En vérité, balbutia la présidente qui perdait contenance, je ne
m'attendais pas... Nous comptions tout uniment obtenir votre départ
et celui de MM. Laïs pour l'étranger.
—Ne songez plus à cela. N'espérez rien que de mon isolement. S'ils
étaient ici, je me souviendrais que René m'aime et je vous braverais.
—Un couvent....
—Un couvent soit. J'y pensais. Mais hâtez-vous. Je ne sais plus si je
suis folle et si mon réveil sera la raison, ou bien si j'ai ma raison et si
je me réveillerai dans la folie, mais je sais que je vais m'éveiller:
hâtez-vous!»
Aurélie hésita. Un instant, tout ce qui restait en elle de noblesse et
de générosité se révolta. Ce fut court. Elle se dit: C'est une
comédienne.
Elle était tout habillée et coiffée. Elle jeta son mantelet sur ses
épaules.
«Vous avez deviné juste, prononça-t-elle résolûment. Nos mesures
étaient prises. Rien ne devait nous arrêter, sinon la violence
matérielle. Ce qui arrive me fend le cœur, mais je jure que c'est la
nécessité. Mademoiselle Laïs, je vous estime et je vous aime; si,
quelque jour, vous avez besoin de moi....
—Moi, je vous jure que je n'aurai jamais besoin de vous, madame!
l'interrompit Annette. Je suis prête: hâtez-vous!»
Il y avait une voiture attelée dans la cour de l'hôtel. Elles partirent,
et Gérard se précipita comme un fou hors du cabinet où il avait tout
entendu. Il était ivre en faisant le chemin de la rue du Regard au
Palais-Royal. Il me dit, ce soir-là même, que jamais en sa vie il
n'avait éprouvé de torture pareille.
Mais il n'eut pas le loisir de me faire le récit qui précède, et ce fut ici
ma dernière entrevue avec le colonel vicomte de Kervigné, mon
frère, à qui Dieu laissa juste le temps de me montrer son loyal cœur.
Il était agenouillé près de moi quand je sortis de mon
évanouissement et me tenait serré dans ses bras.
«Petit frère! me dit-il, au moment où je rouvrais les yeux, je crois
que j'ai bien fait. Il y a des choses impossibles. Je me suis jeté entre
toi et un malheur. On ne fera jamais revenir mon père: voilà pour la
raison. Au diable la raison! je sais où est ton Annette: je vais aller te
la chercher, si tu veux!»
Je me pendis à son cou dans un transport de joie. Je ne savais pas
encore ce qui était arrivé; mais je devinais au pire, et cette bonne
parole était pour moi comme la corde lancée à l'homme qui se noie.
«Partons! m'écriai-je. Crois-tu que je ne puisse pas te suivre?»
Et je bondis sur mes pieds, frémissant d'aise et d'impatience.
«Ma parole! murmura Gérard, il était mort tout à l'heure, et
maintenant le voilà qui danse comme un cheval trop ardent. On
n'apprend pas tout à l'école, ni même au régiment. Je ne connaissais
pas de femme pareille à Annette et je pensais que les amours
comme le tien étaient bons à mettre dans les livres. Oui. Et je suis
arrivé jusqu'au grade de colonel avant d'en savoir si long que cela!
—Mais partons donc!
—C'est qu'il nous faut des chevaux, petit frère.
—Quoi! déjà enlevée!
—Presque nonne! Ah! c'était bien mené! Mais nous avons dix lieues
de marge, et je te promets que nous la rattraperons en route.»
Le tambour roulait pour la fermeture du jardin. Tous les gens de
Vannes s'étaient mis aux fenêtres des Frères-Provençaux pour voir
cette chose curieuse. Les badauds, de leur côté, avaient peine à
quitter leur poste et jetaient un dernier regard d'envie aux croisées
du restaurant.
«Si nous avions quelqu'un.... commença Gérard.
—Présent, quoique ça! l'interrompit la bonne voix de Joson. Ej'
savais qu'y âvait du tâbâc! Faut pas mentir. J'écoutais.... sans
écouter, comme on dit....
—Mon cheval est ici près, aux écuries de l'hôtel des Princes, dit
Gérard. Va prévenir qu'on le selle avec deux autres bons coureurs:
tu viendras avec nous.»
Joson poussa un long cri de triomphe et fit la roue sur place, une
fois à droite, une fois à gauche.
«Nâge, tribord! appuie, bâbord! allume partout, courtequeue! J'ai bu
du punje! A la houp! Et des glâces! C'est-il froid, pour sûr et pour
vrai? Nâge!»
Il perçait déjà le groupe des badauds à coups de poing.
Cinq minutes après, nous allions à franc étrier sur la route de
Versailles.
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and


personal growth!

ebookball.com

You might also like