1

CSCI 104
Sorting Algorithms
Mark Redekopp
David Kempe
 2

Algorithm Efficiency

SORTING
 3

Sorting
• If we have an unordered list, sequential
search becomes our only choice List 7 3 8 6 5 1
index 0 1 2 3 4 5
• If we will perform a lot of searches it may Original
be beneficial to sort the list, then use
binary search List
index
1 3 5 6 7 8
0 1 2 3 4 5
• Many sorting algorithms of differing Sorted

complexity (i.e. faster or slower)

• Sorting provides a "classical" study of
algorithm analysis because there are many
implementations with different pros and
cons
 4

Applications of Sorting
• Find the set_intersection of the 2 A 7 3 8 6 5 1
0 1 2 3 4 5

lists to the right

B 9 3 4 2 7 8 11
– How long does it take? 0 1 2 3 4 5 6

Unsorted

• Try again now that the lists are

A 1 3 5 6 7 8
sorted 0 1 2 3 4 5

– How long does it take? B 2 3 4 7 8 9 11

0 1 2 3 4 5 6

Sorted
 5

Sorting Stability
• A sort is stable if the order of equal
items in the original list is maintained List 7,a 3,b 5,e 8,c 5,d

in the sorted list index 0 1 2 3 4

Original
– Good for searching with multiple criteria
– Example: Spreadsheet search List 3,b 5,e 5,d 7,a 8,c
index 0 1 2 3 4
• List of students in alphabetical order first Stable Sorting
• Then sort based on test score
• I'd want student's with the same test score to List 3,b 5,d 5,e 7,a 8,c
index 0 1 2 3 4
appear in alphabetical order still Unstable Sorting

• As we introduce you to certain sort

algorithms consider if they are stable
or not
 6

Bubble Sorting
• Main Idea: Keep comparing neighbors,
moving larger item up and smaller item List 7 3 8 6 5 1

down until largest item is at the top. Original

Repeat on list of size n-1 List 3 7 6 5 1 8

• Have one loop to count each pass, (a.k.a. i) After Pass 1

to identify which index we need to stop at List 3 6 5 1 7 8

• Have an inner loop start at the lowest After Pass 2

index and count up to the stopping List 3 5 1 6 7 8
location comparing neighboring elements
After Pass 3
and advancing the larger of the neighbors
List 3 1 5 6 7 8

After Pass 4
List 1 3 5 6 7 8

After Pass 5
 7

Bubble Sort Algorithm

void bsort(vector<int> mylist)
{
int i ;
for(i=mylist.size()-1; i > 0; i--){
for(j=0; j < i; j++){
if(mylist[j] > mylist[j+1]) {
swap(j, j+1)
} } }
}

Pass 1 Pass 2 Pass n-2

7 3 8 6 5 1 3 7 6 5 1 8 3 1 5 6 7 8
j i j i j i

3 7 8 6 5 1 swap 3 7 6 5 1 8 no swap 1 3 5 6 7 8 swap

j i j i
3 7 8 6 5 1 no swap 3 6 7 5 1 8 swap …
j i j i
3 7 6 8 5 1 swap 3 6 5 7 1 8 swap
j i j i

3 7 6 5 8 1 swap 3 6 5 1 7 8 swap
j i
3 7 6 5 1 8 swap
 8

Bubble Sort

Value

Courtesy of wikipedia.org
List Index
 9

Bubble Sort Analysis

• Best Case Complexity:
– When already ______________ but still have to
______________
– O(____)
• Worst Case Complexity:
– When ________________________
– O(____) void bsort(vector<int> mylist)
{
int i ;
for(i=mylist.size()-1; i > 0; i--){
for(j=0; j < i; j++){
if(mylist[j] > mylist[j+1]) {
swap(j, j+1)
} } }
}
 10

Bubble Sort Analysis

• Best Case Complexity:
– When already sorted (no swaps) but still have to do all
compares
– O(n2)
• Worst Case Complexity:
– When sorted in descending order
– O(n2) void bsort(vector<int> mylist)
{
int i ;
for(i=mylist.size()-1; i > 0; i--){
for(j=0; j < i; j++){
if(mylist[j] > mylist[j+1]) {
swap(j, j+1)
} } }
}
 11

