def shellSort(lst, lessfunction):
"""
shellSort sort para una lista generica con un comparador establecido
Args:
lst:: List
Lista sobre la cual se realizará el ordenamiento
lessfunction:
Funcion de comparación con la cual se organizaran los datos
Return :: None
"""
n = lt.size(lst)
h = 1
print("h=", h)
while h < n // 3: # Se calcula el tamaño del primer gap. La lista se h-ordena con este tamaño
h = 3 * h + 1 # por ejemplo para n = 100, h toma un valor inicial de 40, 13 , 4, 1
print("h=", h)
while (h >= 1):
print("Shell h: ", h)
for i in range(
h + 1, n + 1
): # posiciones validas para comparar con elementos a h-distancia a la izquierda
j = i
print("Shell i: ", i)
while (j >= (h + 1)) and lessfunction(lt.getElement(lst, j),
lt.getElement(lst, j - h)):
lt.exchange(lst, j, j - h)
print("Shell Exchange: ", j, j - h)
j -= h
h //= 3 # h se decrementa en un tercio. cuando h es 1, se comporta como insertionsort
def insertionSort (lst, function,condition):
size = lt.size(lst)
pos1 = 1
while pos1 <= size:
pos2 = pos1
while (pos2 >1) and (function (lt.getElement(lst, pos2),lt.getElement(lst, pos2-1),condition)):
lt.exchange (lst, pos2, pos2-1)
pos2 -= 1
pos1 += 1
def insertionSort (lst, lessfunction):
size = lst['size']
pos1 = 1
while pos1 <= size:
pos2 = pos1
while (pos2 >1):
if (lessfunction (lt.getElement(lst, pos2),lt.getElement(lst, pos2-1))):
lt.exchange (lst, pos2, pos2-1)
pos2 -= 1
pos1 += 1
def insertionSort(lst, lessfunction):
size = lt.size(lst)
pos1 = 1
while pos1 <= size:
pos2 = pos1
while (pos2 > 1) and (lessfunction(lt.getElement(lst, pos2),
lt.getElement(lst, pos2 - 1))):
lt.exchange(lst, pos2, pos2 - 1)
pos2 -= 1
pos1 += 1
return lst
def shellSort(lst, lessfunction):
n = lt.size(lst)
h = 1
while h < n / 3: # Se calcula el tamaño del primer gap. La lista se h-ordena con este tamaño
h = 3 * h + 1 # por ejemplo para n = 100, h toma un valor inical de 13 , 4, 1
while (h >= 1):
for i in range(h, n):
j = i
while (j >= h) and lessfunction(lt.getElement(lst, j + 1), lt.getElement(lst, j - h + 1)):
lt.exchange(lst, j + 1, j - h + 1)
j -= h
h //= 3 # h se decrementa en un tercio. cuando h es igual a 1, se comporta como insertionsort
def selectionSort (lst, compFunction):
size = lst['size']
pos1 = 1
while pos1 < size:
minimum = pos1 # minimun tiene el menor elemento conocido hasta ese momento
pos2 = pos1 + 1
while (pos2 <= size):
if (compFunction (lt.getElement(lst, pos2),lt.getElement(lst, minimum))):
minimum = pos2 # minimum se actualiza con la posición del nuevo elemento más pequeño
pos2 += 1
lt.exchange (lst, pos1, minimum) # se intercambia el elemento más pequeño hasta ese punto con el elemento en pos1
pos1 += 1
def shellSort(lst, lessfunction, column):
n = lt.size(lst)
h = 1
while h < n / 3: # Se calcula el tamaño del primer gap. La lista se h-ordena con este tamaño
h = 3 * h + 1 # por ejemplo para n = 100, h toma un valor inical de 13 , 4, 1
while (h >= 1):
for i in range(h, n):
j = i
while (j >= h) and lessfunction(lt.getElement(
lst, j + 1), lt.getElement(lst, j - h + 1), column):
lt.exchange(lst, j + 1, j - h + 1)
j -= h
h //= 3
def partition(lst, lo, hi, lessequalfunction):
"""
Función que va dejando el pivot en su lugar, mientras mueve elementos menores a la izquierda del pivot
y elementos mayores a la derecha del pivot
"""
follower = leader = lo
while leader < hi:
if (lessequalfunction(lt.getElement(lst, leader),
lt.getElement(lst, hi))):
lt.exchange(lst, follower, leader)
follower += 1
leader += 1
lt.exchange(lst, follower, hi)
return follower
def selectionSort(
lst, lessfunction, criteria, size
): #Se utiliza selection sort para que se organicen solo las primeras posiciones del ranking, y así
pos1 = 1 #gastar menos timepo con los archivos large
while pos1 < size:
minimum = pos1
pos2 = pos1 + 1
while (pos2 <= lt.size(lst)):
if (lessfunction(lt.getElement(lst, pos2),
lt.getElement(lst, minimum), criteria)):
minimum = pos2 # minimum se actualiza con la posición del nuevo elemento más pequeño
pos2 += 1
lt.exchange(
lst, pos1, minimum
) # se intercambia el elemento más pequeño hasta ese punto con el elemento en pos1
pos1 += 1
def insertionSort(lst, lessfunction):
"""
Insertion sort para una lista genérica con un comparador establecido
Args:
lst:: Lista
Lista sobre la cual se realizara el ordenamiento
lessfunction
Funcion de comparación con la cual se organizaran los datos
Return:: None
"""
size = lt.size(lst)
pos1 = 1
while pos1 <= size:
pos2 = pos1
while pos2 > 1:
if lessfunction(lt.getElement(lst, pos2),
lt.getElement(lst, pos2 - 1)):
lt.exchange(lst, pos2, pos2 - 1)
pos2 -= 1
pos1 += 1
def shellSort(lst, compFunction):
"""
shellSort sort para una lista generica con un comparador establecido
Args:
lst:: List
Lista sobre la cual se realizará el ordenamiento
compFunction:
Funcion de comparación con la cual se organizaran los datos
Return :: None
"""
n = lt.size(lst)
h = 1
while h < n/3: # Se calcula el tamaño del primer gap. La lista se h-ordena con este tamaño
h = 3*h + 1 # por ejemplo para n = 100, h toma un valor inical de 13 , 4, 1
while (h >= 1):
for i in range (h,n):
j = i
while (j>=h) and compFunction (lt.getElement(lst,j+1),lt.getElement(lst,j-h+1)):
lt.exchange (lst, j+1, j-h+1)
j -=h
h //=3 # h se decrementa en un tercio. cuando h es igual a 1, se comporta como insertionsort
def selectionSort (lst, compFunction):
"""
Selection sort para una lista generica con un comparador establecido
Args:
lst:: List
Lista sobre la cual se realizará el ordenamiento
compFunction:
Funcion de comparación con la cual se organizaran los datos
Return :: None
"""
size = lst['size']
pos1 = 1
while pos1 < size:
minimum = pos1 # minimun tiene el menor elemento conocido hasta ese momento
pos2 = pos1 + 1
while (pos2 <= size):
if (compFunction (lt.getElement(lst, pos2),lt.getElement(lst, minimum))):
minimum = pos2 # minimum se actualiza con la posición del nuevo elemento más pequeño
pos2 += 1
lt.exchange (lst, pos1, minimum) # se intercambia el elemento más pequeño hasta ese punto con el elemento en pos1
pos1 += 1
def sort(lst, lo, hi, lessFunc):
if (hi <= lo):
return
lt = lo
i = lo + 1
gt = hi
v = adtlt.getElement(lst, lo + 1)
while i <= gt:
v_i = adtlt.getElement(lst, i + 1)
if lessFunc(v_i, v):
adtlt.exchange(lst, lt + 1, i + 1)
lt = lt + 1
i = i + 1
elif lessFunc(v, v_i):
adtlt.exchange(lst, i + 1, gt + 1)
i = i
gt = gt - 1
else:
i = i + 1
sort(lst, lo, lt - 1, lessFunc)
sort(lst, gt + 1, hi, lessFunc)
def test_exchange(lstbooks, books):
book1 = lt.getElement(lstbooks, 1)
book5 = lt.getElement(lstbooks, 5)
lt.exchange(lstbooks, 1, 5)
assert lt.getElement(lstbooks, 1) == book5
assert lt.getElement(lstbooks, 5) == book1
def test_exchange(lstmovies, movies):
movie1 = lst.getElement(lstmovies, 1)
movie5 = lst.getElement(lstmovies, 5)
lst.exchange(lstmovies, 1, 5)
assert lst.getElement(lstmovies, 1) == movie5
assert lst.getElement(lstmovies, 5) == movie1
def permutate(lst):
for n in range(adtlt.size(lst)):
r = randrange(n, adtlt.size(lst))
adtlt.exchange(lst, n + 1, r + 1)
