A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Implementaci贸n de Selection Sort

8/10
Recursos

Aportes 93

Preguntas 4

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

let arr = [3,1,2,5,8,10,9,6];

const selectionSort = (arr) => {
    let tam = arr.length;
    let aux = 0;
    for (let i = 0; i < tam; i++){
        let indMin = i;
        for (let j = i + 1; j < tam; j++){
            if(arr[indMin] > arr[j]){
                indMin = j;
            }
        }
        aux = arr[i];
        arr[i] = arr[indMin];
        arr[indMin] = aux;
        console.log(arr);
    } 
}

selectionSort(arr);

Luego de todo ya lo entieno, lo que se hace es recorrer el array original buscando el valor minimo y ese valor lo enviamos a un nuevo array con el fin de ir creando un array ordenado

Reto e implementaci贸n en java.

private static void selectionSort(Integer[] array) {
		for(int i = 0; i < array.length - 1; i++) {			
			int min = array[i];
			int index = i;
			for(int j = i+1; j < array.length; j++) {	
				if(array[j] < min) {
					min = array[j];
					index = j;
				}
			}
			swap(array,i,index);
			List arr = Arrays.asList(array);		
			System.out.println("Iteraci贸n "+ (i+1) +": "+arr);
		}
	}
	
	private static void swap(Integer[] array, int origin, int destinity) {
		int tempValue = array[origin];
		array[origin] = array[destinity];
		array[destinity] = tempValue;
	}

Espero le ayude a alguien mi c贸digo 馃槂

# 1. Buscar el numero menor en mi array
# 2. Crear dos subarrays para llevar el control de mi algoritmo
# 3. devolver los datos del array ordenados
import sys
def selectionSort(array):
    
    # Recorre todo nuestro array
    for i in range(len(array)):
        print(array)
        #Encontrar el menor dato del array desordenado
        #Auxiliar de el array desordenado
        idxDesordenado = i 
        
        for j in range(i+1, len(array)):
            if array[idxDesordenado] > array[j]:
                idxDesordenado = j

        # cuando encontramos el minimo elemento, lo cambiamos por el primer valor de nuestro array desordenado
        array[i], array[idxDesordenado] = array[idxDesordenado], array[i]


def main():

    array = [3,124,412,13,235,2,323,3,212,1,25,5,3,323,6,3]
    selectionSort(array)
    
    print("Array ordenado: ")
    
    for i in range(len(array)):
        print("%d"%array[i])

if __name__ == "__main__":
    main()

funciono!!!
馃槜
uwu

Les dejo mi c贸digo con el reto resuelto!!!

def selectionSort(array):
	#Recorremos todo el array
	for i in range(len(array)):
		print(array)
		#Encontramos el valor m铆nimo restante dentro de nuestro array desordenado
		indiceDesordeando = i

		for j in range(i + 1, len(array)):
			if array[indiceDesordeando] > array[j]:
				indiceDesordeando = j

		#Ya que encontramos el mimino lo vamos a cambiar 
		#por el primer valor de nuestro array desordenado 

		array[i], array[indiceDesordeando] = array[indiceDesordeando], array[i]


def main():
	
	array = [20, 5, 21, 6, 23, 7, 34, 999, 68]
	selectionSort(array)

	print("Array ordenado: ")
	for i in range(len(array)):
		print(array[i])

if __name__ == '__main__':
	main()

Mi solucion:

def selectionSort(array):
    n = len(array)
    changes = 0
    print("Array disordered: ",array)
    for i in range(n):
        #Encontrar el valor minimo restante de nuestro array desordenado
        idxDes=i
        for j in range(i+1,n):
            if array[idxDes] > array[j]:
                idxDes = j
        #Ya encontrado ahora sera la poscicion 0, o el primero del array desordenado
        changes+=1
        array[i], array[idxDes] = array[idxDes], array[i] #swap
        print("Change: ",changes," in:",array)
    print("Array in order",array)

Dejo mi aporte del Reto UwU

#Buscar el numero menor en mi array
#Crear dos subarrays para llevar el control de mi algoritmo
#Imprimir el resultado del ordenamiento

import sys 
array = [20, 5, 21, 6, 23, 7, 34, 999, 68]

def selectionSort(array):
    #Recorer todo nuestro array
    for i in range(len(array)):

        #Encontrar el valor minimo restante dentro de nuestro array desordenado
        idxDes = i 
        for j in range(i+1, len(array)):
            if array[idxDes] > array[j]:
                idxDes = j

        #Ya que encontramos el minimo lo vamos a cambiar por el primer valor de nuetsro array desordenado
        array[i], array[idxDes] = array[idxDes], array[i]
        print("process %d", i)
        print(array)

#Ejecutar la funcion

selectionSort(array)
print("Array Ordenado:")
for i in range(len(array)):
    print("%d"%array[i]),

este es el script que implemente:

#script ordenamiento metodo selection short

import random

# funcion ordenamiento metodo selection short
def selection_short(lista):
    n = len(lista)

    # barrido de array de posicion 0 a n-1
    for i in range(0,n-1):
        index, mayor = 0, 0
        # busqueda del mayor del subarray
        for j in range(i+1,n):
            if lista[j] > mayor:
                mayor, index = lista[j], j
            #print("****"+str(j))
        #print("mayor: "+str(mayor)+" index: "+str(index))

        # swap entre el dato i y el menor
        if lista[index] > lista[i]:
            lista[index], lista[i] = lista[i], lista[index]
        #print(lista)
        #print("----"+str(i))
    
    # ajusta nuevamente el vector de m a mayor
    return lista[::-1]

if __name__ == "__main__":

    # generacion de lista ordenada
    valor = int(input("tamano de lista a crear: "))

    lista = [ random.randint(0,100) for i in range(valor)]
    print(lista)

    resultado = selection_short(lista)
    print("lista ordenada: ")
    print(resultado)
    print("prueba: ")
    print(sorted(lista))

Implementacion en C

#include <stdio.h>

void	swap_printf(int *s, int n)
{
	int	i;

	i = 0;
	while (i < n)
	{
		printf("%d ", s[i]);
		i++;
	}
	printf("\n");
}

void	ft_swap(int *i, int *min_i)
{
	int	tmp;

	tmp = *i;
	*i = *min_i;
	*min_i = tmp;
}

int	*ft_selectionSort(int *s, int n)
{
	int	i;
	int	j;
	int	min_i;
	int	temp;

	i = 0;
	while (i < n -1)
	{
		min_i = i;
		j = i + 1;
		while (j < n)
		{
			if (s[j] < s[min_i])
				min_i = j;
			j++;
		}
		ft_swap(&s[i], &s[min_i]);
		i++;
	}
	return (s);
}

int	main(void)
{
	int		array[] = {14, 9, 7, 1, 8, 87, 34, 97, 134, 9876, 543, 556, 765, 6};
	int		*res;
	size_t	n;

	n = sizeof(array) / sizeof(array[0]);
	res = ft_selectionSort(array, n);
	swap_printf(array, n);
	return (0);
}

def selectionSort(array):

for i in range(len(array)):
    print(array)
    
    idxDesordenado = i 
    
    for j in range(i+1, len(array)):
        if array[idxDesordenado] > array[j]:
            idxDesordenado = j

    array[i], array[idxDesordenado] = array[idxDesordenado], array[i]

def main():

array = [3,124,412,13,235,2,323,3,212,1,25,5,3,323,6,3]
selectionSort(array)

print("Array ordenado: ")

for i in range(len(array)):
    print("%d"%array[i])

if name == 鈥main鈥:
main()