Loop Invariants
• Loop invariant is a void bsort(vector<int> mylist)
{
statement about what is int i ;
for(i=mylist.size()-1; i > 0; i--){
true either before an for(j=0; j < i; j++){
if(mylist[j] > mylist[j+1]) {
iteration begins or after } } }
swap(j, j+1)

one ends }

• Consider bubble sort and Pass 1 Pass 2

7 3 8 6 5 1 3 7 6 5 1 8
look at the data after j i j i

each iteration (pass) 3 7 8 6 5 1

j i
swap 3 7 6 5 1 8 no swap
j i
– What can we say about 3 7 8 6 5 1 no swap 3 6 7 5 1 8 swap
j i j i
the patterns of data after
3 7 6 8 5 1 swap 3 6 5 7 1 8 swap
the k-th iteration? j i j i

3 7 6 5 8 1 swap 3 6 5 1 7 8 swap
j i
3 7 6 5 1 8 swap
 12

Loop Invariants
void bsort(vector<int> mylist)
• What is true after the k- {
int i ;
th iteration? for(i=mylist.size()-1; i > 0; i--){
for(j=0; j < i; j++){
• All data at indices n-k and if(mylist[j] > mylist[j+1]) {
swap(j, j+1)
above ___________ }
} } }

– ∀𝑖, 𝑖 ≥ 𝑛 − 𝑘:
Pass 1 Pass 2
• All data at indices below 7 3 8 6 5 1 3 7 6 5 1 8
j i j i
n-k are ______________ 3 7 8 6 5 1 swap 3 7 6 5 1 8 no swap

___________________ j i j i
3 7 8 6 5 1 no swap 3 6 7 5 1 8 swap
– ∀𝑖, 𝑖 < 𝑛 − 𝑘: j i j i
3 7 6 8 5 1 swap 3 6 5 7 1 8 swap
j i j i

3 7 6 5 8 1 swap 3 6 5 1 7 8 swap
j i

3 7 6 5 1 8 swap
 13

Loop Invariants
void bsort(vector<int> mylist)
• What is true after the k- {
int i ;
th iteration? for(i=mylist.size()-1; i > 0; i--){
for(j=0; j < i; j++){
• All data at indices n-k and if(mylist[j] > mylist[j+1]) {
swap(j, j+1)
above are sorted }
} } }

– ∀𝑖, 𝑖 ≥ 𝑛 − 𝑘: 𝑎 𝑖 <
Pass 1 Pass 2
𝑎 𝑖+1 7 3 8 6 5 1 3 7 6 5 1 8

• All data at indices below j i

3 7 8 6 5 1 swap
j i
3 7 6 5 1 8 no swap
n-k are less than the j i j i

value at n-k 3 7 8 6 5 1 no swap

j i
3 6 7 5 1 8
j i
swap

– ∀𝑖, 𝑖 < 𝑛 − 𝑘: 𝑎 𝑖 < 3 7 6 8 5 1 swap 3 6 5 7 1 8 swap

j i j i
𝑎 𝑛−𝑘 3 7 6 5 8 1 swap 3 6 5 1 7 8 swap
j i

3 7 6 5 1 8 swap
 14

Selection Sort
• Selection sort does away with the many swaps and just
records where the min or max value is and performs one swap
at the end
• The list/array can again be thought of in two parts
– Sorted
– Unsorted
• The problem starts with the whole array unsorted and slowly
the sorted portion grows
• We could find the max and put it at the end of the list or we
could find the min and put it at the start of the list
– Just for variation let's choose the min approach
 15

Selection Sort Algorithm

