PROGRAMACIÓN

ORIENTADA
DEFINICIONES
A OBJETOS
ABSTRACCIÓN.- Se centra en la vista externa de cualquier objeto, de modo
que sirva para operar el comportamiento esencial de la implementación.
ENCAPSULAMIENTO.- Es el proceso de ocultar todos los procesos secretos de
un objeto que se constituyen en sus características esenciales, también permite
la división en módulos o en clases.
MODULARIDAD.- Es la propiedad que permite sudividir una aplicación en
partes esenciales, cada una de ellas es independiente como sea posible de la
aplicación, pero que realiza un trabajo específico.
JERARQUÍA.- Es la propiedad que permite una aplicación de las abstracciones
La estructura de clases o jerarquía (generalización) y estructura de objetos
jerarquía o agregación.
 JERARQUÍA DE HERENCIA JAVA.AWT
Event TextComponent
Textfield (texto)
Checkbox (cajon)
Object Componentes Container
Panel Applet
Label (Etiqueta)
CheckbokGroup Button (Botones)
List (lista)
Choice (opcion)
Una partición de la jerarquía de herencia
java.awt
Los componentes GUI básicos.- Debemos entender la
 MANEJO DE CADENAS EN GRÁFICOS
Manejo de cadenas en modo gráfico (java utiliza:
AWT y SWING)

Titulo del formulario Achicar

Agrandar Salir Int. Cadena

Respuesta TextFiel

Label
Abajo, Arriba SALIR MAY
 PILAS
Definición.- Una pila es una lista de elementos a la cual se añaden,
eliminan, ordenan, cambian, etc. solo por un extremo llamado top.
El acceso a esta lista es de tipo LIFO, donde el último elemento que
se introduce en la pila es el primer elemento en ser extraído.
FILOSOFÍA.- La filosofía que se emplea es “Último en entrar primero
en salir”, “Last in, First out, LIFO”
Las pilas son estructuras de datos dinámicos que almacenan
información de un solo tipo, siempre tomando la filosofía de “último
en entrar, primero en salir”
La pila es una estructura de datos dinámicos con numerosas
aplicaciones o analogías en la vida real.
 PILAS
Ejemplos:
Una apilación de platos de loza.
Una apilación de monedas,
Una apilación de objetos metálicos.
Una apilación de cajas de zapatos
Mineros que entran en el socabon
 PILA DE CONEJOS

PILA
TOP LIMITE
 PILAS
REPRESENTACIÓN EN UNA COMPUTADORA
Las pilas están definidas en los diferentes lenguajes de
programación de manera escueta, y elemental que se fundamentan
mediante punteros simples, punteros múltiples, las mismas que se
implementan en vectores tipo Object y listas encadenadas. Para
esto se define el tamaño máximo (límite máximo) o el tope de la pila
y el puntero llamado TOP que señala la posición del último
elemento insertado en la pila.
PILA = P(1), P(2), P(3), … , P(n)
CONDICIONES
Si tope = 0 entonces, la pila esta vacía.
Si tope = límite entonces, la pila esta llena.
 CREAR PILAS Y VERIFICAR VACIO
