Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 711f84d

Browse files
fix index to avoid blank lines
1 parent 2864380 commit 711f84d

20 files changed

+0
-24
lines changed

‎book/chapters/algorithms-analysis.adoc‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,6 @@ To give you a clearer picture of how different algorithms perform as the input s
6060
|=============================================================================================
6161

6262
indexterm:[Permutation]
63-
6463
However, if you keep the input size constant, you can notice the difference between an efficient algorithm and a slow one. An excellent sorting algorithm is `mergesort` for instance, and inefficient algorithm for large inputs is `bubble sort` .
6564
Organizing 1 million elements with merge sort takes 20 seconds while bubble sort takes 12 days, ouch!
6665
The amazing thing is that both programs are measured on the same hardware with the same data!

‎book/chapters/array.adoc‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -184,5 +184,4 @@ To sum up, the time complexity on an array is:
184184
^|_Index/Key_ ^|_Value_ ^|_beginning_ ^|_middle_ ^|_end_ ^|_beginning_ ^|_middle_ ^|_end_
185185
| Array ^|O(1) ^|O(n) ^|O(n) ^|O(n) ^|O(1) ^|O(n) ^|O(n) ^|O(1) ^|O(n)
186186
|===
187-
188187
indexterm:[Runtime, Linear]

‎book/chapters/backtracking.adoc‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,6 @@ Let's do an exercise to explain better how backtracking works.
4444
> Return all the permutations (without repetitions) of a given word.
4545

4646
indexterm:[Permutation]
47-
4847
For instace, if you are given the word `art` these are the possible permutations:
4948

5049
----

‎book/chapters/big-o-examples.adoc‎

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,6 @@ As you can see, in both examples (array and linked list) if the input is a colle
4646
== Logarithmic
4747

4848
Represented in Big O notation as *O(log n)*, when an algorithm has this running time it means that as the size of the input grows the number of operations grows very slowly. Logarithmic algorithms are very scalable. One example is the *binary search*.
49-
5049
indexterm:[Runtime, Logarithmic]
5150

5251
[#logarithmic-example]
@@ -128,7 +127,6 @@ How do we obtain the running time of the merge sort algorithm? The mergesort div
128127
== Quadratic
129128

130129
indexterm:[Runtime, Quadratic]
131-
132130
Running times that are quadratic, O(n^2^), are the ones to watch out for. They usually don’t scale well when they have a large amount of data to process.
133131

134132
Usually, they have double-nested loops that where each one visits all or most elements in the input. One example of this is a naïve implementation to find duplicate words on an array.
@@ -223,7 +221,6 @@ A factorial is the multiplication of all the numbers less than itself down to 1.
223221
=== Getting all permutations of a word
224222

225223
One classic example of an _O(n!)_ algorithm is finding all the different words that can be formed with a given set of letters.
226-
227224
indexterm:[Permutation]
228225

229226
.Word's permutations

‎book/chapters/divide-and-conquer--fibonacci.adoc‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,6 @@
11
= Recursive Fibonacci Numers
22

33
To illustrate how we can solve a problem using divide and conquer, let's write a program to find the n-th fibonacci number.
4-
54
indexterm:[Fibonacci]
65

76
.Fibonacci Numbers

‎book/chapters/divide-and-conquer--intro.adoc‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
11
Divide and conquer is an strategy for solving algorithmic problems.
22
It splits the input into manageble parts recursively and finally join solved pieces to form the end result.
3-
43
indexterm:[Divide and Conquer]
54

65
We have already done some divide and conquer algorithms. This list will refresh you the memory.

‎book/chapters/dynamic-programming--fibonacci.adoc‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,6 @@
33
Let's solve the same Fibonacci problem but this time with dynamic programming.
44

55
When we have recursive functions doing duplicated work is the perfect place for a dynamic programming optimization. We can save (or cache) the results of previous operations and speed up future computations.
6-
76
indexterm:[Fibonacci]
87

98
.Recursive Fibonacci Implemenation using Dynamic Programming
@@ -25,7 +24,6 @@ graph G {
2524
....
2625

2726
This looks pretty linear now. It's runtime _O(n)_!
28-
2927
indexterm:[Runtime, Linear]
3028

3129
TIP: Saving previous results for later is a technique called "memoization" and is very common to optimize recursive algorithms with exponential time complexity.

‎book/chapters/insertion-sort.adoc‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -36,5 +36,4 @@ include::{codedir}/algorithms/sorting/insertion-sort.js[tag=sort, indent=0]
3636
- <<Adaptive>>: [big]#✅# Yes
3737
- Time Complexity: [big]#⛔️# <<Quadratic>> _O(n^2^)_
3838
- Space Complexity: [big]#✅# <<Constant>> _O(1)_
39-
4039
indexterm:[Runtime, Quadratic]

‎book/chapters/linked-list.adoc‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -250,7 +250,6 @@ So far, we have seen two liner data structures with different use cases. Here’
250250
|===
251251

252252
indexterm:[Runtime, Linear]
253-
254253
If you compare the singly linked list vs. doubly linked list, you will notice that the main difference is deleting elements from the end. For a singly list is *O(n)*, while for a doubly list is *O(1)*.
255254

256255
Comparing an array with a doubly linked list, both have different use cases:

‎book/chapters/map-hashmap.adoc‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -296,5 +296,4 @@ Hash Map it’s very optimal for searching values by key in constant time *O(1)*
296296
{empty}* = Amortized run time. E.g. rehashing might affect run time.
297297

298298
indexterm:[Runtime, Linear]
299-
300299
As you can notice we have amortized times since, in the unfortunate case of a rehash, it will take O(n) while it resizes. After that, it will be *O(1)*.

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /