UNIVERSIDAD MAYOR DE SAN ANDRES

Facultad de Ciencias Puras y Naturales

Carrera de Informática
Nombres y Apellidos: Eddy Gonzalo Ortiz Machicado Cedula de Identidad: 3469141 Lp.
Materia: Lab-131 Paralelo: B
Fecha: 15/Marzo/2023 Gestión: I - 2023
Docente: Lic. Victoria Hurtado Cerruto
Tema: Estructura de Datos (Colas Simples, Colas Circulares)

PRACTICA N° 3
EJERCICIO 1
a) Enunciado
Dado un Cola Simple de Empleados<carnet, nombre, cargo, sueldo, edad>
a) Mostrar quienes ganan mas
b) Cuál es la edad promedio
c) Considerando que los Empleados están ordenados por Inicial de su nombre se pide ordenar
un nuevo empleado conservando el orden.

b) Diagrama de Clases

Empleado
- carnet: String
- nombre: String
- cargo: String
- sueldo: double
-edad: int

+ entero()
+ entero(carnet,nombre,cargo,sueldo, edad )
+ getters()
+ setters()
+ leerE():void
+ mostrarE():void
+ leerE(): void
+ mostrarE():void CSimpleEmpleados
- max: int
- ini: int
- fin: int
- v[max+1]: Empleado
+ CSimpleEmpleados()
+ esVacia(): boolean
+ esLlena(): boolean
+ nroElem():void
+ adicionar(it:entero): void
+ eliminar: Entero
+ llenar():void
+ mostrar(): void
+ vaciar(z:
CSimpleEmpleados):void
 c) Codigo JAVA
Main
public class Main {
public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);
CSimpleEmpleados ce = new CSimpleEmpleados();

// CARGAR COLA SIMPLE DE EMPLEADOS

cargarColaEmpelados(ce);
ce.mostrar();

/*Dado un Cola Simple de Empleados<carnet, nombre, cargo, sueldo,

edad>

* a) Mostrar quienes Ganan Mas*/