/* PROYECTO FINAL */
class Pilassimple #include<stdio.h>
{ final int limite = 10; int top; #include<conio.h>
Object p []=new Object [limite]; #include<stdlib.h>
Pilassimple () #include<ctype.h>
#include<string.h>
{ top = 0; }
#include<iostream.h>
#define ENTER 13
5 tam
4
#define ESC 27
3 #define tam 100
1 #define tam 10
0 top typedef struct pila
{int tami[100];
void addp (Object e) int tope; } p;
{ p [top] = e; top++; } void creacsi (p *d1)
{d1->tope=0; }
 VERIFICAR LLENO, ADICIONAR Y ELIMINAR EN PILA
boolean verificalleno ()
{ if (top == tam) return true; void adicionacsi (p *d1,int e)
else return false; } {if (d1->tope <tam)
boolean verifllena () {d1->tami[d1->tope] =e;
d1->tope=d1->tope +1; }
{ if (top == limite) return true; else {printf ("pila llena");}
else return false; }
} tam void mostrarcsi(p d1)
{ int i;
top 55 for (i=0;i<d1.tope;i++)
66 { printf("\npila[%d]=%d",i,d1.tami[i]); }
Object delpila () 77 }
void eliminarcsi(p *d1,int *e)
{ top = top – 1; return (v [top]); } {if(d1->tope>0)
void verpila () {d1->tope=d1->tope-1;
{ System.out.println ("pila:\t"); *e=d1->tami[d1->tope];
}
for (int i = 0 ; i < top ; i++) else
System.out.println ("en la {printf("pila vacia");
pocision [“+i +"]se encuentra el }
}
elemento [“+v [i]+"]");
 ORDENAR, BUSCAR EN PILA
void intercambia (int n, int m)
{ void ordenacsi(p *d1)
int i = 0, j = 0, sw = 0, sw1 = 0; {
Object aux;
System.out.print ("\nDESPUES DEL int i,j,aux;
INTERCAMBIO\n"); for (i=0;i< d1->tope-1;i++)
while (i < t && sw == 0) {for (j=i;j<d1->tope;j++)
{ if (i == n)
{ sw = 1; {if (d1->tami[i] <d1->tami[j])
while (j < t && sw1 == 0) {
{ if (j == m) aux= d1->tami[i];
{ sw1 = 1; aux = p [i];
p [i] = p [j]; p [j] = aux; d1->tami[i]=d1->tami[j];
} d1->tami[j]=aux;
else }
j++;
} }
} }
else }
i++;
}
 MENÚ PRINCIPAL EN JAVA Y C++

int delensupos (int dato)

{ void pilasimples()
int sw = 0; {p d1;
//Object aux; int ps;
int i = 0; int e;
while (i < t) do{
{ if (Integer.parseInt (p [i].toString ()) clrscr();
== dato) cout<<"\n\n\n\t\t**MENU PILAS
{ sw = 1; SIMPLES*";
while (i < t - 1) printf("\n1.- crea \n");
{ p [i] = p [i + 1]; i++; } printf("2.- adicionar \n");
elimp (); i = 0; printf("3.- mostrar \n");
} printf("4.- eliminar\n");
else printf("5.- ordena\n");
{ i++; } printf("6.- salir al menu principal\n");
}System.out.print ("\nDESPUES DE LA scanf ("%d",&ps);
ELIMINACION\n"); switch(ps)
listap ();
return sw;
}
 MENÚ PRINCIPAL EN JAVA Y C++
void buscap (int n) switch(ps)
{ for (int i = 0 ; i < t ; i++) {case 1:clrscr(); creacsi(&d1);
{ if (n == Integer.parseInt (p [i].toString ())) printf("\npila creada"); getch();
System.out.println (n + " SE ENCUENTRA EN break;
LA POSICION " + i); case 3:clrscr(); printf("\nlos elementos de la
} pila son");
} mostrarcsi(d1);
void ordenap () getch(); break;
{ case 2:clrscr();
int i, j; printf("\nelemento a adiconar");
Object aux; scanf("%d",&e);
for (i = 0 ; i < t ; i++) adicionacsi(&d1,e);
{ for (j = i + 1 ; j < t ; j++) break;
{ if (Integer.parseInt (p [i].toString ()) > case 4 :clrscr(); eliminarcsi(&d1,&e);
Integer.parseInt (p [j].toString ())) printf("\nelemento a eliminar");
{ aux = p [i]; p [i] = p [j]; p [j] = printf("%d",e); getch(); break;
aux; case 5 :clrscr(); ordenacsi(&d1);
} printf("de manera ordenad es...... ");
} mostrarcsi(d1); getch(); break;
} }
} }while(ps< 6 );
}
 { m = m * (Integer.parseInt (p [i].toString switch (op)
())); } { case 1: sw = 1; do { if (!x.verifllena
MENÚ PRINCIPAL
System.out.print ("\nLA MULTI DE LOS ELEM EN
()) JAVA Y C++
DE LA PILA ES= “+m); {System.out.print ("\t\tAdicionar el
} elemento--->");
public static void main (String args []) e = Leer.dato (); x.addp (e); }
//public static void pilas ()
else {System.out.println ("\t*pila
{ Pilassimple x = new Pilassimple ();
Object e; int op, a, b, sw,t=1; llena* ");}
do System.out.print ("DESEA SEGUIR ADI
{ System.out.println ("\n\n"); (si=1/no=0)->");
System.out.print ("\t\t\t__PILAS sw = Leer.datoInt ();
SIMPLES________ \n"); } while (sw != 0); break;
System.out.println case 2:if (!x.verifvacia ()) {x.listap
("\t\t=====================\n"); (); }
System.out.println ("\t\t\t1. ADICIONA
ELEMENTO ");
else System.out.println ("\t**pila
System.out.println ("\t\t\t2. LISTA PILA "); vacia** ");
System.out.println ("\t\t\t3. ELIMINA break;
ULTIMO ELEMENTO "); case 3: if (!x.verifvacia ()) { e = x.elimp
System.out.println ("\t\t\t4. ORDENA ESTA ();
PILA"); System.out.print ("el elem elimi fue-
System.out.println ("\t\t\t5. BUSCA > " + e); }
ELEMENTOS");
else System.out.println ("\t**pila
System.out.println ("\t\t\t6. INTERCAMBIA
ELEMENTOS");
vacia** ");
System.out.println ("\t\t\t7. ELIM EL break;
ELEMENTO DESEADO"); case 4: if (!x.verifvacia ()) { x.ordenap ();
 System.out.print ("QUIERE INTERCAMBIAR LA POSICION--->");
MENÚ ();
a = Leer.datoInt PRINCIPAL EN JAVA Y C++
System.out.print ("CON LA POSICION--->\t\t"); b = Leer.datoInt ();
x.intercambia (a, b); break;
} else System.out.println ("\t**pila vacia** "); break;
case 7: if (!x.verifvacia ()) { System.out.print ("QUE
ELEMENTO DESEA ELIMINAR--->");
a = Leer.datoInt (); b = x.delensupos (a);
if (b == 0) { System.out.print ("EL ELEMENTO NO EXISTE
EN LA PILA"); }
else System.out.print ("ELEMENTO ELIMINADO
FUE--->" + a); break;
} else System.out.println ("\t**pila vacia** ");
break;
case 8: if (!x.verifvacia ()) { x.listap (); x.multiplica (t);
break; }
else System.out.println ("\t**pila vacia** ");
break;
case 0: op = 0; System.out.println("<==== ELIJA UNA OPCION DEL MENU
PRINCIPAL\n\n\n"); break;
default: System.out.print ("\tERROR!!!!!!");
}
 //menu pilas
class pilas PILA EN JAVA, OTRA
{ public static final int lim = 50;
VERSIÓN
class sol_2
{ public static void adicion (pilas A, int me)
public int tope; public int[] p; { int n; try
pilas () { for (int i = 1 ; i <= me ; i++)
{ tope = 0; p = new int [lim]; } { System.out.println ("La pila->");
public void poner (int e) throws Exception n = Leer.datoInt (); A.poner (n);
{ if (tope < lim) } }
{ tope++; p [tope] = e; } catch (Exception er)
else { throw new Exception ("Desborde { System.err.println ("EXCEPCION : " +
de Pila");} } er); } }
public int quitar () throws Exception public static int poner (pilas A)
{ int aux; { pilas aux = new pilas (); int e, e1;
if (tope > 0) { aux = p [tope]; tope--; try
} { e = A.quitar (); aux.poner (e);
else while (A.tope != 0) { e1 = A.quitar
{throw new Exception ("pila vacia no ();
puede extraer"); } if (e1 < e) { e = e1; }
return aux; } aux.poner (e1);
public void listar () } while (aux.tope != 0)
{ if (tope == 0) { System.out.println {e1 = aux.quitar (); A.poner (e1); }
("pila vacia"); } return (e);
else { for (int i = tope ; i >= 1 ; i--) }
{ System.out.println ("[" + p [i] + catch (Exception er)
"]"); } { System.err.println ("EXCEPCION : " +
 else { sw = System.out.println ("\n");
} MENÚ int n, w, q, K = 0; pilas A = new pilas ();
1; } PRINCIPAL
while (aux.tope != 0)
EN JAVA Y C++
while (K <= 5)
{ e = aux.quitar (); A.poner (e); { System.out.println ("\t(1)
} } ADICIONAR.");
catch (Exception er) System.out.println ("\t(2)
{ System.err.println ("EXCEPCION : MOSTRAR.");
" + er); } } System.out.println ("\t(3) ELIMINAR.
public static void ordenar (pilas A) ");
{ pilas ao = new pilas (); int e; System.out.println ("\t(4)
try ORDENAR.");
{ while (A.tope != 0) System.out.println ("\t(5) BUSCAR."); K =
{ e = poner (A); eliminar (A, e); Leer.datoInt ();
ao.poner (e); } switch (K) {
System.out.println ("PILA case 1: System.out.println ("INT
ORDENADA"); ao.listar (); } DIMENCION DE LA PILA : ");
catch (Exception er) n = Leer.datoInt (); adicion (A, n);
{ System.err.println ("EXCEPCION : " break;
+ er); } } case 2: System.out.println ("PILA ES: ");
public static void buscar (pilas A, int me) A.listar (); break;
{ pilas aux = new pilas (); int sw = 0, e; case 3: System.out.println ("INT
try ELEMENTO A ELIMINAR");
{ while (A.tope != 0) { e= w = Leer.datoInt (); eliminar (A, w);
A.quitar (); break;
if (e == me) {System.out.println (“elem case 4: System.out.println ("LA PILA
 PILAS MÚLTIPLES
Definición.- Las pilas múltiples son listas de elementos a la cual se añaden,
eliminan, ordenan, cambiar, etc. solo por un extremo llamado top, en cada una
de las pilas.
El acceso a esta lista es de tipo LIFO, donde el último elemento que se
introduce en la pila es el primer elemento en ser extraído.
FILOSOFÍA.- La filosofía que se emplea es “Último en entrar primero en salir”,
“Last in, First out, LIFO”
La pila es una estructura de datos dinámicos con numerosas aplicaciones o
analogías en la vida real.
REPRESENTACIÓN limite=7 15 23

tope=0 =8 =16 tope

Total = 16 PILA 0 PILA 1 PILA 2 PILA 4
 CONCEPTOS GENERALES
CONDICIONES
El total del espacio se divide por el número de pilas en partes iguales
Si tope= 0 entonces, la pila esta vacía.
Si tope > límite entonces, la pila esta llena.
OPERACIONES
Crear
Adicionar
Eliminar
Listar
Ordenar
Buscar
Intercalar
CREACIÓN PROGRAMACIÓN
PILAS DE PILAS
public class Pilas_multiples
{ int tcp, tam = 50; //PILAS MULTIPLES
Object mpi [] = new Object #define tamm 10
[50]; struct mpila
int top [] = new int [50]; { int mp[tam];
int lim [] = new int [50]; int top[tam];
void crea_mp (int ni) int limite[tam];
{ int i; tcp = tam / ni; } pilas;
for (i = 0 ; i < ni ; i++) typedef struct mpila mpilas;
{ top [i] = i * tcp; mpilas mp,mp1,mp2;
lim [i] = ((i + 1) * tcp) – int tcp;
1; } void creamm (mpilas *mp1,int np)
System.out.println ("\tFueron {tcp=tam/np;
creados[" + ni + "]pilas"); for(int i=0;i<np;i++)
} {mp1->top[i]=i*tcp;
tam mp1->limite[i]=((i+1)*tcp)-1;
} }
 void adicionamm(mpilas *mp1,int
ADICIÓN, Y ELIMINACIÓN DEe,int ELEMENTOS
np) EN PILAS
{ if (mp1->top[np-1]<mp1-
>limite[np-1])
void adi_mp (Object e, int ni)
{ mpi [top [ni - 1]] = e;
{ mp1->mp[mp1->top[np-1]] =e;
top [ni - 1]++; mp1->top[np-1]=mp1->top[np-
} 1]+1;
}
else
{ printf ("\npila llena"); }
}
void eliminarmm(mpilas *mp1,int
void elim_mp (int ni) *e,int np)
{ Object e;
top [ni - 1]--; e = mpi [top [ni -
{if(mp1->top[np-1]!=mp1-
1]]; >limite[np-1])
System.out.println ("\tEl elemento {mp1->top[np-1]=mp1->top[np-
[“+e+"]eliminado");
}
1]-1;
*e=mp1->mp[mp1->top[np-1]];
}
 for (i = (ni - 1) * tcp ; i < top
LISTAR ELEMENTOS DE LA PILA
[ni - 1] ; i++)
{System.out.println ("[" + mpi
[i] + "]"); void mostrarmm(mpilas mp1,int
} } np)
public static void main(String { int i;
args[]) if(mp1.top[np-1]!=mp1.limite[np-
{ int op, sw = 0, ni, np; 1])
Object e; { for (i=(np-
Pilas_multiples z = new 1)*tcp;i<mp1.top[np-1];i++)
Pilas_multiples (); { printf("\npila[%d]=
while (sw == 0) %d",i,mp1.mp[i]);
{System.out.println ("\n\tMENU }
PILAS "); }
System.out.println ("1.-CREAR else {cout<<"\npila
PILA MULT"); vacia..";getch();}
System.out.println ("2.- }
ADICIONA ELEMEN");
System.out.println ("3.-LISTAR
 CONSTRUCCIÓN
System.out.println ("5.-RETORNAR DEL AL void
MENÚ pilasmultiples()
PRINCIPAL
MENU PRINCIPAL "); {int ps,np; int e;
System.out.println ("\n\tELIJA UNA do{
OPCION-->"); clrscr();
op = Leer.datoInt (); cout<<"\n\n\t\t**MENU PILAS
switch (op) MULTIPLES**";
{ printf("\n1.- crea \n");
case 1: if (! verificapila()) printf("2.- adicionar \n");
{ System.out.println ("Cuantas Pilas printf("3.- mostrar \n");
desea Crear"); printf("4.- eliminar\n");
ni = Leer.datoInt (); z.crea_mp printf("5.- salir al menu principal\n");
(ni); } scanf ("%d",&ps);
else System.out.println (“Existe switch(ps)
Pilas“+n); { case 1:clrscr();cout<<"\nInt. el numero de
break; pilas...";
case 2: if (!verificalleno(n)) scanf("%d",&np);
{System.out.println ("Numero de creamm(&mp1,np);
Pila"); printf("\npilas creadas");
np = Leer.datoInt (); getch(); break;
System.out.println ("El Elmento de case 2:clrscr();
la Pila"); printf("\nelemento a adicionar");
e = Leer.dato (); z.adi_mp (e, np); scanf("%d",&e);cout<<"en que pila desea
} adicionar...";
else System.out.println (“La Pila
 CONSTRUCCIÓN DEL MENÚ PRINCIPAL
case 3:
System.out.println ("Numero de case 3:clrscr();cout<<"\nque pila desea
Pila"); listar...";
np = Leer.datoInt (); scanf("%d",&np);
z.lista_mp (np); printf("\nlos elementos de la pila son");
break; mostrarmm(mp1,np);
case 4: getch();
System.out.println ("Numero de break;
Pila"); case 4 :clrscr();
np = Leer.datoInt (); cout<<"\nintroduzca la pila a eliminar... \n";
z.elim_mp (np); scanf("%d",&np);
break; eliminarmm(&mp1,&e,np);
case 5: printf("\nelemento a eliminar");
sw = 1; printf("%d",e);
break; getch();
default: break;
System.out.println ("ERROR default:getch();break;
DE OPCION"); }
}while(ps< 5 );
} }
}
}
 COLAS SIMPLES
Def.- Es una estructura de datos que se almacena información de
una sola clase, donde se añaden, eliminan, ordenan, cambian
FILOSOFÍA.- La filosofía que se emplea es “Primero en entrar
primero en salir”, “First in, First out, FIFO”
Las colas son estructuras de datos dinámicos que almacenan
información de un solo tipo, siempre tomando la filosofía de
“Primero en entrar, primero en salir”
La cola tiene numerosas aplicaciones o analogías en la vida real.
REPRESENTACIÓN EN COMPUTADORA
Al igual que las pilas no existe una estructura definida en los
lenguajes de programación, la representación se lo realiza
mediante vectores y listas: COLA = C(1), C(2), C(3), …
 COLAS SIMPLES
CONSIDERACIONES.- La consideración que se realiza es la siguiente.
- Las adiciones se las realizan por el final (fi)
-Las eliminaciones se realizan por el frente (fr),El tamaño de la cola es tam
CONDICIONES.- Las condiciones que se realizan son las siguientes:
- Si sw = 0 entonces la pila no ha sido creada.
- Si frente = final, entonces la cola esta vacia
-Si final > tam, entonces la cola esta llena
- tam
COLA
final tam
frente

Final frente
 OPERACIONES CON COLA
OPERACIONES
Crear
Adicionar
Eliminar
Listar
Ordenar
Búsqueda
Insertar
Sumar
 //COLA SIMPLECREACIÓN DE COLAS
final int tamc = 10;
int fi, fr,x=1; //COLAS SIMPLES
Object c [] = new Object #define tamc 20
[tamc]; struct colas
void creacola () {int c[tamc];
{ fi = 1; fr = 1; x=3; int fi;
System.out.println ("\tCOLA int fr;
FUE CREADA"); };
} typedef struct colas cola;
boolean vercola () top cola c1,c2,c3;
{ if (x == 3) return true; void crea(cola *c1)
else return false; } {c1->fr=0;
boolean verificavacio () top c1->fi=0;
{ if (fi == fr) return true; cout<<"cola creada....";
else return false; } getch();
boolean verificalleno () }
{ if (fi > tamc) return true;
 voidADICIÓN ELIMINACIÓN
addcola (Object e) DE ELEMENTOS EN COLA
{ if (fi != tamc) void adiciona(cola *c1,int e)
{ c [fi] = e; fi+ {if(c1->fi>tamc) cout<<"cola
+; } llena";
else { System.out.print else
("\tLA COLA ESTA LLENA "); {c1->c[c1->fi]=e;
} c1->fi=c1->fi+1;
} }
void delcola () }
{ if (fr != fi)
{ Object e; e = c [fr]; void elimina(cola *c1,int *e)
fr++; {if(c1->fi==c1->fr){cout<<"cola
System.out.println ("\tEL vacia";}
ELEM.“+e+ "FUE else{*e=c1->c[c1->fr];
ELIMINADO"); c1->fr=c1->fr+1;
} cout<<"elemento eliminado...";
else { System.out.print }
("\tLA COLA ESTA VACIA "); }
 void lista(cola c1)
MOSTRAR ELEMENTOS DE LA COLA
{if(c1.fr!=c1.fi)
{for(int i=c1.fr;i<c1.fi;i++)
void listacola () {printf("[%d]=
{ int i; %d\n",i,c1.c[i]);getch(); } }
else {cout<<"cola vacia"; } }
if (fi != fr) void ordenar(cola *c1)
{ for (i = fr ; i < fi ; i++) {int aux;
if(c1->fi!=c1->fr)
{ System.out.print {for(int i=c1->fr;i<c1->fi;i++)
{for(int j=c1->fr;j<c1->fi-1;j++)
("\t" + "[" + c [i] + "]"); {if(c1->c[j]>c1->c[j+1])
} {aux=c1->c[j];c1->c[j]=c1->c[j+1]; c1-
>c[j+1]=aux; }} } } }
} void buscar(cola *c1)
else {int sw=0,e,aux;
cout<<"Int. el elementoa a buscar....";
{ System.out.print scanf("%d",&e);
("\tLA COLA ESTA if(c1->fr!=c1->fi)
{for(int i=c1->fr;i<c1->fi;i++) { sw=1;
VACIA"); aux=c1->c[i];
} if(e==aux)
{printf("El elem esta en la posicion %d.",e,i);
} getch(); } }
if(sw==1)
 Pilas_multiples z = new Pilas_multiples (); void colasimples()
{ int op4, b = 1; Object e; int swc
CONSTRUCCIÓN = 0; MENÚ
DEL ENdo{clrscr();
{int e,cs; JAVA Y TC++ cout<<"\t\t\t\t COLAS
while (swc == 0) SIMPLES";
{ System.out.println (); cout<<"\n\t\t1.- Crear cola....";
System.out.println ("\n\t\t**MENU cout<<"\n\t\t2.- Adicionar cola....";
COLAS**\n"); cout<<"\n\t\t3.- Elimiinar cola....";
System.out.println ("\t\t\t1.-CREAR cout<<"\n\t\t4.- Listar cola....";
COLA "); cout<<"\n\t\t5.- Ordenar cola....";
System.out.println ("\t\t\t2.-ADICIONAR cout<<"\n\t\t6.- Buscar cola....";
COLA "); cout<<"\n\t\t7.-
System.out.println ("\t\t\t3.-LISTAR Min_Max_Par_Impar_Sumatotal cola....";
COLA "); cout<<"\n\t\t8.- Salir del programa....";
System.out.println ("\t\t\t4.-ELIMINAR cout<<"\n\t\t Elija su opcion....";
COLA "); scanf("%d",&cs);
System.out.println ("\t\t\t5.-MENU switch(cs)
PRINCIPAL "); {case 1:crea(&c1);break;
System.out.println case 2:cout<<"Int el elemento
("\t\t**************\n"); adicionar....";scanf("%d",&e);
System.out.print ("\n ELIJA UNA adiciona(&c1,e);break;
OPCION :\t\t"); case 3:elimina(&c1,&e);break;
op4 = Leer.datoInt (); case 4:lista(c1);break;
switch (op4) case 5:ordenar(&c1);lista(c1);break;
{ case 1: z.creacola (); break; case 6:buscar(&c1);break;
case 2: if (!z.vercola) { case
System.out.print ("\t\t\t\t INT. UN 7:min_max_par_impar_suma(&c1);break;
 CONSTRUCCIÓN DEL MENÚ EN JAVA Y TC++
case 3:
System.out.println ("\nLA COLA
TIENE LOS SIGIENTES ELEMENTOS
::\t\t");
o.listacola ();
break;
case 4: o.delcola ();
break;
case 5: op4 swp = 1;
System.out.println ("\n\t\t
---FINALIZANDO ---\n");
swp = 0;
swc = 1;
break;
default:
System.out.println ("ELIGA SOLO LOS
NUMEROS QUE APARECEN EN LA
LISTA :.");
}
}
break;
}
 COLAS MÚLTIPLES
Definición.- Una estructura de datos se almacena información de una sola
clase, donde se añaden, eliminan, ordenan, cambiar, etc.
FILOSOFÍA.- La filosofía que se emplea es “Primero en entrar primero en
salir”, “First in, First out, FIFO”
REPRESENTACIÓN

tam

top top top top

Total = 16
 CONDICIONES, OPERACIONES CON COLAS
CONDICIONES
Dividir en el número de colas del total en partes iguales
Si fi[n] = fr[n] entonces, la cola esta vacía.
Si fi[n] > lím[n] entonces, la cola esta llena.
OPERACIONES
Crear
Adicionar
Eliminar
Listar
Ordenar (Quicksort, sacudidad, )
Búsqueda (binaria, burbuja, shell)
Intercambiar
Intercalar colas
Listar colas
//COLA MULTIPLE
CREACIÓN DE COLAS MÚLTIPLES
//COLAS MULTIPLES
final int tamcm = 100;
#define tamcm 20
Object cm [] = new Object
struct colass
[tamcm];
{int mc[tamcm]; int fr[tamcm];
int frm [] = new int [tamcm];
int fi[tamcm]; int
int fim [] = new int [tamcm];
limite[tamcm];
int lim [] = new int [tamcm];
}colasm;
int tcm;
typedef struct colass colasm;
void creacm (int t)
colasm cm1,cm2,cm3;
{ if (t < tamcm)
int tc;
{ int i; tcm = tamcm / t;
void creacmul(colasm *cm1,int n)
for (i = 1 ; i < t ; i++)
{ int i; tc=tamcm/n;
{ frm [i] = tcm * (i-1); fim [i] =
for(i=0;i<n;i++)
tcm * (i-1);
{cm1->fr[i]=i*tc; cm1-
lim [i] = (i * tcm) - 1;
>fi[i]=i*tc;
} }
cm1->limite[i]=((i+1)*tc)-1; }
else
cout<<"COLA CREADA...";
{System.out.println (“TAMAÑO
getch();
 e,int n)
ADICIÓN, ELIMINACIÓN DE{ELEMENTOS if(cm1->fi[n-1]!=cm1->limite[n-
EN COLA
1])
void addmc (int c, Object e) {cm1->mc[cm1->fi[n-1]]=e;
{ if (fim [c] < tope [c]) cm1->fi[n-1]=cm1->fi[n-1]+1;
{ cm [fim []] = e; }
fim [c]++; else
} {cout<<"COLA
else LLENA...";getch();
{ System.out.println }
(“COLA LLENA "); }
} void eliminacmul(colasm *cm1,int
} *e,int n)
Object delcm (int c) {if(cm1->fi[n-1]!=cm1->fr[n-1])
{ Object e; { *e=cm1->mc[cm1->fr[n-1]];
e = cm [frm [c]]; cm1->fr[n-1]++;
frm [c ]++; cout<<"elemento
return e; eliminado...";getch(); }
} else { printf("COLA VACIA");
 { if(cm1.fi[n-1]!=cm1.limite[n-1])
MOSTRAR ELEMENTOS EN LAS COLAS
{ for(int j=cm1.fr[n-
1];j<cm1.fi[n-1];j++)
{printf("\n[%d]=
void muestra (int c) %d",j,cm1.mc[j]);getch();}
{ System.out.print ("LA COLA } else cout<<"\ncola
" + c + " TIENE LOS vacia...";getch();
SIGUIENTES ELEMENTOS }
:\t"); void copiacmul(colasm *cm1,int
for (int i = frm [c ] ; i < fim [c] ; n)
i++) { int dato,a=cm1->fi[0];
{ cm1->limite[0]+tc;
System.out.println ("\t" + for(int j=cm1->fr[1];j<cm1-
cm [i]); >fi[1];j++)
} { dato=cm1->mc[j];
cm1->mc[cm1->fi[0]]=dato;
} cm1->fi[0]++;
printf("\n[%d]=%d",a++,cm1-
 { System.out.println ("\n\t\t COLAS {int op=0,e,n,nc; clrscr();
MULTIPLES\n"); cout<<"Introduzca el numero de colas…;
CONSTRUCCIÓN DEL MENÚ EN JAVA Y TC++
System.out.println ("\t\t\t1.-CREAR COLA scanf("%d",&n);
MULTIPLE "); do
System.out.println ("\t\t\t2.-ADICIONAR {clrscr(); cout<<"\n\t C O L A S M U L T I
ELEMENTO "); P L E S ";
System.out.println ("\t\t\t3.-ELIMINAR cout<<"\n\t1.-CREA COLAS
ELEMENTO "); MULTIPLES......" ;
System.out.println ("\t\t\t4.-MOSTRAR cout<<"\n\t2.-ADICIONA COLAS
COLA "); MULTIPLES......";
System.out.println ("\t\t\t5.-MENU cout<<"\n\t3.-LISTA COLAS
PRINCIPAL "); MULTIPLES.....";
System.out.print ("\n* ELIJA UNA cout<<"\n\t4.-COPIA DE COLAS.....";
OPCION * :\t\t"); cout<<"\n\t5.- ORDENAR
op5 = Leer.datoInt (); ASCENDENTE.....";
switch (op5) cout<<"\n\t6.- ORDENAR
{ case 1: System.out.println ("\t Int. Num DESCENDENTE......";
colas a crear"); cout<<"\n\t7.-ELIMINAR ELEMENTO.......";
aux = Leer.datoInt (); o.creacm (aux); cout<<"\n\t8.-SALIR.......";
System.out.println ("\n FUERON cout<<"\n\tELIJA UNA OPCION......";
CREADAS " + aux + " COLAS \n"); scanf("%d",&op);
break switch(op)
case 2: { case 1: creacmul(&cm1,n);break;
System.out.println ("\tINTRODUSCA EL case 2: cout<<("\nDesea adicionar el elemento
NUMERO DE LA COLA :"); aux = en la cola");
 case 3:
CONSTRUCCIÓN
System.out.println DEL MENÚ EN JAVA Y TC++
("\tINT. EL NUMERO
DE LA COLA :"); case 3: cout<<"introduzca la cola a listar...";
aux = Leer.datoInt (); aux1 = o.delcm scanf("%d",&nc);listacmul(cm1,nc); break;
(aux); case 4: nc=1;listacmul(cm1,nc);
System.out.println ("\tELEMENTO " + copiacmul(&cm1,n);break;
aux1 + " FUE ELIMINADO "); break; case 5: cout<<"que cola desea ordenar...";
case 4: if (sw == 0) scanf("%d",&nc);
{System.out.println ("\tINT. EL ascendentec(&cm1,nc); listacmul(cm1,nc);
NUMERO DE LA COLA"); break;
aux = Leer.datoInt (); o.muestra (aux); case 6: cout<<"que cola desea ordenar...";
} scanf("%d",&nc);
else { sw = 1; } descendentec(&cm1,nc);
break; listacmul(cm1,nc);
case 5: { swp = 1; break;
System.out.println ("\n\t\t regresa al case 7: cout<<"de que cola desea eliminar...";
menu principal\n"); scanf("%d",&nc);
swp = 0; swcm = 1; op5 = 5; eliminacmul(&cm1,&e,nc); break;
break; default:getch();break;
} }
default: }while(op!=8);
System.out.println ("ELIJA NUMEROS cout<<"YA PUEDE SALIR.";
QUE APARECEN EN LA LISTA :."); getch();
} }
 COLAS CIRCULARES
Definición.- Las estructuras de colas circulares son las más eficientes en la
disponibilidad de la memoria y los elementos se administran de la siguientes
manera:
- Se adicionan los elem una tras otra similar a las colas por el extremo final (fi)
- Se eliminan los elementos mediante el extremo frente (fr).
FILOSOFÍA.- La filosofía que se sigue empleando “Primero en entrar primero
en salir”, “First in, First out, FIFO” pero dentro de la cola circular.
REPRESENTACIÓN
CC() = CC(1), CC(2), CC(3), … tam
JOSE
CC MARIA 1 2 3 4 5 6 7

TITO RENATA RENE MARIA JESE

RENE TITO DEMTRIO MAGALY
CC=
MAGALY
fi RENATA fr fr fi
 COLAS CIRCULARES
CONDICIONES
Dividir en el número de partes iguales
Si fi (final) = fr (frente) entonces, la pila esta vacía.
Si (fi+1) % tam = fr entonces, la cola circular está llena.
EMPLEANDO
El mod para los diferentes procesos (numerodad-([numerodado/base]*base))
OPERACIONES
Crear, Adicionar
Eliminar, Listar
Ordenar, Búsqueda
Intercambiar elementos, Sumar elementos
Eliminar elemento deseado
 DEFINICIÓN Y CREACIÓN DE COLA
//COLA CIRCULAR
import java.io.*; //COLAS CIRCULARES
class colacir #define tamcc 3
{ int fi, fr, i, tam = 6; struct colasci
Object cc[] = new Object {int cc[tamcc];
[tam]; int fi,fr;
colacir () }colascc;
{ fi = 0; typedef struct colasci colascc;
fr = 0; colascc cc1,cc2,cc3;
}
void adcc (Object e) void crea(colascc *cc1)
{ if ((fi + 1) % tam != fr) {cc1->fi=1;
{ cc [fi] = e; cc1->fr=1;
fi = (fi + 1) % tam; cout<<"cola circular creada...";
} getch();
else System.out.println }
("COLA LLENA");
 CONCEPTOS GENERALES
Object delcc ()
void adiciona(colascc *cc1,int e)
{ fr = (fr + 1) % tam; return (cc [fr]); } {if(cc1->fi+1%tamcc<=tamcc)
void listacc () {cc1->cc[cc1->fi]=e;
{ int i; i = fr;
while (i != fi)
cc1->fi++;
{ System.out.println ("" + cc [i]); cout<<"elemento adicionado...";
i = (i + 1) % tam; } getch();
}
int buscacc (colacir cc1, Object e)
}else cout<<"cola llena";getch();
{ colacir cc2 = new colacir (); }
int i = cc1.fr, res = 0; void elimina(colascc *cc1,int *e)
Object dato;
while ((cc1.fi) % tam != cc1.fr)
{if(cc1->fr+1%tamcc!=cc1-
{ dato = cc1.delcc (); >fi+1%tamcc)
if (dato == e) { res = 1; } {*e=cc1->cc[cc1->fr];
cc2.adcc (dato);
} i = cc2.fr;
cc1->fr=cc1->fr+1%tamcc;
while ((cc2.fi) % tam != cc2.fr) cout<<"elemento eliminado...";
{ dato = cc2.delcc (); }else {cout<<"cola circular
cc1.adcc (dato); }
return res;
vacia";getch();}
} }
 int buscacc (int x)
{ int c, y = 0;
MOSTRAR ELEMENTOS
for (int i = fr ; i < fi ; i++)
EN LA COLA
{ c = 0; for (int j = fr ; j < fi ; j+
+)
{if (x == Integer.parseInt (cc
[j].toString ()))
{y = Integer.parseInt (cc void lista(colascc *cc1)
[j].toString ()); } {int a1;
c++; if(cc1->fr!=cc1->fi)
} {a1=cc1->fr;
} return y; while(a1!=cc1->fi)
} {printf("\n[%d]",cc1->cc[a1]);
a1=a1+1;
void ordenacc ()
}
{ Object aux; }else cout<<"cola vacia";getch();
if (fr != fi) }
{ for (int i = fr ; i < fi ; i++)
{ for (int j = i + 1 ; j < fi ; j++)
{if (Integer.parseInt (cc [i].toString
()) > Integer.parseInt (cc [j].toString ()))
{ aux = cc [i]; cc [i] = cc [j]; cc [j] =
aux; } } }
} else{System.out.print("\tCola
 CONSTRUCCIÓN DEL MENÚ EN JAVA Y TC++
boolean verificavacio ()
{ if (fi == fr) return true; void colascirculares()
else return false; {int po,e;
} do
boolean verificalleno () {clrscr();
{ if (fi >= tam) return true; printf("\n1. crear cola CIR");
else return false; printf("\n2. adicionar cola CIR");
} printf("\n3. eliminar ELEMTO");
int menu () printf("\n4. listar cola");
{ int op; printf("\n5. salir cola");
System.out.println (“**/ MENU COLAS cout<<"\neliga una opcion..." ;
CIRCULARES/**"); cin>>po;
System.out.println ("1.- ADICIONAR switch (po)
"); {
System.out.println ("2.- ELIMINAR"); case 1: crea(&cc1); break;
System.out.println ("3.- MOSTRAR"); case 2: cout<<"Digite el elemento que desea
System.out.println ("4.- BUSCAR"); adicionar";
System.out.println ("5.- ORDENAR"); scanf("%d",&e); adiciona(&cc1,e); break;
System.out.println ("6.- SALIR"); case 3: elimina(&cc1,&e); break;
System.out.print ("ELIEGIR UNA case 4: lista(&cc1);getch(); break;
OPCION:::>"); default:exit(0); break;
op = Leer.datoInt (); }
return op; }while(po!=5);getch();
 CONSTRUCCIÓN DEL MENÚ EN JAVA Y TC++
class Colascirculares void listacc ()
{ int fi, fr, i, tam = 10; { int i; i = fr;
Object cc [] = new Object while (i != fi)
[tam]; { System.out.println
Colascirculares () ("posicion " + i + " [" + cc [i]
{ fi = 0; fr = 0; + "]");
System.out.println ("\nCola i = (i + 1) % tam; } }
creada"); } void suma ()
void adcc (Object e) { int s = 0, i = fr;
{ cc [fi] = e; fi = (fi + 1) while (i != fi) { s = s +
% tam; } Integer.parseInt (cc
Object delcc () [i].toString ()); i = (i + 1) %
{ Object x; x = cc [fr]; fr = tam; }
(fr + 1) % tam; return (x); System.out.print ("LA
} SUMA DE ELEMENTOS
void buscaelemento (int x)
{ for CONSTRUCCIÓN
(int i = fr ; i != fi ; i DEL
= (i +MENÚ
ObjectEN JAVA Y(Object
delensupos TC++dato)
1) % tam) { int sw = 0; Object aux; int i = fr;
{ if (x==Integer.parseInt (cc while (i < fi)
[i].toString())) {if (Integer.parseInt
{System.out.println ("SE (cc[i].toString())==dato){ sw = 1;
while (i>fr) {cc [i]=cc[i-1]; i=(i-
ENCONTRO EN LA 1)%tam; }
POSICION\t"+i); } } } delcc (); i = fr; }
void ordenacc () else { i = (i + 1) % tam; }
{ Object aux; } listacc (); return sw; }
for (int i = fr ; i != fi ; i = (i + 1) void intercambiar (int n, int m)
{ int i=fr, sw =0, sw1 = 0; Object aux;
% tam) System.out.print ("\n
{for (int j = i + 1 ; j != fi ; j = (j INTERCAMBIO\n");
+ 1) % tam) while (i != fi && sw == 0){ if (i==n)
{ if (Integer.parseInt (cc { sw= 1; int j = fr;
[i].toString ()) > Integer.parseInt while (j != fi && sw1 == 0)
{if (j == m) {sw1=1;aux=cc[i];cc [i]=cc
(cc [j].toString ())) { [j]; cc [j] = aux; }
aux=cc [i]; cc [i] = cc [j]; cc else j = (j + 1) % tam; }
[j]=aux; } } else i = (i + 1) % tam;
 //public static void main(String args[])
CONSTRUCCIÓN DEL MENÚ ENstatic
public JAVAvoid Y TC++
colas_circulares ()
{ int op, a, b; Object e;
Colascirculares cc1 = new Colascirculares
boolean vervacio () ();
do
{ if (fr == fi) { System.out.println ("\n\t *COLAS
return true; CIRCULARES*");
System.out.println ("\t\t1.-
else ADICIONAR");
System.out.println ("\t\t2.-
return false; ELIMINAR");
} System.out.println ("\t\t3.-LISTAR");
System.out.println ("\t\t4.-BUSCA
boolean verlleno () ELEMENTO");
{ if ((fi + 1) % tam == fr) System.out.println ("\t\t5.-ORDENA");
System.out.println ("\t\t6.-ELIMINA
ELEMENTO DESEADO");
return true; System.out.println ("\t\t7.-INTERCAMBIA
ELEMENTOS");
else System.out.println ("\t\t8.-SUMA LOS
return false; ELEMENTOS");
System.out.println ("\t\t0.-RETORNAR AL
} PRINCIPAL");
System.out.print ("\t\tELIJA UNA
 else System.out.print ("\nCola
CONSTRUCCIÓN DEL MENÚ
llena"); break; case 7:ENifJAVA
(!cc1.vervacio
Y TC++ ())
case 2: if (!cc1.vervacio()) { e = { cc1.listacc ();
cc1.delcc (); System.out.print ("QUIERE
System.out.println ("El dato eliminado INTERCAMBIAR LA POSICION-->\t");
fue" + e); } a = Leer.datoInt ();
else System.out.print ("\nCola System.out.print ("CON LA
vacia"); break; POSICION-->\t\t\t"); b = Leer.datoInt ();
case 3: if (!cc1.vervacio()) cc1.intercambiar (a, b); }
{ System.out.println ("Los datos de la else System.out.print ("\nCola vacia");
cola son:"); cc1.listacc (); } break;
else System.out.print ("\nCola case 8: if (!cc1.vervacio ()) { cc1.suma
vacia"); break; (); }
case 4: System.out.print else System.out.print ("\nCola vacia");
("\tELEMENTO BUSCA->"); break;
b = Leer.datoInt (); case 0: op=0;
cc1.buscaelemento (b); break; System.out.println("<=ELIJA UNA
case 5: if (!cc1.vervacio ()) OPCION DEL MENU PRINCIPAL");
{ cc1.ordenacc (); cc1.listacc (); } break;
else System.out.print ("\nCola default: System.out.println
vacia"); break; ("\t\terror!!"); }
case 6: if (!cc1.vervacio ()) }
while (op != 0);