import sys
def selectionSort(array):
    
    # Recorre todo nuestro array
    for i in range(len(array)):
        print(array)
        #Encontrar el menor dato del array desordenado
        #Auxiliar de el array desordenado
        idxDesordenado = i 
        
        for j in range(i+1, len(array)):
            if array[idxDesordenado] > array[j]:
                idxDesordenado = j

        # cuando encontramos el minimo elemento, lo cambiamos por el primer valor de nuestro array desordenado
        array[i], array[idxDesordenado] = array[idxDesordenado], array[i]


def main():

    array = [3,124,412,13,235,2,323,3,212,1,25,5,3,323,6,3]
    selectionSort(array)
    
    print("Array ordenado: ")
    
    for i in range(len(array)):
        print("%d"%array[i])

if __name__ == "__main__":
    main()

[3, 124, 412, 13, 235, 2, 323, 3, 212, 1, 25, 5, 3, 323, 6, 3]
[1, 124, 412, 13, 235, 2, 323, 3, 212, 3, 25, 5, 3, 323, 6, 3]
[1, 2, 412, 13, 235, 124, 323, 3, 212, 3, 25, 5, 3, 323, 6, 3]
[1, 2, 3, 13, 235, 124, 323, 412, 212, 3, 25, 5, 3, 323, 6, 3]
[1, 2, 3, 3, 235, 124, 323, 412, 212, 13, 25, 5, 3, 323, 6, 3]
[1, 2, 3, 3, 3, 124, 323, 412, 212, 13, 25, 5, 235, 323, 6, 3]
[1, 2, 3, 3, 3, 3, 323, 412, 212, 13, 25, 5, 235, 323, 6, 124]
[1, 2, 3, 3, 3, 3, 5, 412, 212, 13, 25, 323, 235, 323, 6, 124]
[1, 2, 3, 3, 3, 3, 5, 6, 212, 13, 25, 323, 235, 323, 412, 124]
[1, 2, 3, 3, 3, 3, 5, 6, 13, 212, 25, 323, 235, 323, 412, 124]
[1, 2, 3, 3, 3, 3, 5, 6, 13, 25, 212, 323, 235, 323, 412, 124]
[1, 2, 3, 3, 3, 3, 5, 6, 13, 25, 124, 323, 235, 323, 412, 212]
[1, 2, 3, 3, 3, 3, 5, 6, 13, 25, 124, 212, 235, 323, 412, 323]
[1, 2, 3, 3, 3, 3, 5, 6, 13, 25, 124, 212, 235, 323, 412, 323]
[1, 2, 3, 3, 3, 3, 5, 6, 13, 25, 124, 212, 235, 323, 412, 323]
[1, 2, 3, 3, 3, 3, 5, 6, 13, 25, 124, 212, 235, 323, 323, 412]
Array ordenado:
1
2
3
3
3
3
5
6
13
25
124
212
235
323
323
412

Para el reto solo coloqu茅 print(鈥渋teraci贸n %d鈥, i) en la l铆nea 20 y print(array) en la l铆nea 21, ambos en la misma indentaci贸n del array de la l铆nea 19 (en el c贸digo de la clase).

Y me result贸 as铆:

AQUI LES DEJO LA FORMA EN QUE LO REALICE:

import sys
array=[20,21,9,32,23,59,1]
print(f"VECTOR SIN ORDENAR: {array}")
def selecionSort(array):
for i in range(len(array)):
indice=i
for j in range(i+1,len(array)):
if array[indice]>array[j]:
indice=j #encontramos el minimo y lo pasamos al primero del array desordenado
array[i],array[indice]=array[indice],array[i]

selecionSort(array)
print(f"VECTOR ORDENADO: {array}")

Mi implementacion con dos listas, si quieren reducir mas el codigo pueden cambiar el find_min por min y sale 馃槃

def find_min(arr: list):
    min_item = None
    for i in arr:
        if min_item is None:
            min_item = i
        if i < min_item:
            min_item = i
    return min_item


def selection_sort(arr: list) -> list:
    ordened = []
    disordened = arr
    while len(disordened) > 0:
        ordened.append(find_min(disordened))
        disordened.remove(find_min(disordened))
    return ordened


if __name__ == '__main__':
    disordened = [1, 20, 14, 9, 5, 3, 7, 2]
    ordened = selection_sort(disordened)
    print(ordened)

En JavaScript

const selectionSort = (arr) => {
    for (let i = 0; i < arr.length; i++) {
        indexDes = i
        for (let j = i+1; j < arr.length; j++) {
            if(arr[indexDes] > arr[j]){
                indexDes = j
            }
        }
        let helper = arr[i]
        arr[i] = arr[indexDes]
        arr[indexDes] = helper
    }
    return arr
}

let array = [6,23,9,4,3,67,2,8]

selectionSort(array)

Mi soluci贸n en python, dart and javascript.

Resuelto

import sys
array = [20,5,21,6,23,7,34,999,68]

def selectionSort(array):
    for i in range(len(array)):#Es el encargado de hacer todo el recorrido en todo nuestro array
        print(array)
        #Encontrar el valor minimo restante dentro de nuestro array desordenado
        idxDesordenado = i #Varaible a utilizar indice de array desordenado
        for j in range(i + 1, len(array)):
            if array[idxDesordenado] > array[j]: #Trabajamos con corchetes porque estamos hablando de posiciones
                idxDesordenado = j
        
        #ya que encontramos el minimo lo vamos a cambiar por el primer valor de nuestro array desordenado
        array[i], array[idxDesordenado] = array[idxDesordenado], array[i]


if __name__ == "__main__":

    selectionSort(array)
    print("Array Ordenado: ")

    for i in range(len(array)):
        print("%d"%array[i]),

Hola 馃槂 Comparto mi soluci贸n al reto
Cualquier recomendaci贸n o comentario para mejorarlo lo agradecer铆a mucho

# Reto: Imprimir cada ciclo de este trabajo

import sys

def selection_sort(array):
    print(f'Estado inicial del array: {array}')

    for i in range(len(array)):
        indice = i

        for j in range (i+1, len(array)):
            if array[indice] > array[j]:
                indice = j

        array[i], array[indice] = array[indice], array[i]
        print(f'Comprobando la posici贸n de {array[i]}, estado del array: {array}')


    print("Nuestro array ordenado: ")
    for i in range(len(array)):
        print("%d" %array[i]),


if __name__ == "__main__":
    array = [20, 5, 21, 6, 23, 7, 34, 999, 68]
    selection_sort(array)

Presento mi version con generacion aleatoria de numeros para el array

#1. Buscar el numero menor en el array generado aleatoriamente
#2. Crear 2 sub arrays para llevar el control del algoritmo

# import sys
import random
limite = 30
array = []

def cargaArreglo(limite):
    while limite >= 1:
        array.append(random.randint(1, 3000))
        limite = limite - 1

cargaArreglo(limite)

def selectionSort(array):
    for i in range(len(array)):
        idxDes = i
        for j in range(i+1, len(array)):
            if array[idxDes] > array[j]:
                idxDes = j

        array[i], array[idxDes] = array[idxDes], array[i]

selectionSort(array)
for i in range(len(array)):
    print("%d"%array[i])```

No entiendo por qu茅 el 68 se posiciona despu茅s del n煤mero menor:
https://static.platzi.com/media/user_upload/code-9d13210b-c51d-4073-851c-187e15da60ea.jpg
que puede estar pasan; ya revise el c贸digo y esta igual que el del profe

En Java.

import java.util.Arrays;
public class SelectionSort {
    public static void main(String[] args) {
        int lista[] = {5, 9, 3, 7, 1, 8};
        System.out.println("N煤mero de elementos en la lista: " + lista.length);
        // Uno por uno se mueve en el subarray desordenado
        for (int i = 0; i < lista.length - 1; i++) {
            // Buscar el minimo elemento en una lista desordenada
            int min_idx = i;
            for (int j = i + 1; j < lista.length; j++) {
                if (lista[j] < lista[min_idx])
                    min_idx = j; //buscando el 铆ndice m谩s bajo
            }
            System.out.println("N煤mero menor: " + lista[min_idx] + " | 脥ndice original: " + min_idx);
            System.out.println(Arrays.toString(lista));
            // Cambio del minimo elemento con el primer elemento
            int temp = lista[min_idx];
            lista[min_idx] = lista[i];
            lista[i] = temp;
            System.out.println("脥ndice final: " + i + " | Se mueve el: " + lista[min_idx]);
        }

        System.out.println("Lista Ordenada: " + Arrays.toString(lista));
    }


}

Una desventaja de este algoritmo de ordenamiento frente al de burbuja es que no mejora su rendimiento cuando los datos ya est谩n ordenados o parcialmente ordenados.

import sys
array = [23,54,85,47,54,85,74,8,5,6,4,7,8,9] 
def selectionSort(array):
    for i in range(len(array)):
        print(array)
        swapped = False
        idxDes = i
        for j in range(i+1, len(array)):
            if array[idxDes] > array[j]:
                idxDes = j
                swapped = True
                if swapped == False:
                    break 
        array[i], array[idxDes] = array[idxDes], array[i]

selectionSort(array)
print("Array Ordenado: ")
for i in range(len(array)):
    print("%d"%array[i]),```

Mi soluci贸n en java.

import java.util.Arrays;
import java.util.Random;
import java.util.function.BiPredicate;

public class SelectionSort {

    public void sort(final int array[], final BiPredicate<Integer, Integer> sortType) {
        final int n = array.length;
        boolean sorted = false;
        int idxDes;
        int temp;
        print("Size n: %d%n%n", n);

        for (int i = 0; i < n && !sorted; i++) {
            print("Iteration %d input %s%n", i + 1, Arrays.toString(array));
            sorted = true;

            // Buscando el indice del valor m谩s bajo
            idxDes = i;
            for (int j = i + 1; j < array.length; j++) {
                if (sortType.test(j, idxDes)) {
                    idxDes = j;
                    sorted = false;
                }
            }

            // Cambio del minimo elemento con el primer elemento
            temp = array[i];
            array[i] = array[idxDes];
            array[idxDes] = temp;

            print("Iteration %d ouput %s%n", i + 1, Arrays.toString(array));
            print("%s%n%n", "-".repeat(46)); // Java 11 only

        }

    }

    private void print(final String template, final Object... values) {
        System.out.printf(template, values);
    }

    public static void main(String[] args) {
        final int n = 6;
        final int randomNumbers[] = new Random().ints(n, 0, 100).toArray();
        final BiPredicate<Integer, Integer> orderAsc = (j, idxDes) -> randomNumbers[idxDes] > randomNumbers[j];

        final SelectionSort selectionSort = new SelectionSort();
        selectionSort.sort(randomNumbers, orderAsc);
    }

}

mas claro! mmuy buenisimo profe

Reto solucionado 馃懆鈥嶐煉

# Selection Sort Algoritmo
array = [2, 23, 34, 100, 59, 951, 6]

def selectionSort(array):
    
    for i in range(len(array)):
        idxDes = i
        
        for j in range(i + 1, len(array)):
            print(array)
            if array[idxDes] > array[j]:
                idxDes = j
    
        array[i], array[idxDes] = array[idxDes], array[i]


selectionSort(array)
print(array)    

C贸digo en JS.

function selectionSort(arr) {
  let arrLength = arr.length;
  let minorIndex;
  for (let i = 0; i < arrLength; i++) { 
   minorIndex = i;
    for (let j = i; j < arrLength; j++) {
      if ( arr[minorIndex] > arr[j] )
     minorIndex = j;
    }

    [ arr[i], arr[minorIndex] ] = [ arr[minorIndex], arr[i] ]; 
    console.log(arr);  
  } 
}

arr = [700, 312, 8, 12, 1, 66, -40, 859, 24, 0, -120]
selectionSort(arr)
console.log("El arreglo ordenado es: \n")
console.log(arr);```
for i in range(len(A)): 
    print(A)  
    min_idx = i 
    for j in range(i+1, len(A)): 
        
        if A[min_idx] > A[j]: 
            min_idx = j 
              

    A[i], A[min_idx] = A[min_idx], A[i] 
  

print ("Sorted array") 
for i in range(len(A)): 
    print("%d" %A[i])  ```
/*
	 * Selection Sort Iterative
	 **/
	public static int[] selectionSort(int[] items) {

		int swapElement = 0;
		for (int i = 0; i < items.length; i++) {

			int indexMenor = i;

			for (int j = (i + 1); j < items.length; j++) {

				if (items[indexMenor] > items[j]) {

					indexMenor = j;

				}
			}

			swapElement = items[i];
			items[i] = items[indexMenor];
			items[indexMenor] = swapElement;

		}

		return items;
	}```

ya veo como funciona toma la celda actual y la compara con las dem谩s celdas asta hallar la mas peque帽a entre sus compa帽eras por eso se ejecuta algunas mas veces que bubble sort pero el recorrido del array se disminuye lo que hace una comprobaci贸n mas rapida
![](

Lo hice antes de ver el video y en vez de usar doble for, use un for y un while:

def selectionSort(array):
    n = len(array)

    for i in range(n):
        print(array)
        j = i
        min = j
        while j < n-1:
            if(array[j+1] < array[min]):
                min = j+1
            j += 1
        
        array[i], array[min] = array[min], array[i]

array = [50, 23, 15, 20, 10, 999, -4]
selectionSort(array)
print("\nEl array ordenado es:\n", array)```

Mi implementaci贸n

numbers = [4005,8,25,65,48,85,22,14,22,530,2,90,4,5,88,52,205,668,8555,54,0,633,10]

n = len(numbers)

for i in range(n - 1):
 
    min = numbers[i]

    for j  in range( i + 1 , n ):
 
        if min > numbers[j]  :
            min = numbers [ j ]
            index =  j   
    
    if min != numbers[i]:
        numbers[index] = numbers[i]   
        numbers[i] = min
print (numbers)```

Ordenamiento por seleccion en C++

#include <iostream>
#include <ctime>
using namespace std;

int main(){
  srand(time(NULL));

  int n = 100;
  int aux, min, arreglo[n];

  cout<<"\tElementos Desordenados \n";
  for (int i = 0; i < n; i++){
    arreglo[i] = rand()% + 100; // rand() % (Hasta - Desde + 1) + Desde para poner un limite o solo se pone + n que sera del cero hasta n
    cout<<arreglo[i]<<" ";
  }

  for(int i = 0; i < n; i++){
    min = i;
    for(int j = (i + 1); j < n; j++){
      if(arreglo[j] < arreglo[min]){
        min = j;
      }
    }
    aux = arreglo[i];
    arreglo[i] = arreglo[min];
    arreglo[min] = aux;
  }

  cout<<"\n\n\tElementos Ordenado"<<endl;
  for(int i = 0; i < n; i++){
    cout<<arreglo[i]<<" ";
  }
  return 0;
}



def selectionSortAsc(lista):
    for i in range(len(lista)):
        print(lista)
        minValorIndex = i
        for index in range(i+1, len(lista)):
            if lista[minValorIndex] > lista[index]:
                minValorIndex = index
        lista[i], lista[minValorIndex] = lista[minValorIndex], lista[i]

def selectionSortDes(lista):
    for i in range(len(lista)-1, -1, -1):
        print(lista, i)
        minValorIndex = i
        for index in range(0):
            if lista[minValorIndex] > lista[index]:
                minValorIndex = index
        lista[i], lista[minValorIndex] = lista[minValorIndex], lista[i]

            

def run():
    lista = [17,1,15,4,3,9,10,2,5,20,14,7]
    selectionSortAsc(lista)
    selectionSortDes(lista)
    #print(lista)

if __name__ == '__main__':
    run()
import sys
array = [20, 5, 21, 6 , 23, 7, 34, 999, 68]

def selectionSort(array):
    #recorremos el array
    for i in range(len(array)):
        print(array)
        #variable de control, inicializada como verdadera
        comparaciones = True

        #Encontrar el valor minimo que queda en nuestro array desordenado
        idxDes = i
        for j in range(i+1, len(array)):
            if array[idxDes] > array[j]:
                idxDes = j
                #hacemos falsa la variable de control 
                #para que pase el ciclo if de control
                comparaciones = False
        #ciclo if de control
        if comparaciones:
            break

        #en idxDes se guarda el menor elemento del array, 
        #lo cambiamos por el primer elemento del array desordenado
        array[i], array[idxDes] = array[idxDes], array[i]

#ejecutar la funcion
selectionSort(array)
print("Array ordenado:")
for i in range(len(array)):
    print("%d" %array[i]),```

