Scribd
Upload
25 views43 pages

Merge Sort

The document describes the merge sort algorithm. It defines functions for mergeSort and merge that take parameters L, m, and R to recursively sort sublists and then merge them back together.

Uploaded by

damian chamel
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
25 views43 pages

Merge Sort

The document describes the merge sort algorithm. It defines functions for mergeSort and merge that take parameters L, m, and R to recursively sort sublists and then merge them back together.

Uploaded by

damian chamel
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 43

L R

def mergeSort(L, R):


if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
LR
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
LR
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:


if array[a] <= array[b]:
tmp[c++] = array[
else:
0 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:


if array[a] <= array[b]:
tmp[c++] = array[
else:
0 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:


if array[a] <= array[b]:
tmp[c++] = array[
else:
0 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:


if array[a] <= array[b]:
tmp[c++] = array[
else:
0 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:


if array[a] <= array[b]:
tmp[c++] = array[
else:
10 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:


if array[a] <= array[b]:
tmp[c++] = array[
else:
10 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:


if array[a] <= array[b]:
tmp[c++] = array[
else:
10 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:


if array[a] <= array[b]:
tmp[c++] = array[
else:
10 0 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:


if array[a] <= array[b]:
tmp[c++] = array[
else:
10 40 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:


if array[a] <= array[b]:
tmp[c++] = array[
else:
10 40 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:


if array[a] <= array[b]:
tmp[c++] = array[
else:
10 40 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
40 10 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
a b
tmp = [0] * (R – L + 1)

while a <= m and b <= R:


if array[a] <= array[b]:
tmp[c++] = array[
else:
10 40 0 0 0 tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]
c
while b <= R:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L m R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]
L R
def mergeSort(L, R):
if L < R:
m = (L + R) // 2
mergeSort(L, m)
10 40 50 20 30 mergeSort(m + 1, R)
merge(L, m, R)

def merge(L, m, R):


a, b, c = L, m + 1, 0
tmp = [0] * (R – L + 1)

while a <= m and b <= r:


if array[a] <= array[b]:
tmp[c++] = array[
else:
tmp[c++] = array[

while a <= m:
tmp[c++] = array[a++]

while b <= r:
tmp[c++] = array[b++]

You might also like