In-Place SortingIn-Place Sorting

Viliam GeffertViliam GeffertP.J.P.J.ŠŠafafáárik Universityrik University, , KKošice, Slovakiaošice, Slovakia

JJoozef Gajdozef Gajdošš College of International Business ISM College of International Business ISM

SlovakiaSlovakiaPrešovPrešov, Slovakia, Slovakia

The Problem

n elements

n elements

n elements

1.n.log n + Δ(n) comparisons

O(n) element moves

O(1) index variables, of log n bits each

1 hole

Comparisons MovesStorage

log n! ≈ n.log n–1.44n 3/2.n

O(1) lower bound

Comparisons MovesStorage

log n! ≈ n.log n–1.44n 3/2.n

O(1) lower bound

n.log n n.log n nmergesort

[Kn1973]

Comparisons MovesStorage

log n! ≈ n.log n–1.44n 3/2.n

O(1) lower bound

n.log n +O(n.loglog n) O(n.log n/loglog n)O(1)mergesortADV

[KaPa1999]

Comparisons MovesStorage

log n! ≈ n.log n–1.44n 3/2.n

O(1) lower bound

n.log n +O(n.loglog n) O(n.log n/loglog n)O(1)mergesortADV

[KaPa1999]

Θ(n2) O(n)O(1) selectsort

Comparisons MovesStorage

log n! ≈ n.log n–1.44n 3/2.n

O(1) lower bound

n.log n +O(n.loglog n) O(n.log n/loglog n)O(1)mergesortADV

[KaPa1999]

Θ(n1+) O(n)O(1) n1/k-heapsort

[MuRa1992]

Comparisons MovesStorage

log n! ≈ n.log n–1.44n 3/2.n

O(1) lower bound

n.log n +O(n.loglog n) O(n.log n/loglog n)O(1)mergesortADV

[KaPa1999]

Θ(n1+) O(n)O(1) n1/k-heapsort

[MuRa1992]

n.log n O(n)Θ(n) tablesort

Comparisons MovesStorage

log n! ≈ n.log n–1.44n 3/2.n

O(1) lower bound

n.log n +O(n.loglog n) O(n.log n/loglog n)O(1)mergesortADV

[KaPa1999]

Θ(n1+) O(n)O(1) n1/k-heapsort

[MuRa1992]

Θ(n.log n) O(n)Θ(n) samplesortADV

[MuRa1992]

Comparisons MovesStorage

log n! ≈ n.log n–1.44n 3/2.n

O(1) lower bound

n.log n +O(n.loglog n) O(n.log n/loglog n)O(1)mergesortADV

[KaPa1999]

Θ(n1+) O(n)O(1) n1/k-heapsort

[MuRa1992]

Θ(n.log n) O(n)Θ(n) samplesortADV

[MuRa1992]

1991-2005: conjectured that an algorithm matching

the lower bounds for all criteria does not exist

Comparisons MovesStorage

log n! ≈ n.log n–1.44n 3/2.n

O(1) lower bound

n.log n +O(n.loglog n) O(n.log n/loglog n)O(1)mergesortADV

[KaPa1999]

Θ(n1+) O(n)O(1) n1/k-heapsort

[MuRa1992]

Θ(n.log n) O(n)Θ(n) samplesortADV

[MuRa1992]

log n! +Θ(n.log n) (13+ε).nO(1) [GeFr2005]

Comparisons MovesStorage

log n! ≈ n.log n–1.44n 3/2.n

O(1) lower bound

n.log n +O(n.loglog n) O(n.log n/loglog n)O(1)mergesortADV

[KaPa1999]

Θ(n1+) O(n)O(1) n1/k-heapsort

[MuRa1992]

Θ(n.log n) O(n)Θ(n) samplesortADV

[MuRa1992]

log n! +Θ(n.log n) (13+ε).nO(1) [GeFr2005]

log n! +Θ(n.loglog n) (26+ε).nO(1) our result

1. Initial Preparation

2n/log2 n largest elements

2n/log2 n largest elements

Modified heapsort

-- branching degree log n instead of 2

2n/log2 n largest elements

Modified heapsort

-- branching degree log n instead of 2-- halts after extracting 2n/log2 n largest elements

Com: O(n)Mov : O(n/log n)

2n/log2 n largest elements

Com: O(n)Mov : O(n/log n)

2n/log2 n smallest elements 2n/log2 n largest elements

Symmetrically, by modified heapsort

Com: O(n)Mov : O(n/log n)