El ejercicio con la impresion de las iteraciones

#SelectionSort
def selectionSort(array):
	for i in range(len(array)):
		idxDes=i
		print("Iteracion i:",i,"idxDes:",idxDes)
		for j in range(i+1,len(array)):
			print("j:",j,"i+1:",i+1,"len(array):",len(array))
			if array[idxDes]>array[j]:
				idxDes=j
				print("idxDes:",idxDes)
		array[i],array[idxDes]=array[idxDes],array[i] #swap
		print(array) #imprime array de la iteracion i

array=[34,2,56,0,3]
selectionSort(array)
print("Array Final: ",array)

Generalmente el codigo se puede refactorizar mas, es una muy buena practica ademas que lo hace mucho mas entendible

# Algoritmo de ordenamiento Selection Sort
def SelectionSort(array):
  for i in range(len(array)):
    # Reto completado
    print(array)
    # pos almacenara la menor posicion encontrada
    pos = FindSmallest(array, i)
    array[i], array[pos] = array[pos], array[i] 
  # Ya ordenado nuestro arreglo lo imprimimos
  printArray(array)


# Funcion para encontrar la menor posicion
def FindSmallest(array, i):
  aux = i
  for j in range(i + 1, len(array)):
    if array[aux] > array[j]:
      aux = j
  return aux

# Funcion para imprimir arreglos
def printArray(array):
  for i in range(len(integers)):
    print("%d"%integers[i]),

if __name__ == "__main__":
  integers = [2,5,1,9,7,8];
  SelectionSort(integers)
#1. Crear un array de ayuda
#2. Buscar el elementos mas bajo del array principal
#3. Insertar ese elemento al array de ayuda
#4. Repetir hasta que no existan mas elementos en el array principal

def selectionSort(array, showSteps = False):
    n = len(array)

    #Recorrer el array
    for i in range( n ):
        #Encontrar el valor minimo dentro del array desordenado
        idDes = i

        # Buscar en el desordenado 
        for j in range(i + 1, n):
            #Comparar y ver cual es el menor
            if array[idDes] > array[j]:
                idDes = j
        
        if showSteps:
            print("Step {}: {}".format(i, array))
        
        #Encontramos el minimo
        #Cambiarlo por el primer valor del array desordenado
        array[i], array[idDes] = array[idDes], array[i]

#Driver de la funcion
def main():
    array = [100, 68, 20, 5, 6, 23, 7, 68, 72, -1]
    print("Unsorted array: ", array)

    selectionSort(array, True)
    print("Sorted array: ", array)

if __name__ == "__main__":
    main()
#Buscar el n煤mero menor en mi array
#Crear dos sub-arrays para llevar el control del algoritmo
#Imprimir el resultado del ordenamiento
import sys
array = [20, 5, 21, 6, 23, 7, 34, 999, 68]

def selectionSort(array):
  #recorre el array
  for i in range(len(array)):
    print(array)
    #encuentra el valor m铆nimo restante dentro del array desordenado
    idxDes = i
    for j in range(i+1, len(array)):
      if array[idxDes] > array[j]:
        idxDes = j
    
    #El valor minimo se cambia por el primer valor del array desordenado
    array[i], array[idxDes] = array[idxDes], array[i]

#Ejecutar la funci贸n

selectionSort(array)
print("Array Ordenado: ")
for i in range(len(array)):
  print("%d" %array[i]),

Mi soluci贸n

def selection_sort(array):
    size = len(array)

    for i in range(size):
        minor = array[i]
        minor_pos = array[i]
        swap = False

        for j in range(i + 1, size):
            current = array[j]
            if current < minor:
                minor = current
                minor_pos = j
                swap = True
        if swap:
            array[minor_pos], array[i] = array[i], array[minor_pos]

    return array


