Tipos de datos Abstractos

PILAS
La pila es una estructura que se basa en el concepto LIFO: Last In First Out, es decir, el
último elemento que entra es el primero que sale.

Pila Estatica
Se realiza por medio de un array. Se insertan datos hasta su tope máximo y a medida que se van
sacando elementos se setean en cero los elementos del array ya utilizados.

METODO RETORNA PARAMETROS UTILIDAD

Insertar(nuevoValor) void Object Añade un nuevo
elemento a la pila
Sacar() Object Ninguno Retorna el valor del
ultimo elemento
ingresado.
PilaVacia() Boolean Ninguno Retorna true si está
vacía, sino false
PilaLlena() Boolean Ninguno Retorna true si está
llena, sino false

public class PilaEstatica {

int pila1[]=new int[5];
int tope=-1;

public void insertar(int v){

tope++;
pila1[tope]=v;
}

public int sacar(){

int retorno=0;
retorno=pila1[tope];
pila1[tope]=0;
tope--;
return retorno;
}

public boolean PilaLlena(){

return tope==pila1.length-1;
}

public boolean PilaVacia(){

return tope<0;
}
}
 Tipos de datos Abstractos

import java.util.Scanner;

public class Ejecucion {

public static void main(String[] args) {
PilaEstatica p = new PilaEstatica();
int valor=0;
Scanner sc=new Scanner(System.in);
while(!p.PilaLlena()){
System.out.println("ingrese valor");
valor = sc.nextInt();
p.insertar(valor);
}
while(!p.PilaVacia()){
System.out.println(p.sacar());
}
}
}

Pila Simplemente Enlazada

En una pila tenemos un método que agrega un nodo a la pila y otro que elimina el último nodo
ingresado. Cada nodo insertado en la pila será una instancia de la clase Nodo
 Tipos de datos Abstractos

En esta implementación, definiremos los siguientes métodos:

METODO RETORNA PARAMETROS UTILIDAD

Poner(nuevoObjeto) void Object Añade un nuevo
nodo a la pila
Sacar() Object Ninguno Retorna el valor del
ultimo elemento
ingresado y elimina
el nodo.
EstaVacia() Boolean Ninguno Retorna true si está
vacía, sino false
Vaciar() void Ninguno Remueve todos los
nodos de la pila
public class Nodo {
private int valor;
private Nodo siguiente;

public Nodo(int v, Nodo s){

this.valor=v;
this.siguiente=s;
}

public int getValor() {

return valor;
}
 Tipos de datos Abstractos

public void setValor(int valor) {

this.valor = valor;
}

public Nodo getSiguiente() {

return siguiente;
}

public void setSiguiente(Nodo siguiente) {

this.siguiente = siguiente;
}
}

public class Pila {

private Nodo tope;

public Pila(){
tope=null;
}

public void Poner(int v){

tope=new Nodo(v,tope);
}

public int Sacar(){

Nodo aux;
int Info;

aux=this.tope;

if(aux==null)
return 0;

tope=aux.getSiguiente();
Info=aux.getValor();

aux=null;
return Info;
}

public boolean EstaVacia(){

return this.tope==null;
}

public void Vaciar()

{
Nodo aux;

while(tope!=null){
aux=this.tope;
tope=aux.getSiguiente();
aux=null;
}
}
}

public class Ejecucion {

public static void main(String[] args) {

Pila pila = new Pila();
pila.Poner(4);
pila.Poner(5);
pila.Poner(8);

while(!pila.EstaVacia())
 Tipos de datos Abstractos

{
System.out.println(pila.Sacar());
}
pila.Poner(11);
pila.Poner(2);

System.out.println(pila.EstaVacia());
pila.Vaciar();
System.out.println(pila.EstaVacia());
}

Ejercicio:
Hacer una pila de nodos que contenga objetos de la clase Persona, con atributos nombre y edad.
El programa debe cargar hasta que la edad sea cero. Mostrar todos los elementos de la pila.
public class Persona {
private int edad;
private String nombre;
private Persona siguiente;

public int getEdad() {

return edad;
}

public String getNombre() {

return nombre;
}

public Persona getSiguiente() {

return siguiente;
}

public Persona(int e, String n, Persona p){

this.edad=e;
this.nombre=n;
this.siguiente=p;
}
}
public class Pila {
private Persona tope;

public Pila(){
tope=null;
}

public void Poner(int e, String n){

tope=new Persona(e,n,tope);
}

public Persona Sacar(){

Persona p;
Persona aux;
aux=this.tope;

if(aux==null)
return null;

p=aux;
tope=aux.getSiguiente();

aux=null;
return p;
}
 Tipos de datos Abstractos

public boolean EstaVacia(){

return this.tope==null;
}

public void Vaciar()

{
Persona aux;

while(tope!=null){
aux=this.tope;
tope=aux.getSiguiente();
aux=null;
}
}
}

import java.util.Scanner;

public class Ejecucion {

public static void main(String[] args) {

Pila pila = new Pila();
int edad;
String nombre;

Scanner sc = new Scanner(System.in); //Se crea el lector

System.out.println("Ingrese Edad: ");
edad = sc.nextInt();
while(edad !=0){
System.out.println("Ingrese Nombre: ");
nombre = sc.next();
pila.Poner(edad,nombre);

System.out.println("Ingrese Edad: ");

edad = sc.nextInt();
}

while(!pila.EstaVacia())
{
Persona p = pila.Sacar();
System.out.println(p.getNombre()+" "+p.getEdad());
}
}
}

COLAS
La cola es una estructura que se basa en el concepto FIFO: First In First Out, es decir, el
primer elemento que entra es el primero que sale.

Cola Estatica
Se realiza por medio de un array. Se insertan datos hasta su bit de fin máximo y a medida que
se van sacando elementos se setean en cero los elementos del array ya utilizados. Van saliendo
los primeros en ingresar a la cola.

METODO RETORNA PARAMETROS UTILIDAD

Insertar(nuevoValor) void Object Añade un nuevo
elemento a la pila
Sacar() Object Ninguno Retorna el valor del
ultimo elemento
ingresado.
 Tipos de datos Abstractos

ColaVacia() Boolean Ninguno Retorna true si está

vacía, sino false
ColaLlena() Boolean Ninguno Retorna true si está
llena, sino false

public class ColaEstatica {

int cola1[]=new int[5];
int inicio=cola1.length;
int fin=-1;

public void insertar(int v){

if(ColaVacia()){
inicio=0;
}
fin++;
cola1[fin]=v;
}

public int sacar(){

int retorno=0;
retorno=cola1[inicio];
cola1[inicio]=0;
inicio++;
return retorno;
}

public boolean ColaLlena(){

return fin==cola1.length-1;
}

public boolean ColaVacia(){

return inicio > cola1.length-1;
}
}

import java.util.Scanner;

public class Ejecucion {

public static void main(String[] args) {
ColaEstatica c = new ColaEstatica();
int valor=0;
Scanner sc=new Scanner(System.in);
while(!c.ColaLlena()){
System.out.println("ingrese valor");
valor = sc.nextInt();
c.insertar(valor);
}
while(!c.ColaVacia()){
System.out.println(c.sacar());
}
}
}
 Tipos de datos Abstractos

Cola Simplemente Enlazada

En una cola tenemos un método que agrega un nodo a la cola y otro que elimina el primer nodo
ingresado. Cada nodo insertado en la cola será una instancia de la clase Nodo

En esta implementación, definiremos los siguientes métodos:

METODO RETORNA PARAMETROS UTILIDAD

Poner(nuevoObjeto) void Object Añade un nuevo
nodo a la pila
Sacar() Object Ninguno Retorna el valor del
primer elemento de
 Tipos de datos Abstractos

la cola y elimina el
nodo.
EstaVacia() Boolean Ninguno Retorna true si está
vacía, sino false
Vaciar() void Ninguno Remueve todos los
nodos de la pila

public class Nodo {

private int dato;
private Nodo next;

public Nodo(int dato){

this.dato=dato;
}
public int getDato() {
return dato;
}
public void setDato(int dato) {
this.dato = dato;
}
public Nodo getNext() {
return next;
}
public void setNext(Nodo next) {
this.next = next;
}
}

public class Cola {

private Nodo inicio;
private Nodo termino;

public Cola(){
inicio=null;
termino=null;
}
public void insertar(int dato){
Nodo i=new Nodo(dato);
if(inicio==null && termino==null){
inicio=i;
termino=i;
}
termino.setNext(i);
termino = termino.getNext();
}

public int extraer(){

int dato = inicio.getDato();
inicio = inicio.getNext();
return dato;
}
public boolean estaVacia(){
boolean vacia;
if(inicio==null){
vacia=true;
 Tipos de datos Abstractos

}
else{
vacia=false;
}
return vacia;
}
}

public class Ejecucion {

public static void main(String[] args) {
Cola c=new Cola();
c.insertar(46);
c.insertar(12);
c.insertar(87);
c.insertar(125);
c.insertar(30);
c.insertar(25);
c.insertar(12);
c.insertar(2);

while(!c.estaVacia()){
System.out.println(c.extraer());
}
}
}

Ejercicio:
Hacer una Cola de nodos que contenga objetos de la clase Persona, con atributos nombre y
edad. El programa debe cargar hasta que la edad sea cero. Mostrar todos los elementos de la
pila.

public class Persona {

private int edad;
private String nombre;
private Persona siguiente;

public Persona(int e,String n){

this.edad=e;
this.nombre=n;
}

public void setEdad(int edad) {

this.edad = edad;
}

public int getEdad() {

return edad;
}

public String getNombre() {

return nombre;
}

public void setSiguiente(Persona siguiente) {

this.siguiente = siguiente;
 Tipos de datos Abstractos

public Persona getSiguiente() {

return this.siguiente;
}
}

public class Cola {

private Persona primero;
private Persona ultimo;
private int tamanio;

public Cola() {
primero = null;
ultimo = null;
tamanio = 0;
}

public boolean isEmpty() {

return primero == null;
}

public int size() {

return tamanio;
}

public Persona primero() {

if (isEmpty()) {
return null;
}

return primero;
}

public void insertar(int e,String n){

Persona i=new Persona(e,n);
if(primero==null && ultimo==null){
primero=i;
ultimo=i;
}
ultimo.setSiguiente(i);
ultimo = ultimo.getSiguiente();
}

public Persona extraer(){

Persona p = primero;
primero = primero.getSiguiente();
return p;
}

public boolean estaVacia(){

boolean vacia;
if(primero==null){
 Tipos de datos Abstractos

vacia=true;
}
else{
vacia=false;
}
return vacia;
}

import java.util.Scanner;

public class Ejecucion {

public static void main(String[] args) {

Cola cola=new Cola();
int edad;
String nombre;

Scanner sc = new Scanner(System.in); //Se crea el lector

System.out.println("Ingrese Edad: ");
edad = sc.nextInt();

while(edad !=0){
System.out.println("Ingrese Nombre: ");
nombre = sc.next();
cola.insertar(edad, nombre);

System.out.println("Ingrese Edad: ");

edad = sc.nextInt();
}

Persona p;
while(!cola.estaVacia()){
p=cola.extraer();
System.out.println(p.getNombre()+" "+p.getEdad());
}
}
}
 Tipos de datos Abstractos

Guia de ejercicios:

1) Hacer una pila estatica de objetos tipo Persona, con nombre y edad
2) Hacer una cola estatica de objetos tipo Persona, con nombre y edad
3) Hacer una pila con un arraylist de cinco nombres ingresados a mano
4) Hacer una cola con un arraylist de cinco nombres ingresados a mano
5) Hacer una pila dinámica de objetos de bicicleta de distintos tipos(carrera, paseo, mountainbike)
partiendo de una clase abstracta Bicicleta.
6) Hacer una cola dinámica de objetos de especialistas médicos(pediadtra, gastroenterólogo, clinico),
partiendo de una clase abstracta Medico.