2n/log2 n smallest elements 2n/log2 n largest elements

X Y

2n/log2 n smallest elements 2n/log2 n largest elements

Com: 1Mov: --Com: 1Mov: --

If X=Y, we are done, the array is sorted

2n/log2 n smallest elements 2n/log2 n largest elements

X Y

If X<Y, continue

2n/log2 n smallest elements 2n/log2 n largest elements

X Y

Pointer memory

2n/log2 n smallest elements 2n/log2 n largest elements

0

0

0

0

0

0

Pointer memory

2n/log2 n smallest elements 2n/log2 n largest elements

1

0

0

0

0

0

Pointer memory

2n/log2 n smallest elements 2n/log2 n largest elements

1

0

1

0

0

0

Pointer memory

2n/log2 n smallest elements 2n/log2 n largest elements

1

1

1

1

1

1

2n/log2 n smallest elements 2n/log2 n largest elements

2n/log2 n element pairs ≡

2n/log3 n integer variables, of log n bits each

2. Partition-Based Sorting

bL R

ni elementsan element of rank ¼.ni

L R

ni elements

b

an element of rank ¼.ni

L R

ni elements

b

Com1: O( ni )Mov1 : . ni

an element of rank ¼.ni

L R

ni elements

b

an element of rank ¼.ni

L R

ni elements

b

A<

to be sortedB≥

buffer memory

an element of rank ¼.ni

L Rb

A<

to be sortedB≥

buffer memory

ni,< ≤ ¼.ni

ni,≥ ≥ 3.ni,<

an element of rank ¼.ni

L R

an element of rank ¼.ni

b

A<

to be sortedB≥

buffer memory

ni,< ≤ ¼.ni

ni,≥ ≥ 3.ni,<

Com1: O( ni )Mov1 : 2.ni,<

L R

an element of rank ¼.ni

b

A<

to be sortedB≥

buffer memory

ni,< ≤ ¼.ni

ni,≥ ≥ 3.ni,<

Using pointer memory L+R and buffer memory B≥ ,sort A<

L R

an element of rank ¼.ni

b

A<

to be sortedB≥

buffer memory

ni,< ≤ ¼.ni

ni,≥ ≥ 3.ni,<

Using pointer memory L+R and buffer memory B≥ ,sort A<

L R

an element of rank ¼.ni

b

A< B≥

ni,< ≤ ¼.ni

ni,≥ ≥ 3.ni,<

Using pointer memory L+R and buffer memory B≥ ,sort A<

Pointer memory ≥ 2*2m/log2 mBuffer memory ≥ 3m

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

L R

an element of rank ¼.ni

b

ni,< ≤ ¼.ni

ni,≥ ≥ 3.ni,<

B≥A<

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

L R

an element of rank ¼.ni

b

ni,< ≤ ¼.ni

ni,≥ ≥ 3.ni,<

B≥A<

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

L R

an element of rank ¼.ni

b

ni,< ≤ ¼.ni

ni,≥ ≥ 3.ni,<

B≥A<

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

L R

an element of rank ¼.ni

b

ni,< ≤ ¼.ni

ni,≥ ≥ 3.ni,<

B≥A<

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

L R

an element of rank ¼.ni

b

ni,< ≤ ¼.ni

ni,> ≤ ¾.ni

B≥A<

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

L R

an element of rank ¼.ni

b

B≥A<Com1:ni

Mov1:

3.ni,=

ni,> ≤ ¾.ni

ni,<≤¼ ni,=

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

sortedL R

an element of rank ¼.ni

ni,> ≤ ¾.ni

ni,<≤¼ ni,=

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

sortedL R

an element of rank ¼.ni

ni+1 ≤ ¾.ni

ni,<≤¼ ni,=

“new” ni

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

sortedL R

an element of rank ¼.ni+1

ni+1 ≤ ¾.ni

ni,<≤¼ ni,=

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

sortedL R

an element of rank ¼.ni+1

ni+1 ≤ ¾.ni

ni,<≤¼ ni,=

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

sortedL R

an element of rank ¼.ni+1

ni+1 ≤ ¾.ni

ni,<≤¼ ni,=

A< B≥

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

sortedL R

an element of rank ¼.ni+1

ni+1 ≤ ¾.ni

ni,<≤¼ ni,=

A< B≥

sort

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

sortedL R

an element of rank ¼.ni+1

ni+1 ≤ ¾.ni

ni,<≤¼ ni,=

A< B≥

sort

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

sortedL R

an element of rank ¼.ni+1

