Sistemas y Algoritmos 2 Segundo Semestre, 2015

Clase 3: Ordenamiento III

Instructor: Diego Villamizar

3.1. Ordenamiento

Proposición 3.1 Sea x ∈ (A, ≤A)∗ una sucesión de elementos de un conjunto linealmente
ordenado.
ˆ
St(x)i = 1 + |Ai |, Ai = {k ∈ [|x|] : xk <A xi ∨ (xk = xi ∧ i < j)}.

Prueba: Defínase πi = 1 + |Ai |. Para poder demostrar que, efectivamente, π = St(x)

ˆ
hay que ver:

π es permutación

ˆ 1 ≤ πi ≤ |x|
Como ∅ ⊂ Ai ⊆ [|x|] \ {i}, 1 + |∅| = 1 ≤ 1 + |Ai | ≤ 1 + |x| − 1 = |x|.
ˆ πi 6= πj si i 6= j
Veamos que si xi <A xj ∨ (xi = xj ∧ i < j) entonces Ai ⊂ Aj , lo que implica(Por
qué?) πi 6= πj .

◦ Supongamos xi <A xj
Como k ∈ Ai , xk ≤A xi <A xj , luego k ∈ Aj .
◦ Supongamos (xi = xj ∧ i < j)
Como k ∈ Ai , xk ≤A xi =A xj , luego si xk <A xi se tiene k ∈ Aj y si xk = xi
se tiene que k < i < j , luego k ∈ Aj .

π ∈ St(x)
Se ha probado arriba.(Por qué?)

π es minimal.
Completar!

Note que la función de estandarización lo que hace es encontrar una permutación que respete
el orden de el arreglo (o sucesión) x y recuerde que ϕ contiene permutaciones que ordenan
ese arreglo, así que es intuitivo pensar que una es inversa de la otra en algún sentido.

1
2 Clase 3: Ordenamiento III

Proposición 3.2 Sea x ∈ (A, ≤A)∗ una sucesión de elementos de un conjunto linealmente
ordenado.
ˆ
St(x) = ϕ̂(x)−1 .

Prueba: Sea i ∈ [|x|] y consideremos (St(x)

ˆ ˆ
◦ ϕ̂(x))(i) = St(x) ϕ̂(x)i . Por la proposición
pasada, sabemos que, St(x)ϕ̂(x)i = 1+|Aϕ̂(x)i | = 1+|{k ∈ [|x|] : xk <A xi ∨(xk = xi ∧i < j)}|.
ˆ
Como ϕ̂(x) ∈ ϕ(x), se sabe que xϕ̂(x)1 ≤A xϕ̂(x)2 ≤A · · · ≤A xϕ̂(x)i ≤A · · · ≤A xϕ̂(x)|x| . Sea
a ∈ [|x|] tal que xϕ̂(x)a 6= xϕ̂(x)i pero xϕ̂(x)a+1 = xϕ̂(x)i , luego a = |Bϕ̂(x)i = {k ∈ [|x|] :
xk < xϕ̂(x)i }|. Es claro que Bi ⊆ Ai por la denición dada en la proposición pasada y
Aϕ̂(x)i \ Bϕ̂(x)i = {k ∈ [|x|] : xk = xϕ̂(x)i ∧ k < ϕ̂(x)i }.
Por tricotomía se tienen los siguientes casos al comparar |Aϕ̂(x)i \ Bϕ̂(x)i | con i − 1 − a:
|Aϕ̂(x)i \ Bϕ̂(x)i | > i − 1 − a Completar!

|Aϕ̂(x)i \ Bϕ̂(x)i | < i − 1 − a Completar!

como ningún caso anterior se tiene, la igualdad debe cumplirse y entonces St(x) ˆ ϕ̂(x)i =
1 + |Aϕ̂(x)i | = 1 + |Bϕ̂(x)i ∪ (Aϕ̂(x)i \ Bϕ̂(x)i )| = 1 + |Aϕ̂(x)i | + |Bϕ̂(x)i | = 1 + a + (i − 1 − a) = i.

Ejemplo 3.3 Sea A = N con el orden usual. Sea, además, x = (5, 3, 8, 15, 2, 7, 3) ∈ (N, ≤)∗
ˆ
ϕ̂(x) = {5271634}, St(x) ˆ
= {4267153}, St(x) ◦ ϕ̂(x) = 1234567.

Proposición 3.4 Sea x ∈ (A = {a1, a2, . . . , an−1, an}, ≤A)∗ una sucesión de elementos de
un conjunto linealmente ordenado siendo ai <A aj si i < j .
n
Y
|ϕ(x)| = |x|ai !
i=1

Prueba: Por el principio de la multiplicación es claro que