System.out.println("\n.....................................................
................................");
System.out.println(".................................... SOLUCION A
.....................................");
solucionA(ce);

System.out.println(".......................................................
..............................");

/* b) Cual es la Edad Promedio?*/

System.out.println("\n.....................................................
................................");
System.out.println(".................................... SOLUCION B
.....................................");
solucionB(ce);

System.out.println(".......................................................
..............................");

/* c) Considerando que los Empleados estan ordenados por Inicial de

su nombre se pide ordenar un nuevo empleado
* conservando el orden.
* */

System.out.println("\n.....................................................
................................");
System.out.println(".................................... SOLUCION C
.....................................");
solucionC(ce);
ce.mostrar();

System.out.println(".......................................................
..............................");

// METODO PARA CARGAR COLA SIMPLE

private static void cargarColaEmpelados(CSimpleEmpleados CE) {
CE.adicionar(new Empleado("3469141", "Eddy", "Ing. Sistemas", 4000,
27));
 CE.adicionar(new Empleado("2211441", "Pedro", "Seguridad", 3500,
47));
CE.adicionar(new Empleado("4304562", "Carlos", "Chofer", 2100, 24));
CE.adicionar(new Empleado("2370878", "Rufina", "Cocinera", 2600,
27));
CE.adicionar(new Empleado("2345685", "Yazid", "Mensajero", 1500,
18));
CE.adicionar(new Empleado("5632452", "Jose", "J. Operaciones", 10000,
41));
CE.adicionar(new Empleado("25647852", "Juan", "Director", 12000,
50));
CE.adicionar(new Empleado("48975622", "Gonzalo", "Chofer", 2400,
25));
CE.adicionar(new Empleado("24579524", "Wendy", "Secretaria", 3000,
30));
CE.adicionar(new Empleado("78952421", "Karen", "RR.HH.", 6000, 32));

// SOLUCION A
private static void solucionA(CSimpleEmpleados CE) {
int x=CE.nroElem();
int n=((x/2)+1);

ordenarCola(CE);

CSimpleEmpleados aux = new CSimpleEmpleados();

CSimpleEmpleados R = new CSimpleEmpleados();

aux.vaciar((copiarCola(CE)));
R.vaciar(aux);

System.out.println("---> LIBROS MAYOR PRECIO <---");

while(R.nroElem()!=n) {
Empleado elem;
elem = R.eliminar();
System.out.println(elem);
aux.adicionar(elem);
}
R.vaciar(aux);
}

// FUNCION ORDENAR COLA

private static void ordenarCola(CSimpleEmpleados CE) {
CSimpleEmpleados aux = new CSimpleEmpleados();
CSimpleEmpleados R = new CSimpleEmpleados();

while(!CE.esVacia()) {
Empleado mayor = CE.eliminar();
while (!CE.esVacia()) {
Empleado elem = CE.eliminar();
if(elem.getSueldo() > mayor.getSueldo()) {
aux.adicionar(mayor);
mayor = elem;
}
else {
aux.adicionar(elem);
}
}
 CE.vaciar(aux);
R.adicionar(mayor);
}
CE.vaciar(R);
}

// COPIAR COLA
private static CSimpleEmpleados copiarCola(CSimpleEmpleados CE) {
CSimpleEmpleados aux1 = new CSimpleEmpleados();
CSimpleEmpleados aux2 = new CSimpleEmpleados();
CSimpleEmpleados copia = new CSimpleEmpleados();

while(!CE.esVacia()) {
Empleado elem = CE.eliminar();
aux1.adicionar(elem);
aux2.adicionar(elem);
}
CE.vaciar(aux1);
copia.vaciar(aux2);
return copia ;
}

// SOLUCION B
private static void solucionB(CSimpleEmpleados CE) {
int cant=CE.nroElem();
double total=0;

CSimpleEmpleados aux = new CSimpleEmpleados();

while(!CE.esVacia()) {
Empleado elem = CE.eliminar();
total=total+elem.getEdad();
aux.adicionar(elem);
}
CE.vaciar(aux);
double promedio=((total)/(cant));
System.out.println("PROMEDIO-EDAD: "+promedio);
}

// SOLUCION C
private static void solucionC(CSimpleEmpleados CE) {
ordenarColaNombre(CE);
Empleado e = new Empleado();
e.leerE();
CE.adicionar(e);
ordenarColaNombre(CE);
}

// METODO ORDENAR COLA POR ABECEDARIO

private static void ordenarColaNombre(CSimpleEmpleados CE) {
CSimpleEmpleados aux = new CSimpleEmpleados();
CSimpleEmpleados R = new CSimpleEmpleados();

while(!CE.esVacia()) {
Empleado vocal = CE.eliminar();
while(!CE.esVacia()) {
Empleado elem = CE.eliminar();

if(elem.getNombre().compareToIgnoreCase(vocal.getNombre())>0) {
 aux.adicionar(vocal);
vocal=elem;
}
else {
aux.adicionar(elem);
}
}
CE.vaciar(aux);
R.adicionar(vocal);
}
CE.vaciar(R);
}
}

Clase Empleado

public class Empleado {

private String carnet;
private String nombre;
private String cargo;
private double sueldo;
private int edad;

// Constructo por defecto

public Empleado() {
this.carnet = "";
this.nombre = "";
this.cargo = "";
this.sueldo = 0;
this.edad = 0;
}

// Constructor con parametros

public Empleado(String carnet, String nombre, String cargo, double sueldo,
int edad) {
super();
this.carnet = carnet;
this.nombre = nombre;
this.cargo = cargo;
this.sueldo = sueldo;
this.edad = edad;
}

// Getters y Setters
public String getCarnet() {
return carnet;
}

public void setCarnet(String carnet) {

this.carnet = carnet;
}

public String getNombre() {

return nombre;
}

public void setNombre(String nombre) {

this.nombre = nombre;
}
 public String getCargo() {
return cargo;
}

public void setCargo(String cargo) {

this.cargo = cargo;
}

public double getSueldo() {

return sueldo;
}

public void setSueldo(double sueldo) {

this.sueldo = sueldo;
}

public int getEdad() {

return edad;
}

public void setEdad(int edad) {

this.edad = edad;
}

// To String
@Override
public String toString() {
return "Empleado [carnet=" + carnet + ", nombre=" + nombre + ",
cargo=" + cargo + ", sueldo=" + sueldo + ", edad=" + edad + "]";
}

// Metodo Leer Empleado

public void leerE() {
Scanner teclado = new Scanner(System.in);
System.out.println("--------------> LEER-EMPELADO <---------------"
);

System.out.print("Carnet Identidad ---> ");

this.carnet = teclado.nextLine();

System.out.print("Nombre(s) ---> ");

this.nombre = teclado.nextLine();

System.out.print("Cargo ---> ");

this.cargo = teclado.nextLine();

System.out.print("Sueldo ---> ");

this.sueldo = teclado.nextDouble();

System.out.print("Edad ---> ");

this.edad = teclado.nextInt();
}

// Metodo mostrar Empleado

public void mostrarE() {
//System.out.println("--------------> MOSTRAR-EMPLEADO <-------------
--" );
 //System.out.println("*****************************************************
***************************" );
System.out.println(toString());
}
}

Clase CSimpleEmpleados

public class CSimpleEmpleados {

private int max = 100;
private Empleado v[] = new Empleado[max+1];
private int ini;
private int fin;

CSimpleEmpleados(){
ini=0;
fin=0;
}

boolean esVacia (){

if (ini == 0 && fin == 0) {
return (true);
}
else {
return (false);
}
}

boolean esLlena (){

if (fin == max) {
return (true);
}
else {
return (false);
}
}

int nroElem (){

int w = (fin - ini);
return (w);
}

void adicionar (Empleado elem){

if (!esLlena ()){
fin++; //v[fin+1]=elem;
v [fin] = elem; //fin++;
}
else {
System.out.println ("Cola Empleado llena");
}
}

Empleado eliminar (){

Empleado elem = new Empleado();
if (!esVacia ()){
ini++;
elem = v [ini];
if (ini == fin) {
 ini = fin = 0;
}
}
else {
System.out.println ("Cola Empleado vacia");
}
return (elem);
}

void mostrar (){

if(!esVacia()) {
System.out.println("\n---> Datos de la Cola Simple (Empleado (s)) <--
-");

System.out.println("*******************************************************
**********************************************");
CSimpleEmpleados aux = new CSimpleEmpleados();
while (!esVacia ()) {
Empleado elem = eliminar ();
elem.mostrarE();
aux.adicionar (elem);
}

System.out.println("*******************************************************
**********************************************");
vaciar(aux);
}
else {
System.out.println("Cola Simple vacia");
}
}

void vaciar (CSimpleEmpleados a){

while (!a.esVacia ()) {
adicionar(a.eliminar());
}
}

void llenar(Empleado W, int n) {

System.out.println("");
for(int i=1; i<=n; i++) {
Empleado elem = new Empleado();
elem.leerE();
adicionar(elem);
}
}
}
d) Prueba de Corrida
Cola Desordenada

Cola Desordenada
 a) Enunciado
Dados 2 Polinomios p(x) y q(x) almacenados en dos Colas Circulares simples hallar;
a) La suma
b) Producto de P(x) x Q(x)
b) Diagrama de Clases

Polinomio
- coeficiente: int
- exponente: int
+ Polinomio()
+ Polinomio(int, int)
+ getters()
+ setters()
+ leerE():void
+ toString():Srting
+ mostrarE():void

CSimplePolinomios
- max: int
- ini: int
- fin: int
- v[max+1]: Polinomio
+ CSimpleEmpleados()
+ esVacia(): boolean
+ esLlena(): boolean
+ nroElem():void
+ adicionar(Polinomio): void
+ eliminar: Polinomio
+ llenar():void
+ mostrar(): void
+ vaciar(z: CSimpleEmpleado):void
 c) Codigo JAVA
Main
public class ColaCircularPolinomio {
private int max=100;
private Polinomio v[]=new Polinomio[max+1];
private int ini,fin;

ColaCircularPolinomio(){
ini = 0;
fin = 0;
}

int nroElem (){

return ((max + fin - ini) % max);
}

boolean esVacia (){

if (nroElem () == 0) {
return (true);
}
else {
return (false);
}
}

boolean esLlena (){

if (nroElem () == max-1) {
return (true);
}
else {
return (false);
}
}

void adicionar (Polinomio elem){

if (!esLlena ()){
fin = (fin + 1) % max;
v [fin] = elem;
}
else {
System.out.println ("--> Cola Circular llena <--");
}
}

Polinomio eliminar (){

Polinomio elem = new Polinomio();
if (!esVacia ()){
ini = (ini + 1) % max;
elem = v [ini];
if (nroElem () == 0) {
ini = fin = 0;
}
}
else{
System.out.println ("--> Cola Circular llena <--");
}
return (elem);
}
 void mostrar (){
if (esVacia ()) {
System.out.println ("Cola vacia xxx");
}
else{
System.out.println("\n---> Datos de la Cola Circular (Polinomio) <---
");

System.out.println("*******************************************************
**********************************************");
ColaCircularPolinomio aux = new ColaCircularPolinomio ();
while (!esVacia ()){
Polinomio elem = eliminar ();
aux.adicionar (elem);
elem.mostrarP();
}

System.out.println("*******************************************************
**********************************************");
vaciar(aux);
}
}

void vaciar (ColaCircularPolinomio a){

while (!a.esVacia ()) {
adicionar (a.eliminar ());
}
}

void llenar (int n) {

System.out.println("Ingrese Dato(s) de la Cola");
for(int i=0;i<n;i++) {
Polinomio elem = new Polinomio();
elem.leerP();
adicionar(elem);
}
}

Clase Polinomio
public class Polinomio {
private int coeficiente;
private int exponente;

// Constructor por defecto

public Polinomio() {
this.coeficiente = 0;
this.exponente = 0;
}

// Constructor con parametros

public Polinomio(int coeficiente, int exponente) {
super();
this.coeficiente = coeficiente;
this.exponente = exponente;
}

// Getters y Setters
public int getCoeficiente() {
 return coeficiente;
}

public void setCoeficiente(int coeficiente) {

this.coeficiente = coeficiente;
}

public int getExponente() {

return exponente;
}

public void setExponente(int exponente) {

this.exponente = exponente;
}

// To String
@Override
public String toString() {
return "Polinomio [coeficiente=" + coeficiente + ", exponente="
+"X^"+ exponente + "]";
}

// Metodo Leer Polinomio

public void leerP() {
Scanner teclado = new Scanner(System.in);
System.out.println("-------------> LEER-POLINOMIO <---------------"
);
System.out.print("Coeficiente ---> ");
this.coeficiente = teclado.nextInt();

System.out.print("Literal ---> ");

this.exponente = teclado.nextInt();
}

// Metodo mostrar Polinomio

public void mostrarP() {
//System.out.println("--------------> MOSTRAR-POLINOMIO <------------
--" );

//System.out.println("*****************************************************
***************************" );
System.out.println(toString());
}
}
}

Clase CSimplePolinomios

public class ColaCircularPolinomio {

private int max=100;
private Polinomio v[]=new Polinomio[max+1];
private int ini,fin;

ColaCircularPolinomio(){
ini = 0;
fin = 0;
}

int nroElem (){

 return ((max + fin - ini) % max);
}

boolean esVacia (){

if (nroElem () == 0) {
return (true);
}
else {
return (false);
}
}

boolean esLlena (){

if (nroElem () == max-1) {
return (true);
}
else {
return (false);
}
}

void adicionar (Polinomio elem){

if (!esLlena ()){
fin = (fin + 1) % max;
v [fin] = elem;
}
else {
System.out.println ("--> Cola Circular llena <--");
}
}

Polinomio eliminar (){

Polinomio elem = new Polinomio();
if (!esVacia ()){
ini = (ini + 1) % max;
elem = v [ini];
if (nroElem () == 0) {
ini = fin = 0;
}
}
else{
System.out.println ("--> Cola Circular llena <--");
}
return (elem);
}

void mostrar (){

if (esVacia ()) {
System.out.println ("Cola vacia xxx");
}
else{
System.out.println("\n---> Datos de la Cola Circular (Polinomio) <---
");

System.out.println("*******************************************************
**********************************************");
ColaCircularPolinomio aux = new ColaCircularPolinomio ();
while (!esVacia ()){
Polinomio elem = eliminar ();
 aux.adicionar (elem);
elem.mostrarP();
}

System.out.println("*******************************************************
**********************************************");
vaciar(aux);
}
}

void vaciar (ColaCircularPolinomio a){

while (!a.esVacia ()) {
adicionar (a.eliminar ());
}
}

void llenar (int n) {

System.out.println("Ingrese Dato(s) de la Cola");
for(int i=0;i<n;i++) {
Polinomio elem = new Polinomio();
elem.leerP();
adicionar(elem);
}
}
}

d) Prueba de Corrida
a) Enunciado
Dada una cola Circular de Vehiculos <placa, marca, propietario e importe se pide:
a) Cuántos vehiculos tiene el propietario (X) y a cuanto asciende su valor.
b) Mostrar el Propietario con mas vehiculos
b) Diagrama de Clases

Vehiculo
- placa: String
- marca: String
- propietario: String
- importe: double
+ Vehiculo()
+ Vehiculo(String, String, String, double)
+ getters()
+ setters()
+ toString():String
+ leerE():void
+ mostrarE():void

CCircularVehiculo
- max: int
- ini: int
- fin: int
- v[max+1]: Vehiculo
+ CCircularVehiculos()
+ nroElem():int
+ esVacia(): boolean
+ esLlena(): boolean
+ adicionar(Vehiculo): void
+ eliminar: Vehiculo
+ mostrar(): void
+ vaciar(z: CCIrcularVehiculos):void
+ llenar():void
 c) Codigo JAVA
Main
public class Main {
public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);

CCircularVehiculos cv = new CCircularVehiculos();

// CARGAR COLA CIRCULAR DE VEHICULOS
cargarCCircularV(cv);
cv.mostrar();

/*Dada una cola Circular de Vehiculos <placa, marca, propietario e

importe
* se pide: >*/

// a) Cuántos vehiculos tiene el propietario (X) y a cuanto asciende

su valor

System.out.println("\n.....................................................
................................");
System.out.println(".................................... SOLUCION A
.....................................");
String x = "Eddy";
solucionA(cv,x);

System.out.println(".......................................................
..............................");

// b) Mostrar el Propietario con mas vehiculos

System.out.println("\n.....................................................
................................");
System.out.println(".................................... SOLUCION B
.....................................");
solucionB(cv);

System.out.println(".......................................................
..............................");
}

// CARGAR COLA CIRCULA DE VEHICULOS

private static void cargarCCircularV(CCircularVehiculos CV) {
CV.adicionar(new Vehiculo("3760HEC", "TOYOTA", "Carlos", 208.154));
CV.adicionar(new Vehiculo("2370KLM", "NISSAN", "Eddy", 114.235));
CV.adicionar(new Vehiculo("6789HNJ", "TOYOTA", "Juan", 117.350));
CV.adicionar(new Vehiculo("4749SNA", "SUSUKI", "Eddy", 110.450));
CV.adicionar(new Vehiculo("4752FGH", "KING LONG", "Pedro", 100.500));
CV.adicionar(new Vehiculo("5287JPL", "CHANA", "Clara", 119.550));
CV.adicionar(new Vehiculo("6274FFT", "MITSUBISHI", "Clara",
154.700));
CV.adicionar(new Vehiculo("5433PPL", "NISSAN", "Eddy", 180.398));
CV.adicionar(new Vehiculo("2347LMN", "HONDA", "Miriam", 112.200));
CV.adicionar(new Vehiculo("4987YUJ", "MAZDA", "Pablo", 70.500));
}

// SOLUCION A
private static void solucionA(CCircularVehiculos CV, String X) {
int n=CV.nroElem();
 int contador=0;
double total=0;
CCircularVehiculos aux = new CCircularVehiculos();

for(int i=1;i<=(n);i++) {
Vehiculo elem=CV.eliminar();
if(elem.getPropietario().equalsIgnoreCase(X)) {
contador++;
total=total+elem.getImporte();
}
aux.adicionar(elem);
}
System.out.println("Propietario: "+X+"\n"+"Cantidad Vehiculo(s):
"+contador+"\n"+"Total Bolivianos : "+total+" bs.");
CV.vaciar(aux);
}

// SOLUCION B
private static void solucionB(CCircularVehiculos CV) {
int mayorCantidadV = propietarioMasVehiculos(CV);
CCircularVehiculos auxV = new CCircularVehiculos();
int n=CV.nroElem();
String X ="";
for(int i=1;i<=(n);i++) {
Vehiculo elem=CV.eliminar();
int contV=contadorVehiculos(CV, elem.getPropietario());
if(contV==mayorCantidadV) {
System.out.println("Propietario(a):
"+elem.getPropietario());
X=elem.getPropietario();
}
auxV.adicionar(elem);
}
CV.vaciar(auxV);
System.out.println("Vehiculo Mayor-Costo:
"+(vehiculoMayorCosto(CV,X))+" bs.");
}

// FUNCION BUSCAR PROPIETARIO CON MAS VEHICULOS

private static int propietarioMasVehiculos(CCircularVehiculos CV) {
int mayor = Integer.MIN_VALUE;
int n=CV.nroElem();

CCircularVehiculos aux = new CCircularVehiculos();

for(int i=1;i<=(n);i++) {
Vehiculo elem=CV.eliminar();
int contV=contadorVehiculos(CV, elem.getPropietario());
if(contV >= mayor) {
mayor = contV;
}
aux.adicionar(elem);
}
CV.vaciar(aux);
return mayor;
}

// FUNCION CONTADOR DE VEHICULOS

 private static int contadorVehiculos(CCircularVehiculos CV, String
propietario) {
int n=CV.nroElem();
int contador = 0;
CCircularVehiculos aux = new CCircularVehiculos();

for(int i=1;i<=(n);i++) {
Vehiculo elem=CV.eliminar();
if(elem.getPropietario() == propietario) {
contador++;
}
aux.adicionar(elem);
}
CV.vaciar(aux);
return contador;
}

// FUNCION COPIAR COLA

private static CCircularVehiculos copiarCola(CCircularVehiculos CV) {
int n=CV.nroElem();

CCircularVehiculos aux = new CCircularVehiculos();

CCircularVehiculos copia = new CCircularVehiculos();

for(int i=1;i<=(n);i++) {
Vehiculo elem=CV.eliminar();
aux.adicionar(elem);
copia.adicionar(elem);
}
CV.vaciar(aux);
return copia;
}

// FUNCION BUSCAR VEHICULO MAYOR COSTO

private static double vehiculoMayorCosto(CCircularVehiculos CV, String X) {
int n=CV.nroElem();
double mayor=0;
CCircularVehiculos aux = new CCircularVehiculos();
CCircularVehiculos R = new CCircularVehiculos();

for(int i=1;i<=(n);i++) {
Vehiculo elem=CV.eliminar();
if(elem.getPropietario().equalsIgnoreCase(X)) {
R.adicionar(elem);
aux.adicionar(elem);
}
else {
aux.adicionar(elem);
}
}
CV.vaciar(aux);
return (vehiculoCostoso(R));
}

// FUNCION BUSCAR CARRO MAS COSTOO

private static double vehiculoCostoso(CCircularVehiculos R) {
double mayor = Double.MIN_VALUE;
int n=R.nroElem();
 CCircularVehiculos aux = new CCircularVehiculos();
for(int i=1;i<=(n);i++) {
Vehiculo elem=R.eliminar();
if(elem.getImporte() >= mayor) {
mayor = elem.getImporte() ;
}
aux.adicionar(elem);
}
R.vaciar(aux);
return mayor;
}
}

Clase Vehiculos
public class Vehiculo {
private String placa;
private String marca;
private String propietario;
private double importe;

// Constructor por default

public Vehiculo() {
this.placa = "";
this.marca = "";
this.propietario = "";
this.importe = 0;
}

// Constructor con parametros

public Vehiculo(String placa, String marca, String propietario, double
importe) {
super();
this.placa = placa;
this.marca = marca;
this.propietario = propietario;
this.importe = importe;
}

// Getters y Setters
public String getPlaca() {
return placa;
}

public void setPlaca(String placa) {

this.placa = placa;
}

public String getMarca() {

return marca;
}

public void setMarca(String marca) {

this.marca = marca;
}

public String getPropietario() {

return propietario;
}
 public void setPropietario(String propietario) {
this.propietario = propietario;
}

public double getImporte() {

return importe;
}

public void setImporte(double importe) {

this.importe = importe;
}

// To String
@Override
public String toString() {
return "Vehiculo [placa=" + placa + ", marca=" + marca + ",
propietario=" + propietario + ", importe=" + importe + "]";
}

// Metodo leer Vehiculo

public void leerV() {
Scanner teclado = new Scanner(System.in);
System.out.println("--------------> LEER-VEHICULO <---------------"
);

System.out.print("Placa ---> ");

this.placa = teclado.nextLine();

System.out.print("Marca ---> ");

this.marca = teclado.nextLine();

System.out.print("Propietario ---> ");

this.propietario = teclado.nextLine();

System.out.print("Importe ---> ");

this.importe = teclado.nextDouble();
}

// Metodo mostrar Vehiculo

public void mostrarV() {
//System.out.println("--------------> MOSTRAR-VEHICULO <-------------
--" );

//System.out.println("*****************************************************
***************************" );
System.out.println(toString());
}
}
Clase CCircularVehiculos

public class CCircularVehiculos {

private int max=100;
private Vehiculo v[]=new Vehiculo[max+1];
private int ini,fin;

CCircularVehiculos(){
ini = 0;
fin = 0;
}

int nroElem (){

return ((max + fin - ini) % max);
}

boolean esVacia (){

if (nroElem () == 0) {
return (true);
}
else {
return (false);
}
}

boolean esLlena (){

if (nroElem () == max-1) {
return (true);
}
else {
return (false);
}
}

void adicionar (Vehiculo elem){

if (!esLlena ()){
fin = (fin + 1) % max;
v [fin] = elem;
}
else {
System.out.println ("--> Cola Circular llena <--");
}
}

Vehiculo eliminar (){

Vehiculo elem = new Vehiculo();
if (!esVacia ()){
ini = (ini + 1) % max;
elem = v [ini];
if (nroElem () == 0) {
ini = fin = 0;
}
}
else{
System.out.println ("--> Cola Circular llena <--");
}
return (elem);
}
 void mostrar (){
if (esVacia ()) {
System.out.println ("Cola vacia xxx");
}
else{
System.out.println("\n---> Datos de la Cola Circular (Vehiculo (s))
<---");

System.out.println("*******************************************************
**********************************************");
CCircularVehiculos aux = new CCircularVehiculos ();
while (!esVacia ()){
Vehiculo elem = eliminar ();
aux.adicionar (elem);
elem.mostrarV();
}

System.out.println("*******************************************************
**********************************************");
vaciar(aux);
}
}

void vaciar (CCircularVehiculos a){

while (!a.esVacia ()) {
adicionar (a.eliminar ());
}
}

void llenar (int n) {

System.out.println("Ingrese Dato(s) de la Cola");
for(int i=0;i<n;i++) {
Vehiculo elem = new Vehiculo();
elem.leerV();
adicionar(elem);
}
}
}
d) Prueba de Corrida