ni+1 ≤ ¾.ni

ni,<≤¼ ni,=

A< B≥

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

sortedL R

an element of rank ¼.ni+1

ni+1 ≤ ¾.ni

ni,<≤¼ ni,=

A< B≥

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

sortedL R

an element of rank ¼.ni+1

ni+1 ≤ ¾.ni

ni,<≤¼ ni,=

A< B≥

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

sortedL R

an element of rank ¼.ni+1

ni+1 ≤ ¾.ni

ni,<≤¼ ni,= ni+1,< ni+1,=

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

sortedL R

an element of rank ¼.ni+1

ni+2 ≤ ¾.ni+1

ni,<≤¼ ni,= ni+1,< ni+1,=

“new” ni

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

sortedL R

an element of rank ¼.ni+1

ni+2 ≤ ¾.ni+1

ni,<≤¼ ni,= ni+1,< ni+1,=

… … …

iterate

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

L R… … …

iterate

ni+1 ≤ ¾.ni

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

L R

ni+1 ≤ ¾.ni

restore order

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

L R

ni+1 ≤ ¾.ni

restore order

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

L RCom: O(n/log2 n)Mov: O(n/log2 n)

ni+1 ≤ ¾.ni

restore order

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

Total comparisons: Total moves:

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

Total comparisons: Total moves:

Creating/clearing pointer memory: O(n) O(n/log n)

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

Total comparisons: Total moves:

Creating/clearing pointer memory: O(n) O(n/log n)Processing one block, of length ni: O(ni) + .ni +

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

Total comparisons: Total moves:

Creating/clearing pointer memory: O(n) O(n/log n)Processing one block, of length ni: O(ni) + .ni + ni,<

.log n + ni,<.O(loglog n) (26+).ni,< +

26.ni,=

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

Total comparisons: Total moves:

Creating/clearing pointer memory: O(n) O(n/log n)Processing one block, of length ni: O(ni) + .ni + ni,<

.log n + ni,<.O(loglog n) (26+).ni,< +

26.ni,=

Block lengths: n1,< + n1,= + n2,< + n2,= + … ≤ O(n) ⇐ ni+1 ≤ ¾.ni

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

Total comparisons: Total moves:

Creating/clearing pointer memory: O(n) O(n/log n)Processing one block, of length ni: O(ni) + .ni + ni,<

.log n + ni,<.O(loglog n) (26+).ni,< +

26.ni,=

Block lengths: n1,< + n1,= + n2,< + n2,= + … ≤ O(n) ⇐ ni+1 ≤ ¾.ni n1,< + n1,= + n2,< + n2,= + … ≤ n ⇐ disjoint Com?: m.log

m+ O(m.loglog

m)Mov?: (24+).m

Total comparisons: Total moves:

Creating/clearing pointer memory: O(n) O(n/log n)Processing one block, of length ni: O(ni) + .ni + ni,<

.log n + ni,<.O(loglog n) (26+).ni,< +

26.ni,=

Block lengths: n1,< + n1,= + n2,< + n2,= + … ≤ O(n) n1,< + n1,= + n2,< + n2,= + … ≤ n

Total comparisons: n.log n + n.O(loglog n) + O(n)

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

Total comparisons: Total moves:

Creating/clearing pointer memory: O(n) O(n/log n)Processing one block, of length ni: O(ni) + .ni + ni,<

.log n + ni,<.O(loglog n) (26+).ni,< +

26.ni,=

Block lengths: n1,< + n1,= + n2,< + n2,= + … ≤ O(n) n1,< + n1,= + n2,< + n2,= + … ≤ n

Total comparisons: n.log n + n.O(loglog n)

Total moves: (26+).n

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

Total comparisons: Total moves:

Creating/clearing pointer memory: O(n) O(n/log n)Processing one block, of length ni: O(ni) + .ni + ni,<

.log n + ni,<.O(loglog n) (26+).ni,< +

26.ni,=

Block lengths: n1,< + n1,= + n2,< + n2,= + … ≤ O(n) n1,< + n1,= + n2,< + n2,= + … ≤ nProvided that:

Total comparisons: n.log n + n.O(loglog n)

Total moves: (26+).n

Com?: m.log m

+ O(m.loglog m)Mov?: (24+).m

3.Sorting A with AuxiliaryBuffer and Pointer Memories

Basic Idea

A

B

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

B

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

evenly distributed frame of sizem/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

a2 ≤ a1

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

a1 … a2

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

a2 … a3

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

a3 … a4

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

af ≤ a4

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

