plan cul gratuit - plan cul toulouse - voyance gratuite amour

PSeint – Ordenar vectores de forma ascendente y descendente

En esta ocasión, vamos a desarrollar un algoritmo que nos permita ordenar un vector aleatorio tanto de manera descendente como ascendente, y como base tomaremos a PSeint que es una herramienta práctica, ligera y no necesitamos grandes recursos para su ejecución. Finalmente,  la  gran ventaja de usar Pseint  es que permite exportar el código generado a manera de pseudocódigo, a otros lenguajes más complejos de programación.

Los vectores son un tema clásico e importante dentro de la programación por su gran versatilidad, es por ello que entender su uso es de gran importancia para todo programador.

¿ Qué es un vector en programación?

Es  común  confundir el termino de vector usado en física, con el vector que se usa en la programación. Para ello es importante definir lo que es un Array o arreglo, el cual es el termino que se suele emplear en la programación para un vector de manera continua. En este orden de ideas, un vector es una zona que nos permite almacenar una serie de datos que han de ser del mismo tipo.

No podemos encontrar un vector de enteros que contenga datos de tipo string, ya que la particularidad de este tipo de almacenamiento, es que ha de mantener de manera constante el tipo de dato a almacenar.

A continuación vemos un vector de dimensión [2], ya que el índice por lo general en cada uno de los diferentes lenguajes de programación inicia desde cero, sus datos son de tipo entero y la variable como vector estará declarado por la letra (A).

vector programacion concepto pseint

A su vez, cuando se quiere hacer referencia al valor contenido en nuestro vector siempre recurrimos a nuestros índices. Lo que quiere decir que si queremos tener acceso al dato 33 de nuestro vector, debemos hacer referencia a A[0] y este nos traerá el numero 33, y así sucesivamente con los demás valores.

Pasos para crear un algoritmo en PSeint que ordene un  Vector Aleatorio

Una vez que tenemos claro el concepto de lo que son los vectores en la programación, es hora de entrar en detalle de como crear el algoritmo que tiene como función el ordenar un vector aleatorio, de n elementos, el cual este número de elementos será declarado por el usuario.

Entonces, el enunciado de nuestra situación problema es la siguiente:

Elaborar un algoritmo que genere un vector de una dimensión dada por el usuario, y que este genere datos aleatorios de (0 a 999). Luego que lo pueda ordenar de manera ascendente o descendente.

Paso 1: Definir las variables que usaremos junto el vector

En este caso usaremos solo variables enteras en donde el vector será nuestra variable de tipo array, las variables i, j serán los índices con los que trabajaremos el vector, la variable min se encargara de establecer el índice de los datos ya sean mayores o menores, y por ultimo la variable aux se encargara de crear un respaldo a aquel número que queremos ir ordenando.

Definir vector, i,j, N, min, aux como entero;

Paso 2: Preguntar al usuario la dimensión del vector a implementar

En este paso lo que realiza, es preguntar al usuario cuantos datos desea procesar y a su vez esta ser la medida establecida para la dimensión del vector. Recordemos que la dimensión del vector (N) es la cantidad máxima de los datos que se trabajaran.

Escribir Sin Saltar "Ingrese la cantidad de datos a procesar: ";	
Leer N;	
dimension vector[N]		
Escribir "El vector original es:"; 	
para i <- 1 hasta N con paso 1 Hacer
	 vector[i] <-azar(1000);
     Escribir sin Saltar vector[i] " ";	
FinPara
Escribir "";

Paso 3: Implementar el algoritmo para ordenar el vector aleatorio

A continuación establecemos una  de las partes más importante de nuestro algoritmo, y es que en este momento se establece el ordenamiento del vector ya sea de manera ascendente o descendente, para ello solo basta con cambiar el signo (<) o (>), en la línea: Si vector[j] < vector[min] Entonces .

Por otra parte, lo que hace este algoritmo es iniciar a comparar el primer elemento del vector  con cada uno de los demás elementos, y si encontramos un dato menor o mayor  en relación con los elementos restantes, este pasara a asumir dicha posición. Luego, pasaremos al segundo elemento comparándolo con el tercer, cuarto, hasta el elemento N, y así sucesivamente hasta avanzar hasta el elemento N-1.

Es importante mencionar que la línea: Para j<-i+1 Hasta N Con Paso 1 Hacer nos permite determinar la comparación de los elementos restantes a partir del índice i+1. Con este contador, siempre encontrarás el elemento más menor o mayor de los elementos restantes.


para i <- 1 hasta N con paso 1 Hacer       
		
    min <- i;  	
    Para j<-i+1 Hasta N Con Paso 1 Hacer           
	   Si vector[j] < vector[min] Entonces  //con < ordena ascendente, con > ordena descendente				
         min <- j;				
       Fin Si	
     FinPara       
	 aux <- vector[i];
	 vector[i] <- vector[min];
	 vector[min] <- aux;       
FinPara

Paso 4: Imprimir el vector ordenado

Una vez que ordenamos el vector, entonces procedemos a imprimir  de la siguiente manera con nuestro ciclo para, avanzando de 1 en 1 nuestro índice. Puedes notar que usamos Escribir Sin Saltar con el objetivo de imprimir nuestro vector de forma horizontal, y la parte que aparece como ”  “ nos permite establecer el espacio entre los elementos y hacer que estos no queden unidos.

Escribir "El vector ordenado es:";
para i <- 1 hasta N con paso 1 Hacer	
	Escribir Sin Saltar vector[i] " ";
FinPara

Código Completo y Ejecución de nuestro Algoritmo

Finalmente, se anexa el algoritmo en su totalidad para que pueda copiarlo y correrlo con detenimiento, analizando cada una de las partes que hemos desarrollado para su ejecución.

Algoritmo vectores_ordenar
 Definir vector, i,j, N, min, aux como entero;		
 Escribir Sin Saltar "Ingrese la cantidad de datos a procesar: ";
 Leer N;
 dimension vector[N]	
 Escribir "El vector original es:";
 para i <- 1 hasta N con paso 1 Hacer       
   vector[i] <-azar(1000);
   Escribir sin Saltar vector[i] " ";       
 FinPara
 Escribir "";
 para i <- 1 hasta N con paso 1 Hacer       
   min <- i;       
   Para j<-i+1 Hasta N Con Paso 1 Hacer           
     Si vector[j] < vector[min] Entonces    //con < ordena ascendente, con > ordena descendente
        min <- j;
     Fin Si           
   FinPara       
   aux <- vector[i];
   vector[i] <- vector[min];
   vector[min] <- aux;       
 FinPara
 Escribir "El vector ordenado es:";
 para i <- 1 hasta N con paso 1 Hacer       
   Escribir Sin Saltar vector[i] " ";       
 FinPara
FinAlgoritmo

Luego, al ejecutar nuestro algoritmo para el caso de N=15 tenemos el siguiente comportamiento:

PSeint algoritmo ordenar vectores

Artículos Relacionados