1) Hacer una pila estatica de objetos tipo Persona, con nombre y edad.
public class Persona {
int edad;
String nombre;

public Persona(int e, String n){

this.edad=e;
this.nombre=n;
}

public int getEdad() {

return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
}
public class PilaEstatica {
Persona pila1[]=new Persona[5];
int tope=-1;

public void insertar(Persona pers){

tope++;
pila1[tope]=pers;
}

public Persona sacar(){

Persona retorno;
 Tipos de datos Abstractos

retorno=pila1[tope];
pila1[tope]=null;
tope--;
return retorno;
}
public boolean PilaLlena(){
return tope==pila1.length-1;
}

public boolean PilaVacia(){

return tope<0;
}
}

import java.util.Scanner;

public class Ejecucion {

public static void main(String[] args) {

PilaEstatica p = new PilaEstatica();
int edad=0;
String nombre;

Scanner sc=new Scanner(System.in);

while(!p.PilaLlena()){
System.out.println("ingrese nombre");
nombre = sc.next();
System.out.println("ingrese edad");
edad = sc.nextInt();

Persona pers=new Persona(edad,nombre);

p.insertar(pers);
}
while(!p.PilaVacia()){
Persona pp=p.sacar();
System.out.println(pp.nombre+" "+pp.edad);
}
}
}

4) Hacer una cola con un arraylist de cinco nombres ingresados a mano

import java.util.ArrayList;

public class Cola {

ArrayList<String> cola1 = new ArrayList<String>();

public void insertar(String v){

cola1.add(v);
}

public String sacar(){

return cola1.remove(0);
}
 Tipos de datos Abstractos

public boolean ColaVacia(){

return cola1.size() == 0;
}
}

import java.util.Scanner;