frame growsdynamically

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

frame growsdynamically

median

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

frame growsdynamically

≤ ≥

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

frame growsdynamically

≤ ≥

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

≤ ≥

m/log4 m … 2m/log4 m

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

segments sorted by[Geffert & Franceschini

2005]

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

segments sorted by[Geffert & Franceschini

2005]

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

segments sorted by[Geffert & Franceschini

2005]

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

segments sorted by[Geffert & Franceschini

2005]

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

segments sorted by[Geffert & Franceschini

2005]

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

segments sorted by[Geffert & Franceschini

2005]

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

segments of size½.log4 m … log4 m

m/log4 m … 2m/log4 m

A

a1

a2

a3

af

Ϭ0 Ϭ1 Ϭ2 Ϭ3 Ϭf

B

A

B

Data Structure

to be sortedA

melements

to be sortedA

melements

:

pointer memory

2* 2m/log3 m* log m

to be sortedA

melements

:

pointer memory

2* 2m/log3 m* log m

buffer memory B

size 3m

m

:

pointer memory

2* 2m/log3 m* log m

3mto be sorted

A

:

pointer memory

2* 2m/log3 m* log m

3m

m

to be sortedA

:

pointer memory

2* 2m/log3 m* log m

3m

m

to be sortedA

:

pointer memory

2* 2m/log3 m* log m

3m

m

to be sortedA

:

pointer memory

2* 2m/log3 m* log m

3m

m

to be sortedA

:

pointer memory

2* 2m/log3 m* log m

3m

b -- smallest buffer element

hole

m

to be sortedA

:

pointer memory

2* 2m/log3 m* log m

3m

b -- smallest buffer element

m

to be sortedA

:

pointer memory

2* 2m/log3 m* log m

3m

b -- smallest buffer element

m

to be sortedA

:

pointer memory

2* 2m/log3 m* log m

3m

b -- smallest buffer element

m

to be sortedA

:

pointer memory

2* 2m/log3 m* log m

3m

b -- smallest buffer element

m

to be sortedA

:

pointer memory

2* 2m/log3 m* log m

3m

b -- smallest buffer element

m

to be sortedA

:

pointer memory

2* 2m/log3 m* log m

3m

b -- smallest buffer element

m

to be sortedA

:

pointer memory

2* 2m/log3 m* log m

3m

b -- smallest buffer element

Comparisons Comparisons

Moves 2 * Moves

3m free locations + 1 free location

+ 3m buffer elements

m

to be sortedA

b

frameR

2m/log3m

≤ m/2

:

pointer memory

2* 2m/log3 m* log m

m

to be sortedA

b

frameR

2m/log3m

≤ m/2

:

pointer memory

2* 2m/log3 m* log m

m

to be sortedA

b

to store only2m/log4 m elements

frameR

2m/log3m

≤ m/2

cacheC

2m/log2m

≤ m/2

:

pointer memory

2* 2m/log3 m* log m

m

to be sortedA

b

frameR

2m/log3m

≤ m/2

cacheC

2m/log2m

≤ m/2

segmentsS

≤ 2m/log4m * log4m

≤ 2m

:

pointer memory

2* 2m/log3 m* log m

m

to be sortedA

b

to be sortedA

frameR

cacheC

segmentsS

R:

:

2m/log4 m * log m

b

to be sortedA

frameR

cacheC

segmentsS

R:

:

2m/log4 m * log m

b

sorted frame

to be sortedA

frameR

cacheC

segmentsS

R:

:

sorted frame

buffer elementsnot sorted,larger than active elements

2m/log4 m * log m

b

to be sortedA

frameR

cacheC

segmentsS

R:

:

a

a

2m/log4 m * log m

b

a

to be sortedA

frameR

cacheC

segmentsS

R:

:

a

binary search with a:

log(2m/log4 m) ≤ log m

a

2m/log4 m * log m

b

a

to be sortedA

frameR

cacheC

segmentsS

R:

:

a

2m/log4 m * log m

b

a

to be sortedA

frameR

cacheC

segmentsS

R:

:

a

binary search with a:loglog m

a

2m/log4 m * log m

b

a

to be sortedA

frameR

cacheC

segmentsS

R:

:

C:

a

2m/log4 m * log m

2m/log3 m * log m

b

ak … ak+1

a

to be sortedA

frameR

cacheC

segmentsS

R:

:

C:k.log m

akak+1

a

2m/log3 m * log m

b

2m/log4 m * log m

a

to be sortedA

frameR