void ssort(vector<int> mylist)
{
for(i=0; i < mylist.size()-1; i++){
int min = i;
for(j=i+1; j < mylist.size; j++){
if(mylist[j] < mylist[min]) {
min = j
} }
swap(mylist[i], mylist[min])
}
Pass 1 min=0 Pass 2 min=1 Pass n-2 min=4
7 3 8 6 5 1 min=1 1 3 8 6 5 7 min=1 1 3 5 6 7 8 min=4
i j i j i j

7 3 8 6 5 1 min=1 1 3 8 6 5 7 min=1
i j i j

7 3 8 6 5 1 min=1 1 3 8 6 5 7 min=1
i j i j

7 3 8 6 5 1 min=1 1 3 8 6 5 7 min=1
i j i j

7 3 8 6 5 1 min=5 1 3 8 6 5 7 swap
i j

1 3 8 6 5 7 swap
 16

Selection Sort

Value

Courtesy of wikipedia.org List Index

 17

Selection Sort Analysis

• Best Case Complexity:
– __________________
– O(___)
• Worst Case Complexity:
– ____________________
– O(___) void ssort(vector<int> mylist)
{
for(i=0; i < mylist.size()-1; i++){
int min = i;
for(j=i+1; j < mylist.size; j++){
if(mylist[j] < mylist[min]) {
min = j
} }
swap(mylist[i], mylist[min])
}
 18

Selection Sort Analysis

• Best Case Complexity:
– Sorted already
– O(n2)
• Worst Case Complexity:
– When sorted in descending order
– O(n2) void ssort(vector<int> mylist)
{
for(i=0; i < mylist.size()-1; i++){
int min = i;
for(j=i+1; j < mylist.size; j++){
if(mylist[j] < mylist[min]) {
min = j
} }
swap(mylist[i], mylist[min])
}
 19

Loop Invariant
• What is true after the void ssort(vector<int> mylist)
{
k-th iteration? for(i=0; i < mylist.size()-1; i++){
int min = i;
for(j=i+1; j < mylist.size; j++){
• All data at indices less if(mylist[j] < mylist[min]) {
min = j
than k are } }
swap(mylist[i], mylist[min])
}
_____________ Pass 1 min=0 Pass 2 min=1

– ∀𝑖, 𝑖 < 𝑘: 7 3 8 6 5 1
i j
min=1 1 3 8 6 5 7
i j
min=1

• All data at indices k 7 3 8 6 5 1

i j
min=1 1 3 8 6 5 7
i j
min=1

and above are 7 3 8 6 5 1

i j
min=1 1 3 8 6 5 7
i j
min=1

____________ 7 3 8 6 5 1
j
min=1 1 3 8 6 5 7
i j
min=1
i
__________________ 7 3 8 6 5 1 min=5 1 3 8 6 5 7 swap
i j
– ∀𝑖, 𝑖 ≥ 𝑘: 1 3 8 6 5 7 swap
 20

Loop Invariant
• What is true after the void ssort(vector<int> mylist)
{
k-th iteration? for(i=0; i < mylist.size()-1; i++){
int min = i;
for(j=i+1; j < mylist.size; j++){
• All data at indices less if(mylist[j] < mylist[min]) {
min = j
than k are sorted } }
swap(mylist[i], mylist[min])
}
– ∀𝑖, 𝑖 < 𝑘: 𝑎 𝑖 < Pass 1 min=0 Pass 2 min=1

𝑎 𝑖+1 7 3 8 6 5 1 min=1 1 3 8 6 5 7 min=1

i j i j

• All data at indices k 7 3 8 6 5 1

i j
min=1 1 3 8 6 5 7
i j
min=1

and above are greater 7 3 8 6 5 1 min=1 1 3 8 6 5 7 min=1

i j i j
than the value at k 7 3 8 6 5 1 min=1 1 3 8 6 5 7 min=1
i j i j
– ∀𝑖, 𝑖 ≥ 𝑘: 𝑎 𝑘 < 𝑎 𝑖 7 3 8 6 5 1 min=5 1 3 8 6 5 7 swap
i j
1 3 8 6 5 7 swap
 21

Insertion Sort Algorithm

• Imagine we pick up one element of the array at a time
and then just insert it into the right position
• Similar to how you sort a hand of cards in a card game
– You pick up the first (it is by nature sorted)
– You pick up the second and insert it at the right position, etc.
Start 1st Card 2nd Card 3rd Card 4th Card 5th Card
? ? ? ? ? 7 ? ? ? ? 7 3 ? ? ? 3 7 8 ? ? 3 7 8 6 ? 3 6 7 8 5

3 7 ? ? ? 3 7 8 ? ? 3 6 7 8 ? 3 5 6 7 8
 22

Insertion Sort Algorithm

void isort(vector<int> mylist)
{ for(int i=1; i < mylist.size(); i++){
int val = mylist[i];
hole = i
while(hole > 0 && val < mylist[hole-1]){
mylist[hole] = mylist[hole-1];
hole--;
}
mylist[hole] = val;
}
Pass 1 Pass 2 Pass 3 Pass 4
7 3 8 6 5 1 val=3 3 7 8 6 5 1 val=8 3 7 8 6 5 1 val=6 3 6 7 8 5 1 val=5
h h h h

7 7 8 6 5 1 3 7 8 6 5 1 3 7 8 8 5 1 3 6 7 8 8 1
h h h

3 7 8 6 5 1 3 7 7 8 5 1 3 6 7 7 8 1
h h h

3 6 7 8 5 1 3 6 6 7 8 1
h h

3 5 6 7 8 1
h
 23

Insertion Sort

Value

Courtesy of wikipedia.org List Index

 24

Insertion Sort Analysis

• Best Case Complexity:
– Sorted already
– _________________
• Worst Case Complexity:
– When sorted in descending order
– _________________
void isort(vector<int> mylist)
{ for(int i=1; i < mylist.size()-1; i++){
int val = mylist[i];
hole = i
while(hole > 0 && val < mylist[hole-1]){
mylist[hole] = mylist[hole-1];
hole--;
}
mylist[hole] = val;
}
 25

Insertion Sort Analysis

• Best Case Complexity:
– Sorted already
– O(n)
• Worst Case Complexity:
– When sorted in descending order
– O(n2)
void isort(vector<int> mylist)
{ for(int i=1; i < mylist.size()-1; i++){
int val = mylist[i];
hole = i
while(hole > 0 && val < mylist[hole-1]){
mylist[hole] = mylist[hole-1];
hole--;
}
mylist[hole] = val;
}
 26

Loop Invariant
• What is true after the void isort(vector<int> mylist)
{ for(int i=1; i < mylist.size()-1; i++){
k-th iteration? int val = mylist[i];
hole = i
while(hole > 0 && val < mylist[hole-1]){
• All data at indices less mylist[hole] = mylist[hole-1];
hole--;
than _____________ }
mylist[hole] = val;
}
– ∀𝑖, Pass 1 Pass 2

• Can we make a claim 7 3 8 6 5 1

h
val=3 3 7 8 6 5 1
h
val=8

about data at k+1 and 7 7 8 6 5 1 3 7 8 6 5 1

h
beyond? 3 7 8 6 5 1
h
 27

Loop Invariant
• What is true after the k- void isort(vector<int> mylist)
{ for(int i=1; i < mylist.size()-1; i++){
th iteration? int val = mylist[i];
hole = i
• All data at indices less while(hole > 0 && val < mylist[hole-1]){
mylist[hole] = mylist[hole-1];
than k+1 are sorted }
hole--;

– ∀𝑖, 𝑖 < 𝑘 + 1: 𝑎 𝑖 < }

mylist[hole] = val;

𝑎 𝑖+1 Pass 1 Pass 2

• Can we make a claim 7 3 8 6 5 1 val=3 3 7 8 6 5 1 val=8
h h
about data at k+1 and 7 7 8 6 5 1 3 7 8 6 5 1

beyond? h
3 7 8 6 5 1
– No, it's not guaranteed to h

be smaller or larger than

what is in the sorted list
 28

MERGESORT
 29

Exercise
• http://bits.usc.edu/websheets/?folder=cpp/cs104&start=mer
ge&auth=Google#
– merge
 30

Merge Two Sorted Lists

• Consider the problem of
merging two sorted lists into 0 1 2 3
a new combined sorted list 3 7 6 8 Inputs Lists

• Can be done in O(n) 0 1 2 3

3 6 7 8 Merged Result

• Can we merge in place or

need an output array?
r1 r2 r1 r2 r1 r2 r1 r2 r1 r2

0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3
3 7 6 8 3 7 6 8 3 7 6 8 3 7 6 8 3 7 6 8

w w w w w

0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3
3 6 7 8 3 6 7 8 3 6 7 8 3 6 7 8 3 6 7 8
 31

Recursive Sort (MergeSort)

Mergesort(0,8)

• Break sorting problem into 0 1 2 3 4 5 6 7

smaller sorting problems and 7 3 8 6 5 10 4 2

Mergesort(0,4) Mergesort(4,8)
merge the results at the end 0 1 2 3 4 5 6 7
7 3 8 6 5 10 4 2
• Mergesort(0..n) Mergesort(0,2)
0 1 2 3 4 5 6 7
Mergesort(2,4)
– If list is size 1, return Mergesort(4,6)
Mergesort(6,8)
7 3 8 6 5 10 4 2

– Else 0 1 2 3 4 5 6 7
7 3 8 6 5 10 4 2
• Mergesort(0..n/2 - 1)
• Mergesort(n/2 .. n) 0 1 2 3 4 5 6 7
3 7 6 8 5 10 2 4
• Combine each sorted list of n/2
elements into a sorted n-element 0 1 2 3 4 5 6 7
list 3 6 7 8 2 4 5 10

0 1 2 3 4 5 6 7
2 3 4 5 6 7 8 10
 32

Recursive Sort (MergeSort)

Mergesort(0,8)

• Run-time analysis 0 1 2 3 4 5 6 7

– # of recursion levels = 7 3 8 6 5 10 4 2
Mergesort(0,4) Mergesort(4,8)
• Log2(n) 0 1 2 3 4 5 6 7
– Total operations to merge each level = 7 3 8 6 5 10 4 2

• n operations total to merge Mergesort(0,2)

0 1 2 3 4 5 6 7
Mergesort(2,4)
two lists over all recursive Mergesort(4,6) 7 3 8 6 5 10 4 2
calls at a particular level Mergesort(6,8)

0 1 2 3 4 5 6 7
• Mergesort = O(n * log2(n) ) 7 3 8 6 5 10 4 2

– Usually has high constant 0 1 2 3 4 5 6 7

factors due to extra array 3 7 6 8 5 10 2 4

needed for merge 0 1 2 3 4 5 6 7

3 6 7 8 2 4 5 10

0 1 2 3 4 5 6 7
2 3 4 5 6 7 8 10
 33

MergeSort Run Time

• Let's prove this more formally:
• T(1) = Θ(1)
• T(n) =
 34

MergeSort Run Time

• Let's prove this more formally:
• T(1) = Θ(1)
• T(n) = 2*T(n/2) + Θ(n)
k=1 T(n) = 2*T(n/2) + Θ(n) T(n/2) = 2*T(n/4) + Θ(n/2)

k=2 = 2*2*T(n/4) + 2*Θ(n)

k=3 = 8*T(n/8) + 3*Θ(n)
= 2k*T(n/2k) + k*Θ(n)

Stop @ T(1) = 2k*T(n/2k) + k*Θ(n) = 2log2(n)*Θ(1) + log2*Θ(n) = n+log2*Θ(n)

[i.e. n = 2k]
k=log2n
= Θ(n*log2n)
 35

Merge Sort

Value

Courtesy of wikipedia.org
List Index
 36

Recursive Sort (MergeSort)

void mergesort(vector<int>& mylist)
{
vector<int> other(mylist); // copy of array
// use other as the source array, mylist as the output array
msort(other, myarray, 0, mylist.size() );

}
void msort(vector<int>& mylist,
vector<int>& output,
int start, int end)
{
// base case
if(start >= end) return;
// recursive calls
int mid = (start+end)/2;
msort(mylist, output, start, mid);
msort(mylist, output, mid, end);
// merge
merge(mylist, output, start, mid, mid, end);

}
void merge(vector<int>& mylist, vector<int>& output
int s1, int e1, int s2, int e2)
{
...
}
 37

Divide & Conquer Strategy

• Mergesort is a good example of a strategy known as
"divide and conquer"
• 3 Steps:
– Divide
• Split problem into smaller versions (usually partition the data
somehow)
– Recurse
• Solve each of the smaller problems
– Combine
• Put solutions of smaller problems together to form larger solution
• Another example of Divide and Conquer?
– Binary Search
 38

QUICKSORT
 39

Partition & QuickSort

• Partition algorithm (arbitrarily) picks one number as the 'pivot'
and puts it into the 'correct' location
left right left right

unsorted numbers p < pivot p > pivot

int partition(vector<int> mylist, int start, int end, int p)
{ int pivot = mylist[p];
swap(mylist[p], mylist[end]); // move pivot out of the Partition(mylist,0,5,5)
//way for now
int left = start; int right = end-1; 3 6 8 1 5 7
while(left < right){ l r p
while(mylist[left] <= pivot && left < right) 3 6 8 1 5 7
left++; l r p
while(mylist[right] >= pivot && left < right)
right--; 3 6 5 1 8 7
if(left < right) l r p
swap(mylist[left], mylist[right]); 3 6 5 1 8 7
} l,r p
if(mylist[right] > mylist[end]) { // put pivot in
swap(mylist[right], mylist[end]); // correct place 3 6 5 1 7 8
return right; l,r p
} Note: end is
else { return end; } inclusive in this
} example
 40

QuickSort
• Use the partition algorithm as the basis of a sort algorithm
• Partition on some number and the recursively call on both
sides
< pivot p > pivot

// range is [start,end] where end is inclusive

void qsort(vector<int>& mylist, int start, int end)
{ 3 6 8 1 5 7
// base case – list has 1 or less items l r p
if(start >= end) return;
3 6 8 1 5 7
l r p
// pick a random pivot location [start..end]
int p = start + rand() % (end+1); 3 6 5 1 8 7
// partition l r p
int loc = partition(mylist,start,end,p)
3 6 5 1 8 7
// recurse on both sides
l,r p
qsort(mylist,start,loc-1);
qsort(mylist,loc+1,end); 3 6 5 1 7 8
} l,r p
 41

Quick Sort

Value

Courtesy of wikipedia.org
List Index
 42

QuickSort Analysis
• Worst Case Complexity: 3 6 8 1 5 7

– When pivot chosen ends up being 3 6 1 5 7 8

__________________
3 6 8 1 5 7
– Runtime: 3 1 5 6 8 7

• Best Case Complexity:

– Pivot point chosen ends up being the
________________
– Runtime:
 43

QuickSort Analysis
• Worst Case Complexity: 3 6 8 1 5 7
– When pivot chosen ends up being min or max item 3 6 1 5 7 8

– Runtime:
• T(n) = Θ(n) + T(n-1) 3 6 8 1 5 7
3 1 5 6 8 7

• Best Case Complexity:

– Pivot point chosen ends up being the median item
– Runtime:
• Similar to MergeSort
• T(n) = 2T(n/2) + Θ(n)
 44

QuickSort Analysis
• Average Case Complexity: O(n*log(n)) 3 6 8 1 5 7

– ____________ choose a pivot

 45

QuickSort Analysis
• Worst Case Complexity:
– When pivot chosen ends up being max or min of each list
– O(n2)
• Best Case Complexity:
– Pivot point chosen ends up being the middle item
– O(n*lg(n))
• Average Case Complexity: O(n*log(n))
– Randomly choose a pivot
• Pivot and quicksort can be slower on small lists than
something like insertion sort
– Many quicksort algorithms use pivot and quicksort recursively until
lists reach a certain size and then use insertion sort on the small
pieces
 46

Comparison Sorts
• Big O of comparison sorts
– It is mathematically provable that comparison-
based sorts can never perform better than
O(n*log(n))

• So can we ever have a sorting algorithm that

performs better than O(n*log(n))?

• Yes, but only if we can make some meaningful

assumptions about the input
 47

OTHER SORTS
 48

Sorting in Linear Time

• Radix Sort
– Sort numbers one digit at a time starting with the least
significant digit to the most.

• Bucket Sort
– Assume the input is generated by a random process that
distributes elements uniformly over the interval [0, 1)

• Counting Sort
– Assume the input consists of an array of size N with
integers in a small range from 0 to k.
 49

Applications of Sorting
• Find the set_intersection of the 2 A 7 3 8 6 5 1
0 1 2 3 4 5

lists to the right

B 9 3 4 2 7 8 11
– How long does it take? 0 1 2 3 4 5 6

Unsorted

• Try again now that the lists are

A 1 3 5 6 7 8
sorted 0 1 2 3 4 5

– How long does it take? B 2 3 4 7 8 9 11

0 1 2 3 4 5 6

Sorted
 50

Other Resources
• http://www.youtube.com/watch?v=vxENKlcs2Tw

 http://flowingdata.com/2010/09/01/what-different-sorting-algorithms-
sound-like/

 http://www.math.ucla.edu/~rcompton/musical_sorting_algorithms/music
al_sorting_algorithms.html

• http://sorting.at/

• Awesome musical accompaniment:

https://www.youtube.com/watch?v=ejpFmtYM8Cw