CARLOS OCHOA

ALGORITMOS DE ORDENAMIENTO DE VECTORES

Los algoritmos de ordenamiento de vectores son

esenciales para la programación en Python.

BUBLBLE SORT :
Este algoritmo compara elementos adyacentes en un
arreglo y los intercambia si están en el orden incorrecto.
Repite este proceso hasta que el arreglo esté ordenado.

COMO UTILIZARLO

Este algoritmo es fácil de implementar, pero es ineficiente

para vectores grandes, ya que su complejidad de tiempo
es O(n^2). Se recomienda utilizar Bubble Sort solo para
vectores pequeños.

EJEMPLO
def bubble_sort(arr):

n = len(arr)

for i in range(n):

for j in range(n - i - 1):

if arr[j] > arr[j + 1]:

arr[j], arr[j + 1] = arr[j + 1], arr[j]

return arr
CARLOS OCHOA
SELECTION SORT:
Este algoritmo selecciona el elemento más pequeño en un
arreglo y lo coloca al principio. Luego selecciona el
siguiente elemento más pequeño y lo coloca junto al
primer elemento, y así sucesivamente, hasta que todo el
arreglo esté ordenado.

COMO UTILIZARLO

Este algoritmo también es fácil de implementar, pero su

complejidad de tiempo es O(n^2). Se recomienda utilizar
Selection Sort solo para vectores pequeños.

EJEMPLO
def selection_sort(arr):

n = len(arr)

for i in range(n):

min_index = i

for j in range(i + 1, n):

if arr[min_index] > arr[j]:

min_index = j

arr[i], arr[min_index] = arr[min_index], arr[i]

return arr
CARLOS OCHOA
Insertion Sort:
Este algoritmo construye el arreglo ordenado final de a un
elemento a la vez. Toma cada elemento por turno e
inserta en su posición correcta en el arreglo ordenado.

COMO UTILIZARLO

Este algoritmo es eficiente para vectores pequeños y casi

ordenados, pero su complejidad de tiempo es O(n^2), lo
que lo hace ineficiente para vectores grandes y
desordenados.

EJEMPLO
def insertion_sort(arr):

n = len(arr)

for i in range(1, n):

key = arr[i]

j=i-1

while j >= 0 and key < arr[j]:

arr[j + 1] = arr[j]

j -= 1

arr[j + 1] = key

return arr
CARLOS OCHOA
MERGE SORT:
Este algoritmo divide un arreglo en dos mitades, ordena
cada mitad y luego las fusiona nuevamente en un solo
arreglo ordenado.

COMO UTILIZARLO

Este algoritmo tiene una complejidad de tiempo de O(n

log n) y es eficiente para vectores grandes y
desordenados. Se recomienda utilizar Merge Sort para
vectores grandes y desordenados.

EJEMPLO
def merge_sort(arr):

if len(arr) > 1:

mid = len(arr) // 2

left_half = arr[:mid]

right_half = arr[mid:]

merge_sort(left_half)

merge_sort(right_half)

i=j=k=0
CARLOS OCHOA
while i < len(left_half) and j < len(right_half):

if left_half[i] < right_half[j]:

arr[k] = left_half[i]

i += 1

else:

arr[k] = right_half[j]

j += 1

k += 1

while i < len(left_half):

arr[k] = left_half[i]

i += 1

k += 1

while j < len(right_half):

arr[k] = right_half[j]

j += 1

k += 1

return arr
CARLOS OCHOA
QUICK SORT:
Este algoritmo selecciona un elemento pivote y divide los
otros elementos en dos sub-arreglos, según si son
menores o mayores que el pivote. Luego ordena
recursivamente cada sub-arreglo.

COMO UTILIZARLO

Este algoritmo también tiene una complejidad de tiempo

de O(n log n) y es eficiente para vectores grandes y
desordenados. Se recomienda utilizar Quick Sort para
vectores grandes y desordenados.

EJEMPLO

def quick_sort(arr, low, high):

if low < high:
pivot_index = partition(arr, low, high)

quick_sort(arr, low, pivot_index - 1)

quick_sort(arr, pivot_index + 1, high)

return arr
CARLOS OCHOA

def partition(arr, low, high):

pivot_value = arr[high]
i = low - 1

for j in range(low, high):

if arr[j] < pivot_value:
i += 1
arr[i], arr[j] = arr[j], arr[i]

arr[i + 1], arr[high] = arr[high], arr[i + 1]

return i + 1
CARLOS OCHOA
HEAP SORT:
Este algoritmo convierte un arreglo en un heap, un tipo
especial de árbol binario, y luego elimina repetidamente el
elemento más grande del heap y lo coloca al final del
arreglo.

COMO UTILIZARLO

Este algoritmo tiene una complejidad de tiempo de O(n

log n) y es eficiente para vectores grandes y
desordenados. Se recomienda utilizar Heap Sort si se
desea una implementación más eficiente que Merge Sort
o Quick Sort, aunque puede ser un poco más difícil de
implementar.

EJEMPLO

def heap_sort(arr):
n = len(arr)

for i in range(n // 2 - 1, -1, -1):

heapify(arr, n, i)

for i in range(n - 1, 0, -1):

CARLOS OCHOA
arr[0], arr[i] = arr[i], arr[0]
heapify(arr, i, 0)

return arr
def heapify(arr, n, i):
largest = i
left_child = 2 * i + 1
right_child = 2 * i + 2

if left_child < n and arr[left_child] > arr[largest]:

largest = left_child

if right_child < n and arr[right_child] > arr[largest]:

largest = right_child

if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
heapify(arr, n, largest)