cacheC

segmentsS

R:

:

C:

akak+1

a

not sortedbuffer elements not sorted,larger than active elements

a2m/log3 m * log m

b

a

to be sortedA

frameR

cacheC

segmentsS

R:

:

C:

akak+1

a

b

a2m/log3 m * log m

b

a

to be sortedA

frameR

cacheC

segmentsS

R:

:

C:

akak+1

a

a

bbinary search with

b:loglog m

2m/log3 m * log m

b

bto be sortedA

frameR

cacheC

segmentsS

R:

:

2m/log3 m * log mC:

akak+1

2m/log4 m * log m

S: … …

≤ 2m/log4 m * log4 m

k.log m

bto be sortedA

frameR

cacheC

segmentsS

R:

:

C:

akak+1

S: … …

k.log m

k.log m k.log m

≤ 2m/log4 m * log4 m

2m/log4 m * log m

bto be sortedA

frameR

cacheC

segmentsS

R:

:

C:

akak+1

S: … …

k.log m

k.log m k.log m

≤ 2m/log4 m * log4 m

bto be sortedA

frameR

cacheC

segmentsS

R:

:

C:

akak+1

S: … …

k.log m

k.log m

decoding segment address:

log m comparisons

≤ 2m/log4 m * log4 m

bto be sortedA

frameR

cacheC

segmentsS

R:

:

C:

akak+1

S: … …ak … ak+1

≤ 2m/log4 m * log4 m

≤ 2m/log4 m * log4 m

bto be sortedA

frameR

cacheC

segmentsS

R:

:

C:

akak+1

S: … …

not sortednot sorted

bto be sortedA

frameR

cacheC

segmentsS

R:

:

C:

akak+1

S: … …

b

≤ 2m/log4 m * log4 m

bto be sortedA

frameR

cacheC

segmentsS

R:

:

C:

akak+1

S: … …

b

binary search with b:

log(log4 m) ≤ 4.loglog m

≤ 2m/log4 m * log4 m

bto be sortedA

frameR

cacheC

segmentsS

R:

:

C:

akak+1

S: … …

≤ 2m/log4 m * log4 m

2m/log3 m * log m

2m/log4 m * log m

bto be sortedA

frameR

cacheC

segmentsS

R:

:

C:

akak+1

S: … …

≤ 2m/log4 m * log4 m

2m/log3 m * log m

2m/log4 m * log m

Com: m.log m +O(m.loglog m)Mov : O(m)

Final Remarks

Our result

Comparisons: log n! +Θ(n.loglog n)

Moves: (26+ε).n

Storage: O(1)

Our result[GeFr2005]

Comparisons: log n! +Θ(n.loglog n) log n! +Θ(n.log n)

Moves: (26+ε).n(13+ε).n

Storage: O(1) O(1)

Our result[GeFr2005]

Comparisons: log n! +Θ(n.loglog n) log n! +Θ(n.log n)

Moves: (26+ε).n(13+ε).n

Storage: O(1) O(1)

cache memory

short segments

sorted by [GeFr2005]

Our result

Comparisons: log n! +Θ(n.loglog n)

Moves: (26+ε).n

Storage: O(1)

- mainly of theoretical interest, too complex to implement

Our result

Comparisons: log n! +Θ(n.loglog n)

Moves: (26+ε).n

Storage: O(1)

- mainly of theoretical interest, too complex to implement- however, several new techniques and data structures can be utilized in other applications

Our result

Comparisons: log n! +Θ(n.loglog n)

Moves: (26+ε).n

Storage: O(1)

- mainly of theoretical interest, too complex to implement- however, several new techniques and data structures can be utilized in other applications

? probably, (26+ε).n moves can be substantially improved

[proceedings: (34+ε).n moves]

Our result

Comparisons: log n! +Θ(n.loglog n)

Moves: (26+ε).n

Storage: O(1)

- mainly of theoretical interest, too complex to implement- however, several new techniques and data structures can be utilized in other applications

? probably, (26+ε).n moves can be substantially improved

[proceedings: (34+ε).n moves]? log n! +O(n) comparisons

Our result

Comparisons: log n! +Θ(n.loglog n)

Moves: (26+ε).n

Storage: O(1)

- mainly of theoretical interest, too complex to implement- however, several new techniques and data structures can be utilized in other applications

? probably, (26+ε).n moves can be substantially improved

[proceedings: (34+ε).n moves]? log n! +O(n) comparisons? stable version (equal buffer elements are mixed up)

Thank You for Your Attention