- Vectores (ordenamiento con vectores paralelos)

Cuando se tienen vectores paralelos y se ordena uno de ellos hay que tener la precaución de intercambiar los elementos de los vectores paralelos.

Problema 1:

Confeccionar un programa que permita cargar los nombres de 5 alumnos y sus notas respectivas. Luego ordenar las notas de mayor a menor. Imprimir las notas y los nombres de los alumnos.

Programa:

import java.util.Scanner;
public class PruebaVector16 {
    private Scanner teclado;
    private String[] nombres;
    private int[] notas;
    
    public void cargar() {
        teclado=new Scanner(System.in);
        nombres=new String[5];
        notas=new int[5];
        System.out.println("Carga de nombres y notas");
        for(int f=0;f<nombres.length;f++) {
            System.out.print("Ingese el nombre del alumno:");
            nombres[f]=teclado.next();
            System.out.print("Ingrese la nota del alumno:");
            notas[f]=teclado.nextInt();
        }
    }        
    
    public void ordenar() {
        for(int k=0;k<notas.length;k++) {
            for(int f=0;f<notas.length-1-k;f++) {
                if (notas[f]<notas[f+1]) {
                    int auxnota;
                    auxnota=notas[f];
                    notas[f]=notas[f+1];
                    notas[f+1]=auxnota;
                    String auxnombre;
                    auxnombre=nombres[f];
                    nombres[f]=nombres[f+1];
                    nombres[f+1]=auxnombre;
                }
            }
        }
    }
        
    public void imprimir() {
   	System.out.println("Nombres de alumnos y notas de mayor a menor");
        for(int f=0;f<notas.length;f++) {
            System.out.println(nombres[f] + " - " + notas[f]);
        }
    }        

    public static void main(String[] ar) {
        PruebaVector16 pv=new PruebaVector16();
        pv.cargar();
        pv.ordenar();
        pv.imprimir();
    }  	
}

Definimos los dos vectores:

    private String[] nombres;
    private int[] notas;

Creamos los dos vectores paralelos con cinco elementos cada uno:

        nombres=new String[5];
        notas=new int[5];

En el proceso de ordenamiento dentro de los dos for verificamos si debemos intercambiar los elementos del vector notas:

        for(int k=0;k<notas.length;k++) {
            for(int f=0;f<notas.length-1-k;f++) {
                if (notas[f]<notas[f+1]) {

En el caso que la nota de la posición 'f' sea menor a de la posición siguiente 'f+1' procedemos a intercambiar las notas:

                    int auxnota;
                    auxnota=notas[f];
                    notas[f]=notas[f+1];
                    notas[f+1]=auxnota;

y simultánemamente procedemos a intercambiar los elementos del vector paralelo (con esto logramos que los dos vectores continuen siendo vectores paralelos):

                    String auxnombre;
                    auxnombre=nombres[f];
                    nombres[f]=nombres[f+1];
                    nombres[f+1]=auxnombre;

Como vemos utilizamos dos auxiliares distintos porque los elementos de los dos vectores son de distinto tipo (int y String)

Si deseamos ordenar alfabéticamente la condición dependerá del vector nombres.

Problemas propuestos

1. Cargar en un vector los nombres de 5 paises y en otro vector paralelo la cantidad de habitantes del mismo. Ordenar alfabéticamente e imprimir los resultados. Por último ordenar con respecto a la cantidad de habitantes (de mayor a menor) e imprimir nuevamente.

Solución

import java.util.Scanner;
public class PruebaVector17 {
    private Scanner teclado;
	private String[] paises;
    private int[] habitantes;
    
    public void cargar() {
        teclado=new Scanner(System.in);
        paises=new String[5];
        habitantes=new int[5];
        System.out.println("Carga de paises y habitantes");
        for(int f=0;f<paises.length;f++) {
            System.out.print("Ingese el nombre del pais:");
            paises[f]=teclado.next();
            System.out.print("Ingrese la cantidad de habitantes:");
            habitantes[f]=teclado.nextInt();
        }
    }        
    
    public void ordenarPorNombres() {
        for(int k=0;k<paises.length;k++) {
            for(int f=0;f<paises.length-1-k;f++) {
                if (paises[f].compareTo(paises[f+1])>0) {
                    String auxpais;
                    auxpais=paises[f];
                    paises[f]=paises[f+1];
                    paises[f+1]=auxpais;
                    int auxhabitante;
                    auxhabitante=habitantes[f];
                    habitantes[f]=habitantes[f+1];
                    habitantes[f+1]=auxhabitante;
                }
            }
        }
    }
        
    public void ordenarPorHabitantes() {
        for(int k=0;k<paises.length;k++) {
            for(int f=0;f<paises.length-1-k;f++) {
                if (habitantes[f]<habitantes[f+1]) {
                    String auxpais;
                    auxpais=paises[f];
                    paises[f]=paises[f+1];
                    paises[f+1]=auxpais;
                    int auxhabitante;
                    auxhabitante=habitantes[f];
                    habitantes[f]=habitantes[f+1];
                    habitantes[f+1]=auxhabitante;
                }
            }
        }
    }
    
    public void imprimir() {
        for(int f=0;f<paises.length;f++) {
            System.out.println(paises[f] + " - " + habitantes[f]);
        }
    }        

    public static void main(String[] ar) {
        PruebaVector17 pv=new PruebaVector17();
        pv.cargar();
        pv.ordenarPorNombres();
 	    System.out.println("Ordenados alfabéticamente");
        pv.imprimir();
        pv.ordenarPorHabitantes();
 	    System.out.println("Ordenados por cantidad de habitnates");        
        pv.imprimir();
    }  	
}