n
Y n
Y
| S|x|ai | = |x|ai !,
i=1 i=1

luego, consideremos una función f : ϕ(x) −→ ni=1 S|x|ai que a una permutación σ ∈
Q
ϕ(x) la envíe en una n-tupla f (σ) = (σ 1 , σ 2 , . . . , σ n−1 , σ n ) con σ i ∈ S|x|ai donde σ i =
St((σj , σj+1 , . . . , σj+|x|ai −2 , σj+|x|ai −1 )), con j tal que xσj = ai y (xσj−1 6= ai ó j = 1).

Debemos ver que f es biyectiva, para usar el principio de la biyección y obtener el

resultado.
f es inyectiva. Completar!
 Ordenamiento 3

f es sobre. Completar!

Como ordenar es permutar los elementos de una sucesión para volverla creciente en su orden
lineal, entonces para poder ordenar un arreglo basta con iterar sobre todas las posibles
permutaciones, aplicarle la permutación al arreglo y vericar que, efectivamente, el arreglo
obtenido esté ordenado.
Para eso, es bueno recordar cómo por recursión se pueden encontrar las permutación de Sn
(ver 3.1).
i i i i i, for del caso recursivo.

1 2 n m−1 m

Variable n, la recursin.

Figura 3.1: Las lineas punteadas son el for para poner la imagen de la permutación y la línea
verde hace referencia a cómo la recursión mueve el puntero en el arreglo de la permutación.

1 x = [2 ,4 ,2 ,3 ,3 ,4 ,1 ,5]
2 a = len(x)
3 laper = [0] * a
4 us = [0] * a
5 encon = 0
6 def permu(n,m):
7 global encon # permite ver la v a r i a b l e encon
8 if encon ==1: # ya encontre la permutacion , salga
9 return
10 if n==0: #caso base
11 y =[0] * m
12 for i in range (0,m): #componga e l arreglo y la pe
13 y[i]=x[laper[i]−1]
14 f = 0
15 for i in range (0,m−1): #v e r i f i q u e e l orden
16 if y[i]>y[i+1]:
17 f = 1
18 if f==0: #funciono
19 encon = 1
20 print y
21 return
22 for i in range (0,m): #caso recursivo
 4 Clase 3: Ordenamiento III

23 if us[i]==0:
24 us[i]=1
25 laper[m−n]=i+1
26 permu(n−1,m)
27 us[i]=0
28 permu (a,a)
En Java.
1 import java.util . * ;
2 public class orde{
3 public static int x[] = {2 ,4 ,2 ,3 ,3 ,4 ,1 ,5};
4 public static boolean ya = false;
5 public static boolean us [];
6 public static int laper [];
7 public static void main( String args []){
8 us = new boolean [x. length ];
9 laper = new int[x. length ];
10 orde(x.length ,x. length );
11 }
12 public static void orde(int a,int b){
13 if(ya) return ;
14 if(a ==0){
15 int y[] = new int[b];
16 for(int n = 0;n<b;n++)
17 y[n]=x[ laper[n]−1];
18 boolean f = false;
19 for(int n = 0;n<b−1 && !f;n++)
20 if(y[n]>y[n+1])f=true;
21 if(!f){
22 ya = true;
23 for(int n = 0;n<b;n++) System .out. print (y[n]+(n==b−1?"\n":","));
24 }
25 return ;
26 }
27 for(int i = 0;i<b;i++){
28 if(us[i]) continue ;
29 us[i]= true;
30 laper [b−a]=i+1;
31 orde(a−1,b);
32 us[i]= false;
 Ordenamiento 5

33 }
34 }
35 }
Ejercicios para el taller.

1. Diseñe e implemente en Python/C/Java un algoritmo que dado σ ∈ Sn , encuentre σ −1 .

2. Diseñe e implemente en Python/C/Java un algoritmo que dado x ∈ (N, ≤)∗ , encuentre
ˆ
St(x) .
3. Complete las pruebas.
6 Clase 3: Ordenamiento III
Bibliografía
[1] M. Aigner, A course in Enumeration, GTM (2007).
[2] N. Biggs, Discrete Mathematics, Oxford Press (2009).
[3] T. Cormen, C. Leiserson, R. Rivest, C. Stein, Introduction to Algorithms, 3rd Edition,
MIT Press (2009).
[4] D. Knuth, The art of computer programming, Addison-Wesley (1968).
[5] C. Papadimitriou, K. Steiglitz, Combinatorial Optimization, Dover (1998).
[6] R. Sedgewick, K. Wayne, Algorithms, 3rd Edition, Addison-Wesley (2011).
[7] D. Welsh, Matroid Theory, Dover (2005).