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 6c53fdd

Browse files
reorganize sorting info
1 parent fa13238 commit 6c53fdd

File tree

11 files changed

+174
-152
lines changed

11 files changed

+174
-152
lines changed

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -95,7 +95,7 @@ An algorithm with a linearithmic runtime is represented as _O(n log n)_. This on
9595
[#linearithmic-example]
9696
=== Sorting elements in an array
9797

98-
The merge sort, like its name indicates, has two functions merge and sort. Let’s start with the sort function:
98+
The ((Merge Sort)), like its name indicates, has two functions merge and sort. Let’s start with the sort function:
9999

100100
// image:image9.png[image,width=528,height=383]
101101

‎book/chapters/bubble-sort.adoc‎

Lines changed: 42 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
= Bubble Sort
22

3-
Bubble sort is a simple sorting algorithm that "bubbles up" the biggest values to the right side of the array.
3+
((Bubble sort)) is a simple sorting algorithm that "bubbles up" the biggest values to the right side of the array.
44
It's also call _((sinking sort))_ because the largest values sinks to the right side of the array.
55
This algorithm is adaptive which means that if the array is already sorted it will take only _O(n)_ to "sort".
66
However, if the array is quite out of order it will require _O(n^2^)_ to sort.
@@ -21,6 +21,47 @@ include::{codedir}/algorithms/sorting/bubble-sort.js[tag=sort, indent=0]
2121
<5> (optimization) If there was no swap means that the array is already sorted and no more work is needed. This make this sorting adaptive, if everything is sorted it will be only one pass: _O(n)_.
2222
<6> Each step moves the largest element from `0` to `n - i` to the right side. So, we need to do this `n - 1` to sort the array in case most elements needs to be swapped.
2323

24+
25+
The swap function is implemented as follows.
26+
27+
.Swap function
28+
[source, javascript]
29+
----
30+
include::{codedir}/algorithms/sorting/sorting-common.js[tag=swap, indent=0]
31+
----
32+
33+
It uses JavaScript ES6 destructing arrays.
34+
35+
.JavaScript Array destructuring
36+
****
37+
*Assignment separate from declaration*
38+
39+
A variable can be assign to its values using the destructing syntax.
40+
41+
[source, javascript]
42+
----
43+
let a, b;
44+
45+
[a, b] = [1, 2];
46+
console.log(a); //↪️ 1
47+
console.log(b); //️↪️ 2
48+
----
49+
50+
*Swapping variables*
51+
52+
Two variables values can be swapped in one destructuring expression.
53+
54+
[source, javascript]
55+
----
56+
[a, b] = [b, a];
57+
console.log(a); //↪️ 2
58+
console.log(b); //️↪️ 1
59+
----
60+
61+
Without destructuring assignment, swapping two values requires a temporary variable.
62+
****
63+
64+
2465
Bubble sort has a <<Quadratic>> running time, as you might infer from the nested for-loop.
2566

2667
== Bubble Sort Properties

‎book/chapters/chapter4.adoc‎

Lines changed: 5 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -6,29 +6,21 @@ include::algorithms-intro.adoc[]
66

77
:leveloffset: +1
88

9-
//
10-
// Sorting algorithms
11-
//
12-
= Sorting Algorithms
13-
14-
Sorting is one of the most common solutions when we want to extract some insights about a collection of data.
15-
We can sort to get the maximum or minimun value and many algorithmic problems involves sorting data first.
16-
17-
Before we dive into the most well-known sorting algorithms, let's discuess about the sorting properties.
9+
include::sorting-intro.adoc[]
1810

1911
:leveloffset: +1
2012

21-
// TODO: pending
22-
include::sorting-intro.adoc[]
13+
include::sorting-properties.adoc[]
14+
2315

2416
// Slow Sorting
2517

2618
include::bubble-sort.adoc[]
2719

28-
include::selection-sort.adoc[]
29-
3020
include::insertion-sort.adoc[]
3121

22+
include::selection-sort.adoc[]
23+
3224

3325
// include::insertion-selection-bubble-sort.adoc[]
3426

‎book/chapters/greedy-algorithms--intro.adoc‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,7 @@ Don't get the wrong idea some greedy algorithms works very well if they are desi
3232
.Some examples greedy algorithms that works well:
3333
- <<Selection Sort>>: we select the best (minimum value) remove it from the input and then select the next minimum until everything is processed.
3434
- <<Merge Sort>>: the "merge" uses a greedy algorithm, where it combine two sorted arrays by looking at their current values and choosing the best (minimum) at every time.
35+
indexterm:[Merge Sort]
3536
3637
3738
.In general, we can follow these steps to design Greedy Algorithms:

‎book/chapters/insertion-sort.adoc‎

Lines changed: 10 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,6 @@
11
= Insertion Sort
22

3-
Insertion sort is a simple sorting algorithm. It is onne of the most natural way of sorting. You take an element and move it to the sorted pile. You take the next element and move it where it belongs in the sorted pile. Repeat for the rest of the elements.
4-
5-
If you are given some cards that's probably how you are going to sort them.
3+
((Insertion sort)) is a simple sorting algorithm. It is one of the most natural way of sorting. If you are given some cards that's probably how you are going to sort them.
64

75
// Good illustration on of sorting a deck of cards: https://www.khanacademy.org/computing/computer-science/algorithms/insertion-sort/a/insertion-sort
86

@@ -13,17 +11,22 @@ If you are given some cards that's probably how you are going to sort them.
1311
----
1412
include::{codedir}/algorithms/sorting/insertion-sort.js[tag=sort, indent=0]
1513
----
14+
<1> Convert to array or clone the array.
15+
<2> Start with the 2nd element. Everything on the left is considered sorted.
16+
<3> Compare current element (2nd) to the previous one. If is bigger swap them, if not move to the next one.
17+
<4> We check every element on the left side and swap any of them that are out of order
18+
1619

1720
// .Swap function
1821
// [source, javascript]
1922
// ----
2023
// include::{codedir}/algorithms/insertion-sort.js[tag=swap, indent=0]
2124
// ----
2225

23-
.This is how it works:
24-
. Visit 2nd. If the current element is smaller than the previous one move to the place it should be.
25-
. Visit next element and do the same thing. The left side is always sorted and the right is not (yet).
26-
. Repeat for the rest of the array.
26+
// .This is how it works:
27+
// . Visit 2nd. If the current element is smaller than the previous one move to the place it should be.
28+
// . Visit next element and do the same thing. The left side is always sorted and the right is not (yet).
29+
// . Repeat for the rest of the array.
2730

2831
== Insertion Sort Properties
2932

‎book/chapters/merge-sort.adoc‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,11 @@
11
= Merge Sort
22

3-
Merge sort is an efficient sorting algorithm that uses "divide and conquer" paradigm to accomplish it task faster. It uses auxiliary memory in the process of sorting.
3+
((Merge sort)) is an efficient sorting algorithm that uses <<Divide and Conquer, divide and conquer>> paradigm to accomplish its task faster. It uses auxiliary memory in the process of sorting.
44

55
Merge sort algorithm splits the array in halves until 2 or less elements are left. It sorts these two elements and then merge back all halves until the whole array is sorted.
66

7+
image:image11.png[Mergesort visualization,width=500,height=600]
8+
79
== Merge Sort Implementation
810

911
Merge sort implementation is as follows

‎book/chapters/selection-sort.adoc‎

Lines changed: 14 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,6 @@
11
= Selection Sort
22

3-
The selection sort is a simple sorting algorithm. As its name indicates, it chooses the lowest element from the list and move it where it should be.
4-
5-
TIP: Selection sort is a in-place sorting algorithms, it should be used when auxiliary memory is limited.
3+
The ((selection sort)) is a simple sorting algorithm. As its name indicates, it chooses the lowest element from the list and move it where it should be.
64

75
.Selection sort algorithm
86
. Start with the element in position 0.
@@ -19,54 +17,24 @@ For implementing the selection sort we need 2 indexes.
1917
----
2018
include::{codedir}/algorithms/sorting/selection-sort.js[tag=sort, indent=0]
2119
----
20+
<1> Converts any collection to an array or clone existing array
21+
<2> Visit all elements in the array starting from 1st element (index 0)
22+
<3> Everything to the left side is considered sorted in it's final position. So, select `left` as the minimun value
23+
<4> Compare the `selection` to every element to the right
24+
<5> If it finds a value *smaller* than the selection, then update the `selection`.
25+
<6> Put the next smallest item to it's final position
2226

23-
One index is for the position in question (selection/outer) and another one for finding the minimun in the rest of the array (element/inner).
24-
25-
The swap function is implemented as follows.
26-
27-
.Swap function
28-
[source, javascript]
29-
----
30-
include::{codedir}/algorithms/sorting/sorting-common.js[tag=swap, indent=0]
31-
----
32-
33-
It uses JavaScript ES6 destructing arrays.
34-
35-
.JavaScript Array destructuring
36-
****
37-
*Assignment separate from declaration*
38-
39-
A variable can be assign to its values using the destructing syntax.
27+
TIP: Selection sort minimize the number of swaps. It only does a swap per cycle while insertion sort and bubble sort swap inmediately.
4028

41-
[source, javascript]
42-
----
43-
let a, b;
44-
45-
[a, b] = [1, 2];
46-
console.log(a); //↪️ 1
47-
console.log(b); //️↪️ 2
48-
----
49-
50-
*Swapping variables*
51-
52-
Two variables values can be swapped in one destructuring expression.
53-
54-
[source, javascript]
55-
----
56-
[a, b] = [b, a];
57-
console.log(a); //↪️ 2
58-
console.log(b); //️↪️ 1
59-
----
60-
61-
Without destructuring assignment, swapping two values requires a temporary variable.
62-
****
29+
One index is for the position in question (selection/left) and another one for finding the minimun in the rest of the array (right).
6330

6431
== Selection Sort Properties
6532

66-
// - <<Stable>>: [big]#✅# Yes
67-
- <<Stable>>: [big]#️️❌# No
6833
- <<In-place>>: [big]#✅# Yes
69-
- <<Online>>: [big]#✅# Yes
70-
- <<Adaptive>>: [big]#✅# Yes
34+
- <<Stable>>: [big]#️️❌# No
35+
- <<Adaptive>>: [big]#️️❌# No
36+
- <<Online>>: [big]#️️❌# No
7137
- Time Complexity: [big]#⛔️# <<Quadratic>> _O(n^2^)_
7238
- Space Complexity: [big]#✅# <<Constant>> _O(1)_
39+
40+
CAUTION: Selection sort is the worst compared <<Bubble Sort>> and <<Insertion Sort>>. The only advantage of selection sort is that it minimizes the number of swaps. In case, that swapping is expensive then it could make sense to use this one over the others.

‎book/chapters/sorting-intro.adoc‎

Lines changed: 11 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -1,71 +1,15 @@
1-
= Sorting Properties
1+
= Sorting Algorithms
22

3-
Sorting implementations with the same time complexity might manipulate the data differently. We want to understand these differences so we can be aware of the side-effects it will have on data or extra resources. For instance, some solutions will need auxiliary memory to store temporary data while sorting while other can do it in place.
3+
Sorting is one of the most common solutions when we want to extract some insights about a collection of data.
4+
We can sort to get the maximum or minimun value and many algorithmic problems involves sorting data first.
45

5-
== Stable
6+
.We are going to explore 3 basic sorting algorithms _O(n^2^)_ which have low overhead:
7+
- <<Bubble Sort>>
8+
- <<Selection Sort>>
9+
- <<Insertion Sort>>
610
7-
An ((stable sorting)) algorithms keeps the relative order of items with the same comparison criteria.
11+
.Efficient sorting algorithms _O(n log n)_:
12+
- <<Merge Sort>>
13+
- <<Quicksort>>
814
9-
This specially useful when you want to sort on multiple phases.
10-
11-
.Let's say you have the following data:
12-
[source, javascript]
13-
----
14-
const users = [
15-
{ name: 'Bob', age: 32 },
16-
{ name: 'Alice', age: 30 },
17-
{ name: 'Don', age: 30 },
18-
{ name: 'Charly', age: 32 },
19-
];
20-
----
21-
22-
.If you sort by `name` you would have:
23-
[source, javascript]
24-
----
25-
[
26-
{ name: 'Alice', age: 30 },
27-
{ name: 'Bob', age: 32 },
28-
{ name: 'Charly', age: 32 },
29-
{ name: 'Don', age: 30 },
30-
];
31-
----
32-
33-
Then, here comes the important part, if you sort by `age` you might get two different results.
34-
35-
.If the sorting algorithm is *stable*, it should keep the items with the same age ordered by `name`:
36-
[source, javascript]
37-
----
38-
[
39-
{ name: 'Alice', age: 30 },
40-
{ name: 'Don', age: 30 },
41-
{ name: 'Bob', age: 32 },
42-
{ name: 'Charly', age: 32 },
43-
];
44-
----
45-
46-
.However, if the sorting is *not stable*, then you will lose the relative order of the items and get something like this:
47-
[source, javascript]
48-
----
49-
[
50-
{ name: 'Don', age: 30 },
51-
{ name: 'Alice', age: 30 },
52-
{ name: 'Charly', age: 32 },
53-
{ name: 'Bob', age: 32 },
54-
];
55-
----
56-
57-
Both results are correctly sorted by `age`, however, having a stable sorting is better if you want to keep the relative possition of keys with the same value.
58-
59-
== In-place
60-
61-
An ((in-place sorting)) algorithm would a _space complexity_ of O(1). In other words, it does not use any other auxiliary memory because it moves the items in the collection itself.
62-
This is specially useful for memory constraint enviroments like robotics or embedded systems in appliances.
63-
64-
== Online
65-
66-
It can sort a list as it receives it.
67-
((Online sorting)) algorithms doesn't have to re-sort the whole collection for every new item added.
68-
69-
== Adaptive
70-
71-
Algorithms with ((adaptive sorting)) run faster, close to _O(n)_, on an already sorted (or partially sorted) collection.
15+
Before we dive into the most well-known sorting algorithms, let's discuess about the sorting properties.
Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
= Sorting Properties
2+
3+
Sorting implementations with the same time complexity might manipulate the data differently. We want to understand these differences so we can be aware of the side-effects it will have on data or extra resources. For instance, some solutions will need auxiliary memory to store temporary data while sorting while other can do it in place.
4+
5+
== Stable
6+
7+
An ((stable sorting)) algorithms keeps the relative order of items with the same comparison criteria.
8+
9+
This specially useful when you want to sort on multiple phases.
10+
11+
.Let's say you have the following data:
12+
[source, javascript]
13+
----
14+
const users = [
15+
{ name: 'Bob', age: 32 },
16+
{ name: 'Alice', age: 30 },
17+
{ name: 'Don', age: 30 },
18+
{ name: 'Charly', age: 32 },
19+
];
20+
----
21+
22+
.If you sort by `name` you would have:
23+
[source, javascript]
24+
----
25+
[
26+
{ name: 'Alice', age: 30 },
27+
{ name: 'Bob', age: 32 },
28+
{ name: 'Charly', age: 32 },
29+
{ name: 'Don', age: 30 },
30+
];
31+
----
32+
33+
Then, here comes the important part, if you sort by `age` you might get two different results.
34+
35+
.If the sorting algorithm is *stable*, it should keep the items with the same age ordered by `name`:
36+
[source, javascript]
37+
----
38+
[
39+
{ name: 'Alice', age: 30 },
40+
{ name: 'Don', age: 30 },
41+
{ name: 'Bob', age: 32 },
42+
{ name: 'Charly', age: 32 },
43+
];
44+
----
45+
46+
.However, if the sorting is *not stable*, then you will lose the relative order of the items and get something like this:
47+
[source, javascript]
48+
----
49+
[
50+
{ name: 'Don', age: 30 },
51+
{ name: 'Alice', age: 30 },
52+
{ name: 'Charly', age: 32 },
53+
{ name: 'Bob', age: 32 },
54+
];
55+
----
56+
57+
Both results are correctly sorted by `age`, however, having a stable sorting is better if you want to keep the relative possition of keys with the same value.
58+
59+
== In-place
60+
61+
An ((in-place sorting)) algorithm would a _space complexity_ of O(1). In other words, it does not use any other auxiliary memory because it moves the items in the collection itself.
62+
This is specially useful for memory constraint enviroments like robotics or embedded systems in appliances.
63+
64+
== Online
65+
66+
It can sort a list as it receives it.
67+
((Online sorting)) algorithms doesn't have to re-sort the whole collection for every new item added.
68+
69+
== Adaptive
70+
71+
Algorithms with ((adaptive sorting)) run faster, close to _O(n)_, on an already sorted (or partially sorted) collection.

0 commit comments

Comments
(0)

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