print(selection_sort([2, 2, 5, 4, 7]))
print(selection_sort([3, 1, 4, 4, 7, 8, 0, 9]))
print(selection_sort([10, 3, 1, 4, 4, 7, 8, 0, 9])

[2, 2, 4, 5, 7]
[0, 1, 3, 4, 4, 7, 8, 9]
[0, 1, 3, 4, 4, 7, 8, 9, 10]
<
array = [1907, 9, 12005, 1, 35000, 5, 200, 7, 2000, 1]

def selectionSort(array):
    for i in range(len(array)):
        idxDEs = i
        print(array,'Se va ordenando')
        print(array[idxDEs-1],'---','Numero menor que tomo')
        print(array[idxDEs],'Numero donde empieza')
        for j in range(i+1, len(array)):
            print(array[j],'******','Numeros que recorre')
            if array[idxDEs] > array[j]:
                idxDEs = j


        array[i], array[idxDEs] = array[idxDEs], array[i]
        print('----------'*3)


selectionSort(array)
print('array ordenado')
print(array)
>

Mejoras y arreglo de errores de mi intento respecto al anterior clase
Para el ejemplo de esta clase mi codigo no ordenaba bien, porque yo no estaba almacenando la posicion, en vez de eso guardaba el valor pero para hacer el cambio si guardaba la posicion, grave error!, es mucho mas importante guardar la posicion del valor encontrado que el valor en si, el valor por los swaps van a ir cambiando.

def selectionSort(array):
  n = len(array)
  print(n)
  for i in range (n-1):
    menorTemporal = array[i]
    posicion = i
    
    for j in range (i+1, n):
      if menorTemporal > array[j]:
        menorTemporal = array[j]
        posicion = j
      print(array, menorTemporal)
    array[i], array[posicion] = array[posicion], array[i]
    print("---")


array = [20,5,21,6,23,7,34,68]

selectionSort(array)

print(array)
# Python program for implementation of Selection 
# Sort 
import sys 
A = [64, 25, 12, 22, 11] 
  
# Traverse through all array elements 
for i in range(len(A)): 
      
    # Find the minimum element in remaining  
    # unsorted array 
    min_idx = i
    count = 0 
    for j in range(i+1, len(A)): 
        if A[min_idx] > A[j]: 
            min_idx = j 
            count = 1
              
    # Swap the found minimum element with  
    # the first element         
    A[i], A[min_idx] = A[min_idx], A[i] 
    print(A)
    if count == 0:
        break
# Driver code to test above 
print ("Sorted array") 
for i in range(len(A)): 
    print("%d" %A[i]),  

Solved in python

def selection(arr):
  for i in range(len(arr)-1):
    idx = i
    for j in range(i+1,len(arr)):
      if arr[idx] > arr[j]:
        idx = j
    print(arr)
    arr[idx],arr[i] = arr[i],arr[idx]

array = [190,1200,1,2,4,55,1000,6,800,0]
selection(array)
print(array)
defSelectionSort(array):
  for i in range(len(array)):
    print(array)
    pos = FindSmallest(array, i)
    array[i], array[pos] = array[pos], array[i] 
  printArray(array)

defFindSmallest(array, i):
  aux = i
  for j in range(i + 1, len(array)):
    if array[aux] > array[j]:
      aux = j
  return aux

defprintArray(array):
  for i in range(len(integers)):
    print("%d"%integers[i]),

if __name__ == "__main__":
  integers = [2,5,1,9,7,8];
  SelectionSort(integers)```
const selectionSort = (numbers) => {
  let temp
  let index
  for (let i = 0; i < numbers.length; i++) {
    index = i
    for (let j = i; j < numbers.length - 1; j++) {
      if (numbers[j] > numbers[j + 1]) {
        index = j + 1
      }
    }
    console.log(numbers)
    temp = numbers[i]
    numbers[i] = numbers[index]
    numbers[index] = temp
  }
  return numbers
}

Les comparto algunas relacionadas con el algoritmo de insertion sort

Selection Sort en C

// Leer un vector de n elementos

void leervect(float x[20], int n)
{
   int i;
   for (i = 1; i <= n; i++)
      {
		printf("x(%d)=",i);
		scanf("%f",&x[i]);
	  }
	  return;
}
	  
// Escribir un vector de n elementos

void escvect(float x[20], int n)
{
   int i;
   for (i = 1; i <= n; i++)
	{
		printf ("%5.0f ",x[i]);
	}
	return;
}
			
// M茅todo Ordenaci贸n por Selecci贸n

void seleccion(float x[20], int n)
{
   int i,j,k;
   float temp;
   for(i=1; i <= n-1; i++)
      { 
         k = i;
         temp = x[i];
         for(j=i+1; j <=n; j++)
            if(x[j] < temp)
               {
                  k = j;
                  temp = x[j];
               }
         x[k] = x[i];
         x[i] = temp;
			 
      }         
   return;
}


main()
{
	int n, i;
    float x[20];
    printf("METODO ORDENACION POR SELECCION\n\n");
	printf("Numero de elementos = ");
	scanf("%d",&n);
	printf("\nElementos del Vector \n");
	leervect(x, n);
	printf("\n\nVector Original\n");
	escvect(x, n);
    seleccion(x, n);
	printf("\n\nVector Ordenado\n");
    escvect(x, n);
	getch();
}```

Reto:

Versi贸n en JavaScript

/*
1. Buscar el n煤mero menor en el array
2. Crear dos sub-arrays para llevar el control del algoritmo
3. Imprimir el resultado ordenado
*/
const dataSet = [1997, -2, 4, 3, 0, 100, 12, 20, 123, -6, -8, 10]

const selectionSort = (arr) =>{
    const size = arr.length
    
    //For que recorre el array
    for(let i = 0; i < size; i++){
        //Encontrar el valor m铆nimo dentro del array desordenado
        indexDes = i;
        for(let j = i; j < size-1; j++){
            if(arr[indexDes] > arr[j]){
                indexDes = j;
            }
        }

        //Ya que se tiene el valor m铆nimo, se cambia por el primer valor del array desordenado
        swap(arr, i, indexDes)
        console.log(arr)
    }
    return arr;
}

const swap = (arr, n1, n2) => {
    let temp = arr[n1]
    arr[n1] = arr[n2];
    arr[n2] = temp;
}

console.log(selectionSort(dataSet));

Mi Soluci贸n:

import random as rd

def selection_sort(my_list):

    subarray = []
    #numbers = list(range(list_size)) 
    #rd.shuffle(numbers)
    numbers = my_list
    m = min(numbers)
    
    while len(numbers) > 0:
        subarray.append(m)

        for i in range(len(numbers)):
            if numbers[i] == m:
                numbers.pop(i)
                break

        if len(numbers) > 0:        
            m = min(numbers)
        else:
            break

    ordered_list = subarray + numbers

    return ordered_list

if __name__ == "__main__":

    list_size = int(input('enter the size of the list: '))
    my_list = [rd.randint(0, 100) for i in range(list_size)]
    print(my_list)
    my_sort = selection_sort(my_list)
    print( my_sort)

Les comparto mi implementaci贸n en Lenguaje C.

#include <stdio.h>

void bubbleSort(int array[], int num)
{
    int aux = 0;
    for(int i = 0; i < num-1 ;i++)
    {
        int indexDesor = i;
        for (int j = i+1; j < num-1; j++)
        {
            if(array[indexDesor] > array[j])
            {
                indexDesor = j;
            }
        }
        aux = array[indexDesor];
        array[indexDesor] = array[i];
        array[i] = aux;
    }
}

int imprimirArray(int array[], int num)
{
    printf("[");
    for (int i = 0; i < num-1; i++)
    {
        printf("%d, ", array[i]);
    }
    printf("]");
}

int main()
{
    int array[] = {20, 5, 21, 6, 23, 7, 34, 999, 68};
    int size =  sizeof(array) / sizeof(array[0]);

    bubbleSort(array, size);
    imprimirArray(array, size);
    printf("\n");
    return 0;
}```
#Look for the smallest number
#Create 2 subarrays 

import sys

array = [10, 30, 40, 40, 29, 42, 5, -8, 999]

def selectionSort(array):

    for i in range ( len(array) ):
        #Find the minimum value
        idxDes = i
        for j in range(i+1, len(array)):
            if array[idxDes] > array[j]:
                idxDes = j
        
        #Change the minimum value for the first one
        array[i], array[idxDes] = array[idxDes], array[i]
        print(array)

selectionSort(array)
print("sorted array: ")
for i in range( len(array) ):
    print("%d" %array[i]),```
#1. Find the smallest number in the array
#2. Make two sub arrays to keep track of the algorithm

#Function to do the Selection Sort
def selectionSort (arr):
    n = len(arr)

    #The first FOR loop is to walk through the whole array
    for i in range(n):
        #This print the sorting cycle
        print(arr)

        #Now we need to find the smallest number in the array and
        #we also need to save the index of the second sub array
        indexDesor = i
        for j in range(i+1, n):
            
            if arr[indexDesor] > arr[j]:
                indexDesor = j
                
        #Once we found the smallest number we are going to switch it for the 
        #first value of the disordered array
        arr[i],arr[indexDesor] = arr[indexDesor], arr[i]


array = [50,26,85,46,92,7,15]
selectionSort(array)

print('El array ordenado es: ')
#This FOR loop print the sort in realtime
for i in range(len(array)):
    print("%d" %array[i])

Reto realizado:

import sys

def selectionSort(array):
    
    for i in range(len(array)-1): #recorrer todo el array, no me imprimiria un recorrido de mas, ya que hasta ahi se encuentra ordenado 
        
        # encontrar el valor minimo restante dentro del array desordenado
        idxdes = i  # estamos comenzando en 0
        for j in range(i + 1, len(array)):
            if array[idxdes] > array[j]: # se confirma que va a ser el minimo
                idxdes = j
        
        # ya que encontramos el minimo elemento lo vamos a 
        # cambiar por el primer valor de nuestro array desordenado 
        array[i], array[idxdes] = array[idxdes], array[i]

        print(f'recorrido {i + 1}: {array}') # me imprime el final de cada recorrido i + 1
   
    
if __name__ == '__main__':

    array = [20, 5, 21, 6, 23, 7, 34, 999, 68, 56, 348, 1, 90]
    print('')
    selectionSort(array)
    print('')
array = [20, 5, 21, 6, 23, 7, 34, 999, 68]


def selectionSort(array):
    # recorrer todo nuestro array
    for i in range(len(array)):
        # encontrar el valor m铆nimo restante dentro de nuestro array
        # desordenado
        idxDes = i
        for j in range(i+1, len(array)):
            if array[idxDes] > array[j]:
                idxDes = j
        # Ya que encontramos el m铆nimo lo vamos a cambiar por el primer valor
        # de nuestro array desordenado
        array[i], array[idxDes] = array[idxDes], array[i]
        print(array)


# Ejecutar la funci贸n
selectionSort(array)
print("Array ordenado: ")
for i in range(len(array)):
    print("%d " % array[i], end=""),

Hola , recomiendo ver este v铆deo https://www.youtube.com/watch?v=AgFR0kO05RM
al final de la explicaci贸n de ricardo , yo tuve un problema en entender la parte del c贸digo ya que no manejo python y hay una parte del bucle que no comprend铆 , entonces para aquellos q les pase lo mismo que a mi , 茅chenle una mirada a ese v铆deo , ah铆 entend铆 el c贸digo xD.

En c:

//Buscar el n煤mero menor en mi array
//Crar dos subarrays para llevar el control de mi algoritmo
//imprimir resultado de ordenamiento
#include <stdio.h>

void cambio(int *comp1, int *comp2)
{
    int temp = *comp1;
    *comp1 = *comp2;
    *comp2 = temp;
}

void selectionSort(int entrada[], int n)
{
    int i, j, min;

    // Se mueve dentro de los elementos del array
    for (i = 0; i < n-1; i++)
    {
       
        min = i;
        for (j = i+1; j < n; j++) 
          if (entrada[j] < entrada[min]) // elemento j es menor al min
            min = j;

        // cambio del orden
        cambio(&entrada[min], &entrada[i]); // se hace el cambio de posici贸n
        for(int j = 0; j < n ; j++){ //imprime cada movimiento que se hace

          printf("%d, ", entrada[j]);
        }
        printf("\n");
    }

}

void imprime(int entrada[], int size) //imprime el array entrada de manera ordenada
{
    int i;
    for (i=0; i < size; i++)
        printf("%d ", entrada[i]);
    printf("\n");
}


int main()
{
    int entrada[] = {20, 5, 21, 6, 23, 7, 34, 999,68};
    int n = sizeof(entrada)/sizeof(entrada[0]);
    selectionSort(entrada, n);
    printf("O R D E N A D O: \n");
    imprime(entrada, n);
    return 0;
}

# 1. Buscar el numero menor en mi array.
# 2. Crear dos subarrays para llevar el control de mi algoritmo.
# 3. Imprimir el resultado del ordenamiento.

import sys
array = [20, 5, 21, 6, 23, 7, 34, 999, 68]

def selcctionSort(array):
    # recorrer todo nuestro array
    for i in range(len(array)):

        print(array)

        #Encontrar el valor minimo restante dentro de nuestro array desordenado
        idxDes = i
        for j in range(i+1, len(array)):
            if array[idxDes] > array[j]:
                idxDes = j

        # ya q encontramos el minimo lo vamos a cambiar
        # por el primer valor de nuestro array desordenado
        array[i], array[idxDes] = array[idxDes], array[i]

#ejecutar la funcion

selcctionSort(array)
# print(array)
print("Array Ordenado: ")
for i in range(len(array)):
    print("%d" %array[i]),

#Buscar el numero menor en mi array 
#Crear dos subarrays para llevar el contro de mi algoritmo
#Imprmir el resultado del ordenamiento
import sys
array = [20,5,21,6,23,7,34,999,68]

def selectionSort(array):

    #Recorrer todo nuestro array
    for i in range(len(array)):
        print(array)
        #Encontrar el valor minimo restante dentro de nuestro array desordenado
        idxDes = i
        for j in range(i+1, len(array)):
            if array[idxDes]> array[j]:
                idxDes = j
            
        
        #Ya que encontramos el minimo lo vamos a cambiar 
        # por el valor de nuestro array desordenado
        array[i], array[idxDes] = array[idxDes], array[i]

#ejecutamos la fncion
selectionSort(array)

print("El arreglo ordenado de forma Ascendente es: ")
for i in range(len(array)):
    print("%d"%array[i]),```
def selection_sort():
    data = [20, 5, 21, 6, 23, 7, 34, 999, 68]
    print("data original: " + str(data))
    for i in range(len(data)):
        indice_del_menor = i
        for j in range(i + 1,  len(data)):
            if data[j] < data[indice_del_menor]:
                indice_del_menor = j
        data[i], data[indice_del_menor] = data[indice_del_menor], data[i]
        print(data)


if __name__ == "__main__":
    selection_sort()```
"""
    Search the minor number in the array
    Create two sub arrays For controling the algorithm
    Print the result array
"""
import random


def selection_sort(arr):
        
    # recorer todo el arrray
    for i in range(len(arr)):
        min_idx = i
        print(arr)
        for j in range(i+1, len(arr)):
            if arr[min_idx] > arr[j]:
                min_idx = j
            

        # applaying changes to minimun value
        arr[i], arr[min_idx] = arr[min_idx], arr[i]


def selection_max_sort(arr):
        
    # recorer todo el arrray
    for i in range(len(arr)):
        max_idx = i
        print(arr)
        for j in range(i+1, len(arr)):
            if arr[max_idx] < arr[j]:
                max_idx = j
            

        # applaying changes to minimun value
        arr[i], arr[max_idx] = arr[max_idx], arr[i]


if __name__ == "__main__":
    arr = [random.randint(0, 100) for _ in range(10)]
    selection_sort(arr)
    print("*"*40)
    selection_max_sort(arr)
import random

def run(num):
    lista = [random.randint(0, 100) for i in range(num)]
    print(lista)

    for a in range(len(lista) - 1):
        c = a
        for i in range(a+1, len(lista)):
            if lista[c] < lista[i]:
                c = i
        lista[a], lista[c] = lista[c], lista[a]
    print(lista)


if __name__ == '__main__':
    num = int(input('Cuantos numeros necesitas: '))
    run(num)

Mi versi贸n del reto

import random

limite = 10
array = [random.randint(0, limite) for i in range(limite)]

for i in range(len(array)):
    auxIndex = i
    for j in range(i + 1, len(array)):
        if array[auxIndex] > array[j]:
            auxIndex = j
    print (f'{i}: {array}')
    array[i], array[auxIndex] = array[auxIndex], array[i]

print(f'Resultado: {array}')

Con eso obtuve la sgte salida:

0: [10, 8, 9, 1, 9, 10, 1, 0, 2, 0]
1: [0, 8, 9, 1, 9, 10, 1, 10, 2, 0]
2: [0, 0, 9, 1, 9, 10, 1, 10, 2, 8]
3: [0, 0, 1, 9, 9, 10, 1, 10, 2, 8]
4: [0, 0, 1, 1, 9, 10, 9, 10, 2, 8]
5: [0, 0, 1, 1, 2, 10, 9, 10, 9, 8]
6: [0, 0, 1, 1, 2, 8, 9, 10, 9, 10]
7: [0, 0, 1, 1, 2, 8, 9, 10, 9, 10]
8: [0, 0, 1, 1, 2, 8, 9, 9, 10, 10]
9: [0, 0, 1, 1, 2, 8, 9, 9, 10, 10]
Resultado: [0, 0, 1, 1, 2, 8, 9, 9, 10, 10]

PD: no es necesario importar sys

Tenemos varios ciclos dentro de nuestro Selection Sort, por lo que tenemos que ir comparando el resto de los elementos aparte del principal seleccionado.

<h3>El algoritmo en otros lenguajes:</h3>
  • JS
const selectionSort = (array) => {
    for(let i = 0; i < array.length; i++) {

        let indexDes = i;
        let actualValue = array[i];

        for (let j = i + 1; j < array.length; j++) {
            if (array[indexDes] > array[j])
            {
                indexDes = j;
            }
        }

        if (indexDes != i)
        {
            let nextValue = array[indexDes];

            array[i] = nextValue;
            array[indexDes] = actualValue;
        }
    }

    return array;
}

const main = () => {
    const array = [20, 5, 21, 6, 23, 7, 34, 999, 68];

    console.log("El arreglo desordenado es:");
    console.log(array);

    console.log("El arreglo ordenado de forma ascendente es: ");
    console.log(selectionSort(array));
}

main();

  • C
#include <stdlib.h>
#include <stdio.h>

#define ARRAY_SIZE 9

void selectionSort(int *array[ARRAY_SIZE])
{
    for(int i = 0; i < ARRAY_SIZE - 1; i++)
    {
        int indexDes = i;
        int * actualValue = array[i];
        

        for(int j = i + 1; j < ARRAY_SIZE; j++)
        {
            if (array[indexDes] > array[j])
            {
                indexDes = j;
            }
        }
        
        if (indexDes != i)
        {
            int * nextValue = array[indexDes];

            array[i] = nextValue;
            array[indexDes] = actualValue;
        }
    }
}

void printArray(int array[ARRAY_SIZE])
{
    for(int i = 0; i < ARRAY_SIZE; i++)
    {
        printf("%d, ", array[i]);
    }
}

int main()
{
    int array[ARRAY_SIZE] = {20, 5, 21, 6, 23, 7, 34, 999, 68};
    printf("\nEl arreglo desordenado es: \n");
    printArray(array);
    
    selectionSort(&array);
    printf("\nEl arreglo ordenado de forma ascendente es: \n");
    printArray(array);

    return 0;
}

C贸digo en C:

#include <stdio.h>

void swap(int *xp, int *yp)
{
    int temp = *xp;
    *xp = *yp;
    *yp = temp;
}



/* Function to print an array */
void printArray(int arr[], int size)
{
    int i;
    for (i=0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
}


void selectionSort(int arr[], int n)
{
    int i, j, min_idx;

    // One by one move boundary of unsorted subarray
    for (i = 0; i < n-1; i++)
    {
        // Find the minimum element in unsorted array
        printf("ITERACION[%d]: ", i);
        printArray(arr, n);
        min_idx = i;
        for (j = i+1; j < n; j++)
          if (arr[j] < arr[min_idx])
            min_idx = j;

        // Swap the found minimum element with the first element
        swap(&arr[min_idx], &arr[i]);
    }
}


// Driver program to test above functions
int main()
{
    int arr[] = {64, 25, 12, 22, 11};
    int n = sizeof(arr)/sizeof(arr[0]);
    selectionSort(arr, n);
    printf("\n\n\nArreglo de menor a mayor: \n");
    printArray(arr, n);
    return 0;
}

Se recorre el array original buscando el valor m铆nimo y ese valor 鈥渓o enviamos a un nuevo array鈥 con el fin de ir creando un array ordenado, el sub-array.(Es el mismo array solo que se dice que es otro array ordenado ,para que se entienda)

public class SelectionSort {

	public static  int[] sort(int[] array) {
		for (int i = 0; i < array.length; i++) {
			System.out.println("ciclo"+i);
			lecture(array);
			int desorderIndex=i;
			for (int j = i+1; j < array.length; j++) {
				if (array[desorderIndex] > array[j]) {
					desorderIndex=j;
				
				}
			}
			swap(array, i, desorderIndex);
		}
		return array;
	}
	
	public static void swap(int [] arrayInChange,int firstIndexInChange, int secondIndexInChange) {
		int aux=arrayInChange[firstIndexInChange];
		arrayInChange[firstIndexInChange]=arrayInChange[secondIndexInChange];
		arrayInChange[secondIndexInChange]=aux;
	}
	
	public static void lecture(int[] array) {
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
	}
}

C贸digo en C#. Disculpen el desorden 馃槮

       static void SelectionSort(int[] arreglo)
        {

            int n = arreglo.Length;
            int indice = 0;
            int aux = 0;

            foreach (var item in arreglo)
            {
                Console.Write(item + " ");
            }
            Console.WriteLine();

            // Recorrer el arreglo
            for (int i = 0; i < n; i++)
            {
                // Encontrar el valor m铆nimo restante dentro de nuestro array desordenado.
                // siempre debemos recordar el 铆ndice del array desordenado.
                Console.WriteLine($"    i =    {i}");
                indice = i;
                for (int j = i+1; j < n; j++)
                {
                    Console.WriteLine($"indice[{indice}]=> {arreglo[indice]} > j[{j}]=> {arreglo[j]} ====> {arreglo[indice] > arreglo[j]} ");
                    if (arreglo[indice] > arreglo[j])
                    {
                        indice = j;
                    }
                }

                // ya que encontramos el m铆nimo lo vamos a cambiar por el valor de nuestro
                // array desordenado. Aqu铆 se hace el swap.
                aux = arreglo[i];
                arreglo[i] = arreglo[indice];
                arreglo[indice] = aux;

                foreach (var item in arreglo)
                {
                    Console.Write(item + " ");
                }
                Console.WriteLine();
            }

            Console.WriteLine("Bucle Ordenado: ");
            foreach (var item in arreglo)
            {
                Console.Write(item + " ");
            }
            Console.ReadLine();
        }

Aqu铆 mi aporte en java. cuando lo realice lo pude entender mejor, se reciben criticas a que puedo mejor. 馃槂


public class Solution {

    public static void main(String[] args) {

        Integer[] myArray = {20,10,154,78,956,2,30,30,45,78,95,141,85,456,1558,45,66,98,895,525,654};
        int lengthMyArray = myArray.length;
        int higherValue;
        int index;
        for(int i = 0;i<lengthMyArray;i++){
            higherValue = myArray[i];
            index = i;
            for(int j = i; j < lengthMyArray; j++){
               if(myArray[j] > higherValue){
                   higherValue = myArray[j];
                   index = j;
               }
            }
            myArray[index] = myArray[i];
            myArray[i] = higherValue;

        }

        for(int i = 0;i<lengthMyArray;i++) {
                System.out.print(myArray[i] + " " );
        }
    }
}

RETO:

def selection_sort_asc(lista):
    for i in range(len(lista)):
        idxDes = i
        for j in range(i+1,len(lista)):
            if lista[idxDes] > lista[j]:
                # print(f'{lista[idxDes]} es mayor {lista[j]}')
                # idxDes = j
                print(lista)
        lista[i],lista[idxDes] = lista[idxDes],lista[i]


def selection_sort_des(lista):
    for i in range(len(lista)):
        idxDes = i
        for j in range(i+1,len(lista)):
            if lista[idxDes] < lista[j]:
                idxDes = j
        lista[i],lista[idxDes] = lista[idxDes],lista[i]


def main():
    num_des = [12,3,6,487,123,967,34,5,756]
    selection_sort_asc(num_des)
    print(f'Los numeros ordenados de menor a mayor son:\n{num_des}\n')
    selection_sort_des(num_des)
    print(f'Los numeros ordenados de mayor a menor son:\n{num_des}')


if __name__ == '__main__':
    main()

coloque el print en el primer for.

def selectionsort(array):
    #recorrer todo nuestro array
    for i in range(len(array)):
        print(array)```

SOLUCION DE RETO Y CODIGO EN JS

const selectionSort = (array) => {
    for(let i = 0; i < array.length; i++) {
        let index = i
        console.log(array)
        for(let j = i + 1; j < array.length; j++) {
            if(array[index] > array[j]) {
                index = j
            }
        }
        let temp = array[i]
        array[i] = array[index]
        array[index] = temp
    }
    return array
}

const array = [20, 5, 21, 6, 23, 7, 34, 999, 68]

console.log(selectionSort(array))

Reto completado:

#1. Buscar el numero menor en mi array
#2. Crear dos subarrays para llevar el control de mi algoritmo
import sys
array = [20,5,21,6,23,7,35,999,68]

def selectionSort(array):
    for i in range(len(array)):
        #Encontrar el valor m铆nimo restante dentro de nuestro array desordenado
        print(array)
        idxDes = i
        for j in range(i+1,len(array)):
            if array[idxDes] > array[j]:
                idxDes = j
        #ya que encontramos el minimo lo vamos a 
        #cambiar por el primer valor de nuestro array desordenado
        array[i],array[idxDes] = array[idxDes],array[i]

#ejecutar la funcion

selectionSort(array)

print("Array Ordenado: ")

for i in range(len(array)):
    print("%d"%array[i]),```

selection sort en C

#include <stdio.h>

int indexmin;
int array[]={20,5,21,6,23,7,34,999,68};
int sizeArray = sizeof(array)/sizeof(array[0]);

void check(){
    for(int i = 0 ; i < sizeArray;i++){
        printf("%d, ",array[i]);  
    }
    printf("\n");
}

void selection_Sort(int array[]){
    for(int i = 0; i< sizeArray;i++){
        indexmin = i;
        check();
        for(int j = i+1; j<sizeArray;j++){
            if(array[indexmin] > array[j]){
                indexmin = j;
            }
        }
        
        int aux = array[i];
        array[i] = array[indexmin];
        array[indexmin] = aux;
    }

}

int main(){

    selection_Sort(array);
    printf("arreglo ordenado: \n");
    check();
    return 0;
}```

Ejemplo del Selection Sort en C++

#include <iostream>

using namespace std;

int main()
{
    int n = 7;
    int vector[7] = {3, 1, 45, 16, 50, 6, 0};
    
    int minValue = 0;
    
    for(int i = 0; i < n-1; i++){
        
        minValue = i;
        
        for(int j = n-1; j >= i+1; j--)
        {
            if(vector[j] < vector[minValue])
            {
                minValue = j;
            }
        }
        
        int var = vector[i];
        vector[i] = vector[minValue];
        vector[minValue] = var;
        
    }
     
    //Print array values
    for(int i = 0; i <= n-1; i++)
    {
        cout << vector[i] << " ";

    }
    
}```

De esta manera qued贸 el c贸digo con la impresi贸n del array a medida que se va arreglando. Adem谩s lo coloco de manera que ordene de mayor a menor.

# Buscar el numero menor en mi array
# Crear dos sub arrays para llevar el control de mi algoritmo
# Imprimir el resultado del ordenamiento.

import sys
array = [20, 5, 21, 6, 23, 7, 34, 999, 68]


def selection_sort(array):
    # Recorrer todo nuestro array
    for i in range(len(array)):

        # Encontrar el valor minimo restante dentro de nuestro array desordenado
        idxdes = i
        for j in range(i+1, len(array)):
            if array[idxdes] < array[j]:
                idxdes = j
        print(f'{array}')
        # Ya que encontramos el minimo lo cambiamos por el primer valor de nuestro array desordenado

        array[i], array[idxdes] = array[idxdes], arraya[i]


# ejecutar la funcion
selection_sort(array)
print(f'The sorted array:')
for i in range(len(array)):
    print(f'{array[i]}')

Y nos da el siguiente Output:

[20, 5, 21, 6, 23, 7, 34, 999, 68]
[999, 5, 21, 6, 23, 7, 34, 20, 68]
[999, 68, 21, 6, 23, 7, 34, 20, 5]
[999, 68, 34, 6, 23, 7, 21, 20, 5]
[999, 68, 34, 23, 6, 7, 21, 20, 5]
[999, 68, 34, 23, 21, 7, 6, 20, 5]
[999, 68, 34, 23, 21, 20, 6, 7, 5]
[999, 68, 34, 23, 21, 20, 7, 6, 5]
[999, 68, 34, 23, 21, 20, 7, 6, 5]
The sorted array:
999
68
34
23
21
20
7
6
5

S铆 me funcion贸, interesante el tema de Python, supongo que en un tiempo lo revisar茅, pero no por el momento.

Les comparto mi c贸digo:

#1.Buscar el numero menor en mi array
#2. Crear dos subarrays para llevar el control de mi algoritmo
#imprimir el resultado del ordenamiento
import sys
array=[200,5,23,21,7,999,68]
def selectionSort(array):
    #recorrer todo nuestro array
    for i in range(len(array)):

        #Encontrar el valor m铆nimo restante dentro
        #de nuestro array desordenado
        idxDes=i
        for j in range(i+1, len(array)):
            if array[idxDes]>array[j]:
                idxDes=j
        #ya que encontramos el minimo, lo vamos a cambiar
        #por el primer valor de nuestro array desordenado
        array[i],array[idxDes]=array[idxDes],array[i]

selectionSort(array)
print("Sorted array:")
for i in range(len(array)):
    print("%d"%array[i]),
#Buscar el numero menor en mi array
#Crear dos sub-arrays para llevar el control de mi algoritmo
#Imprimir el resultado del 
import sys

array = [20, 5, 21, 6, 23,1200,1000, 34, 89,  69, 72, 100]

def selectionSort(array):
    #Este for recorre todo nuestro array
    for i in range(len(array)):
        #Encontrar el valor minimo dentro del array desordenado
        indexDes = i
        for j in range(i+1, len(array)):
            if array[indexDes] > array[j]:
                indexDes = j
            print("%d"%array[j])

        #Despues de encontrar el valor minimo lo cambiamos por
        # el primer valor del array desordenado
        array[i], array[indexDes] = array[indexDes], array[i]
        print("%d"%array[i])
#Ejecutar la funcion
selectionSort(array)
print("Array Ordenado: ")
for i in range(len(array)):
    print("%d" %array[i])

listo ya copie del codigo del profesor 馃槂

![](

![](

#Buscar el numero menor en mi array
#Crear dos subarrays para llevar el control de mi algoritmo
import sys
array = [20,21,23,34,68,7, 34,999,68]
def selectionSort(array):
#Recorrer todo nuestro array
for i in range(len(array)):
print(array)
#Encontrar el valor minimo restante dentro de nuestro array desordenado
idxDes = i
for j in range(i+1, len(array)):
if array[idxDes] > array[j]:
idxDes = j

    #Ya que encontramos lo vamos a cambiar por el primer valor de nuestro array
    #por el primer valor de nuestro array desordenado
    array[i], array[idxDes] = array[idxDes], array[i]

#ejecutar la funcion

selectionSort(array)
print(鈥淎rray Ordenado:鈥)
for i in range(len(array)):
print("%d" %array[i]),

Es fascinante como trabajan los array anidados, de esta manera se logra ver paso por paso el print statement es muy util

array = [20, 34, 68, 799, 100, 21, 23, ]


def selectionSort(array):
    # recorrer todo nuestro array
    for i in range(len(array)):
        print(f""" 
        Array principal{array} """)
        # encontrar el valor minimo restante dentro del array desordenado
        idxdes = i  # auxiliar para decir el indice del array desordenado
        for j in range(i+1, len(array)):
            if array[idxdes] > array[j]:
                idxdes = j
                print(f"""
                Array secundario{array} """)
        # ya que encontramos el minimo lo vamos a cambiar por el primer valor de neustro array desordenado
        array[i], array[idxdes] = array[idxdes], array[i]


# ejecutar la funcion
selectionSort(array)
print("""

Array ordernado:""")
for i in range(len(array)):
    print(array[i])