public class Ejecucion {

public static void main(String[] args) {
Cola c = new Cola();
String nombre;
Scanner sc=new Scanner(System.in);

for (int i=0;i<5;i++)

{
System.out.println("Ingrese Nombre");
nombre = sc.next();
c.insertar(nombre);
}
while(!c.ColaVacia()){
System.out.println(c.sacar());
}
}
}

5) Hacer una pila dinámica de objetos de bicicleta de distintos tipos(carrera, paseo, mountainbike)
partiendo de una clase abstracta Bicicleta.

public abstract class Bicicleta {

private String color;
private int pesocuadro;
//marcha; //lenta,media,rapida
private Bicicleta siguiente;

public Bicicleta(int pes,String col){

this.pesocuadro=pes;
this.color=col;
}

public Bicicleta getSiguiente() {

return siguiente;
}

public void setSiguiente(Bicicleta siguiente) {

this.siguiente = siguiente;
}

public String getColor() {

return this.color;
}
public void setColor(String color) {
this.color = color;
}
public int getPesocuadro() {
return pesocuadro;
 Tipos de datos Abstractos

}
public void setPesocuadro(int pesocuadro) {
this.pesocuadro = pesocuadro;
}

public abstract String getMarcha();

}

public class BicicletaCarrera extends Bicicleta{

int capacidadCantimplora;

public BicicletaCarrera(int peso, String col, int cap){

super(peso,col);
this.capacidadCantimplora=cap;
}

public int getCapacidadCantimplora() {

return capacidadCantimplora;
}

public void setCapacidadCantimplora(int capacidadCantimplora) {

this.capacidadCantimplora = capacidadCantimplora;
}

@Override
public String getMarcha(){
return "rapida";
}
}

public class BicicletaPaseo extends Bicicleta{

int capacidadCanasta;

public BicicletaPaseo(int peso, String col, int cap){

super(peso,col);
this.capacidadCanasta=cap;
}
public int getCapacidadCanasta() {
return capacidadCanasta;
}

public void setCapacidadCanasta(int capacidadCanasta) {

this.capacidadCanasta = capacidadCanasta;
}

@Override
public String getMarcha(){
return "lenta";
}
}

public class BicicletaMountain extends Bicicleta{

int capacidadAmortiguacion;

public BicicletaMountain(int peso, String col, int cap){

super(peso,col);
 Tipos de datos Abstractos

this.capacidadAmortiguacion=cap;
}

public int getCapacidadAmortiguacion() {

return capacidadAmortiguacion;
}

public void setCapacidadAmortiguacion(int capacidadAmortiguacion) {

this.capacidadAmortiguacion = capacidadAmortiguacion;
}

@Override
public String getMarcha(){
return "media";
}
}

public class Pila {

private Bicicleta tope;

public Pila(){
tope=null;
}

public void Poner(Bicicleta b){

b.setSiguiente(tope);
tope=b;
}

public Bicicleta Sacar(){

Bicicleta p;
Bicicleta aux;
aux=this.tope;

if(aux==null)
return null;

p=aux;
tope=aux.getSiguiente();

aux=null;
return p;
}

public boolean EstaVacia(){

return this.tope==null;
}

public void Vaciar()

{
Bicicleta aux;

while(tope!=null){
aux=this.tope;
tope=aux.getSiguiente();
aux=null;
 Tipos de datos Abstractos

}
}
}

public class Ejecucion {

public static void main(String[] args) {

Pila pila = new Pila();

Bicicleta objBiciPaseo=new BicicletaPaseo(10,"Verde",6);

pila.Poner(objBiciPaseo);

Bicicleta objBiciCarrera=new BicicletaCarrera(4,"Blanca",1);

pila.Poner(objBiciCarrera);

Bicicleta objBiciMountain=new BicicletaMountain(6,"Azul",20);

pila.Poner(objBiciMountain);

while(!pila.EstaVacia())
{
Bicicleta p = pila.Sacar();
if(p.getClass().getName()=="BicicletaPaseo"){
System.out.println(p.getColor()+" "+p.getPesocuadro()+" "+
((BicicletaPaseo)p).getCapacidadCanasta()+" "+((BicicletaPaseo)p).getMarcha());
}
if(p.getClass().getName()=="BicicletaCarrera"){
System.out.println(p.getColor()+" "+p.getPesocuadro()+" "+
((BicicletaCarrera)p).getCapacidadCantimplora()+" "+
((BicicletaCarrera)p).getMarcha());
}
if(p.getClass().getName()=="BicicletaMountain"){
System.out.println(p.getColor()+" "+p.getPesocuadro()+" "+
((BicicletaMountain)p).getCapacidadAmortiguacion()+" "+
((BicicletaMountain)p).getMarcha());
}
}
}
}