Estructura de Datos

ITSP

UNIDAD lll. ESTRUCTURAS LINEALES, ESTTICAS Y DINMICAS

3.1 PILAS
Una pila (stack) es una estructura de datos, que consta de una serie de
datos, en la cual las inserciones y eliminaciones se hacen por un extremo,
llamado cima (top), de la pila. La estructura pila se conoce tambin como
LIFO (Last-in, First-out, ltimo en entrar primero en salir), que significa,
ultimo elemento introducido, primero sacado.
Una pila permite almacenar y recuperar datos mediante operaciones push
(apilar) y pop (desapilar) estas operaciones se realizan sobre un nico
extremo llamado cima.
Por analoga con objetos cotidianos, una operacin push equivaldra a colocar
un plato sobre una pila de platos, y un pop a retirarlo.
Esto quiere decir que con una operacin pop se obtiene el elemento que se
aadi la ltima vez en la pila (el que se encuentre en la parte superior, al
mismo tiempo que lo elimina de la fila).
Las pilas suelen emplearse con los siguientes contextos:
A) Evaluacin de expresiones en notacin postfija, notacin polar inversa.
B) Reconocedores sintcticos de lenguajes independientes del contexto.
C) Implementacin de recursividad.

Las operaciones bsicas que se asocian con una pila son:

Crear o inicializar

Inicializa una pila (p) vaca

Pila vaca (empty)

Verifica si una pila esta vaca

Meter (push)

Inserta un elemento en la cima de la pila

Pagina 25

Estructura de Datos
Sacar (pop)

ITSP
Recupera y elimina el ltimo elemento en la
cima de la pila.

Pila llena (full)

Verifica si una pila esta llena y no se pueden

insertar mas elementos.

Representacin de la estructura pila

En teora el tamao de una pila no esta limitado; sin embargo, en la prctica
de la programacin existe una limitacin fsica en el espacio reservado en
memoria.
Una estructura pila puede ser realizada en Java utilizando un vector cuyo
tamao sea lo suficientemente grande para alojar los elementos iniciales, as
como todas las posibles inserciones que se pueden hacer.
La variable cima contiene el nmero de elementos actualmente en la pila y
puede ser utilizada como un subndice o como un puntero al elemento
superior de la pila. Si una pila no tiene elementos, se dice que es una pila
vaca. La variable o puntero cima se incrementa en uno al poner un elemento
en la pila y se decrementa en uno al quitar el elemento.
Pese a la similitud, es preciso notar que una pila no es igual que un vector.
Una pila, es por esencia, un objeto dinmico, mientras que un vector tiene un
numero mximo de elementos, determinado por su definicin; no es, pues,
mas que una representacin de la nocin abstracta.
La estructura pila se realiza con un vector, cuyo ndice representa el rango de
un elemento de la pila.

Pagina 26

Estructura de Datos

ITSP

Errores con pilas

Antes de describir la realizacin de una pila y sus operaciones bsicas vamos
a considerar las posibles situaciones de error que se pueden presentar:
1.- Intentar meter un elemento en una pila llena (error de desbordamiento,
over-flow).
2.- Intentar sacar un elemento de una pila vaca (error de desbordamiento
negativo underflow).
Las operaciones pila llena y pila vaca devuelven true si la pila esta llena o
vaca, y false en caso contrario.
Cdigo de la estructura Pila
A continuacin de describe cada una de los mtodos y atributos de la clase
pila.
Existe una clase llamada Pila, que contiene cada uno de los mtodos para
manipulacin de la estructura.
Con esa clase, se pueden crear objetos de la clase Pila y manipularlos desde
otra clase, tal como se muestra en el ejemplo UsoPilas.
Clase PILA
public class Pila {
int TOTAL;
int cima;
int DATOS[];

Pagina 27

Estructura de Datos

ITSP

// Constructor de la clase Pila

public Pila(int x)
{
this.TOTAL = x;
this.DATOS=new int [x];
this.cima = 0;
}
// Mtodo Insertar
public void Push(int valor)
{
DATOS[cima]=valor;
cima++;
}
// Mtodo Eliminar
public int Pop()
{
int aux;
cima--;
aux = DATOS[cima];
return aux;
}
// Mtodo que verifica si la pila esta vaca.
public boolean Empty()
{
if (cima == 0)
return true;
else
return false;
}

Pagina 28

Estructura de Datos

ITSP

// Mtodo que verifica si la pila esta llena

public boolean Full()
{
if (cima == TOTAL)
return true;
else
return false;
}
// Mtodo que retorna los datos de la pila. Retorna un arreglo
public int [] RetornaPila()
{
return DATOS;
}
// Mtodo que retorna el total de elementos insertados en la
pila.
public int RetornaCima()
{
return cima;
}
}

Clase USOPILAS.
Leer 5 valores e insertarlos a una pila, retornar el total de elementos y los
datos sin sacarlos y visualizarlos en pantalla.
import java.io.*;
import java.awt.*;
public class UsoPilas {
public static void main(String[] args) throws IOException {

Pagina 29

Estructura de Datos

ITSP

Pila p;
BufferedReader c;
int x,y, tot;
int A[];
String linea;
c = new BufferedReader (new InputStreamReader(System.in));
p = new Pila(10);
for (i = 1; i <= 5; i++)
{
linea = c.readLine();
x= Integer.parseInt(linea);
p.Push(x);
}
tot = p.RetornaCima();
A= p.RetornaPila();

//Recupera el total de elementos

//Recupera el arreglo de elementos

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

System.out.println(A[i]);
}
}

Pagina 30

Estructura de Datos

ITSP

Ejercicios de Pilas.
1) Crear una pila de 10 elementos, que saque cada uno de los elementos
y lo despliegue en pantalla. Ejemplo
Entrada

1, 2, 3, 4,5

Salida

5, 4, 3, 2,1

2) Crear un programa que lea una pila de 10 elementos, que solicite un

numero a buscar y que saque los nmeros hasta que encuentre ese
elemento o se vaci visualizar los elementos restantes de la pila. Por
ejemplo
Elementos 1, 2, 3, 4, 5, 6, 7, 8, 9,10
Elemento a buscar 6 los elementos que se sacaran de la pila seria 10, 9,
8, 7,6
Visualizacin de la pila 1, 2, 3, 4,5
3) Crear una pila de mximo 10 elementos se van a insertar valores a la
pila mientras capture un -1 o la pila se llene. Calcular y desplegar:
a. Los elementos insertados
b. El total de elementos insertados
c. Suma de los elementos
d. Promedio de elementos
e. Total de elementos pares
f. Elemento mayor
4) Crear un programa que genere 2 pilas de elementos 5 mximo cada
una. El usuario captura elementos en cada una hasta que se de cero.
Sacar y agregar los elementos de la pila en una tercera pila.
Visualizar los elementos de la pila. Ejemplo:

Pagina 31

Estructura de Datos

ITSP

Pila 1: 8, 4, 5,0
Pila 2: 3, 7,0

5
4
8
Pila 1

7
3
Pila 2

3
7
8
4
5
Pila 3

3.2 COLA.
Pagina 32

Estructura de Datos

ITSP

El diccionario de la real academia define una acepcin de cola como hilera

de personas que esperan turno para alguna cosa; una hilera de vehculos
esperando pasar una frontera, una hilera de personas para entrar en un
teatro, una hilera de aviones en la pista en espera de despegar, o una cola de
trabajo en un sistema de computadora que espera la disponibilidad de algn
dispositivo de salida tal como una impresora. En cada uno de estos ejemplos,
los elementos se atienden en el orden en que llegaron; es decir, el primer
elemento en entrar (primero en la cola) es el primero en ser atendido (salir).
Una cola es una estructura de datos de tipo FIFO (First in, Fisrt Out) que
permite

almacenar

datos

del

mismo

tipo.

Las

colas

pueden

ser

implementadas utilizando memoria esttica o memoria dinmica.

Para el control de una cola se requieren 2 apuntadores uno que indique el
principio de la cola por donde se sacaran los elementos y otro que indique el
final por donde entraran los elementos.
Por consiguiente, mientras que una pila es una estructura LIFO, una cola es
una estructura FIFO, primero en entrar primero en salir, tambin llamada a
veces estructura FCFS (First Come First Server: primero que llega, primero
que se atiende).
Al igual que las pilas, las colas son estructuras de datos en las cuales las
operaciones bsicas de aadir y eliminar elementos se realiza en los
extremos de la lista. Al contrario en las pilas cuyos elementos se aaden y
borran por un extremo de la lista, en las colas los elementos se borran por
un extremo, llamado frente o cabeza (front, head), de la cola y los elementos
se aaden por el otro extremo, llamado final o fin (rear, tail).
Las operaciones bsicas a realizar una cola son:

Pagina 33

Estructura de Datos

ITSP

Crearcola(Q)

Crea una cola vaca (sin elementos)

Colavacia(Q)

Determina si una cola esta vaca; devuelve true si

la cola esta vaca, false en caso contrario.

Colallena(Q)

Devuelve True si la cola esta llena; false en caso

contrario.

Insertar(Q,X)

aadir un elemento al final de la lista (siempre y

cuando la cola no este llena)

Borrar(Q,X)

Recupera y elimina el elemento que esta al

principio (frente) de la cola

Elementoscola(Q)

Devuelve el numero de elementos existentes en la

cola.

APLICACIONES DE LAS COLAS

Las colas se utilizan con frecuencia en los sistemas informticos, siempre que
ms de un proceso requiera un recurso especfico, tal como una impresora,
una unidad de disco o la unidad central de proceso. Tales procesos, al
solicitar un recurso especfico, se sitan en una cola a la espera de atender a
ese recurso. Por ejemplo, diferentes computadoras pueden compartir la
misma impresora, y una cola spool se utiliza para planificar las diferentes
salidas. Si una peticin para un trabajo de impresin se realiza y la impresora
esta libre, se le asigna inmediatamente ese trabajo. Mientras esa salida se
esta imprimiendo, otras tareas pueden necesitar la impresora. Se sitan en
una cola de tipo spool para esperar su turno. Cuando la salida del trabajo
actual termina, la impresora se libera de ese trabajo y se asigna a la primera
tarea de la cola.
Otro uso importante de las colas en un sistema informtico es para
operaciones de acoplamiento o adaptacin de entrada/salida (input/output

Pagina 34

Estructura de Datos

ITSP

buffering). La transferencia de informacin, desde un dispositivo de entrada o

desde un dispositivo de entrada/salida, es una operacin relativamente lenta,
y si el proceso de un programa debe ser suspendido mientras se transfieran
los datos, la ejecucin del programa se ralentiza drsticamente.
Una solucin frecuente a este problema utiliza secciones de memoria
principal conocidas como memorias intermedias (buffers) y transfiere datos
entre el programa y estas memorias intermedias, en lugar de entre el
programa y el dispositivo de entrada/salida directamente.
En particular, considrese el problema en el cual los datos procesados por un
programa se leen en un archivo de disco. Esta informacin se transfiere
desde el archivo de disco hasta una memoria intermedia de entrada en
memoria principal mientras la unidad central de proceso (CPU) esta
ejecutando alguna otra cosa. Cuando el programa necesita los datos, se
recuperan los siguientes valores almacenados en la memoria intermedia. La
memoria intermedia (buffer) debe ser organizada como una estructura
primero en entrar primero en salir, es decir, una cola. Una condicin de
cola vaca indica que la memoria intermedia esta vaca y la ejecucin del
programa se suspende mientras el sistema operativo intenta cargar ms
datos en la memoria intermedia o seala el fin de la entrada. Naturalmente,
tal memoria intermedia tiene un tamao limitado, y por consiguiente una
condicin de cola llena se debe utilizar para indicar cuando la memoria
intermedia esta llena y ningn dato ms se tiene que transferir desde el
archivo de disco hasta la misma.

DECLARACIN DE UNA COLA

Pagina 35

Estructura de Datos

ITSP

Para utilizar una cola se utiliza una clase con los siguientes atributos:

Frente

Final o atrs

Datos, donde se almacenara cada uno de los elementos de la cola.

Colas circulares.
Supongamos un vector para representar a una cola. Se realizan las
siguientes inserciones:
Insertar (30);
Insertar (75);
Insertar (55);
La cola seria:
Atrs=3

30

75

55

Frente=0

Supongamos que se eliminan elementos:

Eliminar

Se eliminara el 30

Eliminar

Se eliminara el 75

Atrs=3

Pagina 36

Estructura de Datos

ITSP

55

Frente=0

Si se requiere Insertar nuevamente:

Insertar (80);
Insertar (65);
Insertar (10);

El valor 10 ya no se insertara porque parecera que la cola esta llena.

Final=5

55

80

65

Frente=0

Mas sin embargo como se puede apreciar en la figura anterior, el vector esta
vaci al principio, por lo que la solucin seria una cola circular.
El vector circular se puede realizar fijando el ndice del arreglo en 0 e
incrementando frente y atrs.

Pagina 37

Estructura de Datos
Insertar 50
Insertar 40
Insertar 30

ITSP

Frente
0

50

40

Atras

30
2

Pagina 38

Estructura de Datos

ITSP

Eliminar
Eliminar

Frente

Atras

30
2

Pagina 39

Estructura de Datos

ITSP

Atras
Insertar 75
Insertar 55

4
55

1
75

30
2
Frente
Determinar cola vaca o cola llena
Para determinar si la cola esta vaca se tiene que verificar la condicin
frente=atrs. Inicialmente, CrearCola fijara frente y atrs, ambas a cero.
Si la cola tiene un solo elemento, debe estar en la posicin frente y atrs es
la posicin libre siguiente a ella. Si este elemento se suprime, frente se
incrementa en 1, de modo que frente y atrs tienen el mismo valor cuando la
cola esta vaca.

Pagina 40

Estructura de Datos

ITSP

Atras
Frente

Cola Vaca
1

Atras
Frente

50

55

Cola LLena

60
22

34
2
Nodo de Sacrificio.
Si un elemento se almacena en esa posicin, atrs se incrementa en 1 y por
consiguiente tendr el mismo valor que frente. Sin embargo, la condicin
frente=final indica que la cola esta vaca. Por tanto, no podremos diferenciar
entre una cola vaca y una cola llena, si esta posicin se utiliza para
almacenar un elemento. Se puede evitar esta dificultad, si se mantiene una
posicin vaca (libre) en el arreglo; la condicin que indica si una cola esta
llena es entonces:

Pagina 41

Estructura de Datos

ITSP

(Atrs+1)% MaxCola == frente

Para mover los apuntadores de la cola sern:
Atrs = (atrs+1) % MaxCola;
frente = (frente+1) % MaxCola;
donde: MaxCola es el nmero del tamao mximo de la cola.
Cdigo de la estructura cola.
A continuacin de describe cada una de los mtodos y atributos de la clase
cola.
Se utiliza una clase Cola, que contiene todas las operaciones de la
estructura Cola.
En la clase Uso de Colas, se puede crear objetos para manipular la
estructura cola.
Clase COLA.
public class Cola{
int TOTAL;
int frente, atras;
int DATOS[];
// Constructor de la clase Cola
public Cola(int x)
{
this.TOTAL = x;
this.DATOS=new int [x+1];

Pagina 42

Estructura de Datos

ITSP

this.frente = 0;
this.atras = 0;
}
// Mtodo que inserta elementos.
public void Insertar(int valor)
{
DATOS[atras]=valor;
atras = (atras + 1 ) % TOTAL;
}
// Mtodo que elimina elementos de la cola.
public int Eliminar()
{
int aux;
aux = DATOS[frente];
frente = (frente + 1 ) % TOTAL;
return aux;
}
// Mtodo que verifica si la cola esta vaca.
public boolean Vacio()
{
if (frente == atras)
return true;
else
return false;
}
// Mtodo que verifica si la cola esta llena
public boolean Lleno()
{
int sig;
sig = (atras + 1 ) % TOTAL;
if (sig == frente)

Pagina 43

Estructura de Datos

ITSP

return true;
else
return false;
}
// Mtodo que retorna el arreglo de los datos
public int [] RetornaCola()
{
return DATOS;
}
}

Clase USOCOLA.
Leer 5 valores e insertarlos a una cola, sacar cada elemento de la misma
hasta que la cola se quede vaci y visualizarlos en pantalla.

import java.io.*;
import java.awt.*;
public class UsoColas {
public static void main(String[] args) throws IOException {
Cola cola;
BufferedReader c;
int i, x,y, tot;
String linea;
c = new BufferedReader (new InputStreamReader(System.in));
cola = new Cola(10);
for (i = 1; i <= 5; i++)
{

Pagina 44

Estructura de Datos

ITSP

linea = c.readLine();
x= Integer.parseInt(linea);
cola.Insertar(x);
}
while (!cola.Vacio())
{
y = cola.Eliminar();
System.out.println(y);
}
}
}

Pagina 45

Estructura de Datos

ITSP

Ejercicios de Colas.
1. Generar una cola de 10 enteros. Sacar cada elemento de la cola y
visualizarlo en pantalla capturando los siguientes elementos:
a) Suma de elementos insertados
b) Promedio de los elementos
c) Numero de elementos pares
d) Numero de elementos mltiplos de 4
Visualizar el resultado de los clculos anteriores

2. Generar una cola con los primeros 15 nmeros primos. Sacar cada
elemento de la cola y visualizarlo en pantalla.
3. Declarar una cola de mximo 10 elementos. Leer un nmero e insertar a
la cola los nmeros que sean divisores del nmero capturado. El total de
nmeros insertados depender de que la cola se llene o que la cantidad de
nmeros divisores sean pocos. Sacar y visualizar los elementos de la cola.
4. Hacer un programa que lea 2 colas de 10 elementos y que declare otra
cola de 20 y que realice la mezcla de ambas colas. Visualizar la tercera cola
sin sacar los elementos.

Pagina 46

Estructura de Datos

ITSP

3.3 LISTAS ENLAZADAS

Estructuras de datos por esencias dinmicas. Permite almacenar elementos
del mismo tipo de datos cuya limitante en tamao depende de la capacidad
de memoria Ram.
La lista enlazada es un TDA (Tipo de dato Abstracto) que nos permite
almacenar datos de una forma organizada, al igual que los vectores pero, a
diferencia de estos, esta estructura es dinmica, por lo que no tenemos que
saber "al inicio" los elementos que puede contener.
En una lista enlazada, cada elemento apunta al siguiente excepto el ltimo
que no tiene sucesor y el valor del enlace es null. Por ello los elementos son
registros que contienen el dato a almacenar y un enlace al siguiente
elemento. Los elementos de una lista, suelen recibir tambin el nombre de
nodos de la lista.
Esquema de un nodo y una lista enlazada.

null

El elemento que forma a la lista es el nodo que es una estructura

autorreferenciable, es decir que enlaza a una estructura como el.

Pagina 47

Estructura de Datos

ITSP

Las listas pueden ser de un solo enlace o apuntador de 2 enlaces, de 4

enlaces o de n enlaces.
El Dato se refiere al dato o conjunto de datos que se desea almacenar en la
lista. El enlace contendr la direccin en memoria del siguiente nodo.
Cuando un apuntador no tiene enlazado a ningn otro nodo su valor es null
(vaci).
Las operaciones bsicas de una lista enlazada son:

Insertar: inserta un nodo con dato x en la lista, pudiendo realizarse

esta insercin al principio o final de la lista o bien en orden.

Eliminar: elimina un nodo de la lista, puede ser segn la posicin o por

el dato.

Buscar: busca un elemento en la lista.

Localizar: obtiene la posicin del nodo en la lista.

Vaciar: borra todos los elementos de la lista

DIFERENCIAS ENTRE LISTAS Y ARREGLOS

-

En las lista no existen ndices

Las variables que identifica a la lista solo conoce el primer nodo. Para
acceder al resto de los nodos se hace a travs del apuntador de cada
nodo.

No hay un tamao predefinido de nodos (total), por lo que cada vez

que se requiera, hay que solicitar la creacin de un nuevo nodo.

Pagina 48

Estructura de Datos

ITSP

Listas doblemente enlazadas.

Introduccin.
El TDA lista doblemente enlazada, al igual que la lista enlazada, es un TDA
dinmico lineal pero, a diferencia de este, cada nodo de la lista doblemente
enlazada contiene dos punteros, de forma que uno apunta al siguiente nodo
y el otro al predecesor. Esta caracterstica, permite que se pueda recorrer la
lista en ambos sentidos, cosa que no es posible en las listas simples.

Cdigo de la estructura lista simple

A continuacin de describe cada una de los mtodos y atributos de la clase
lista simple.
La lista simple puede manipularse como una Pila o como una Cola,
dependiendo del tipo de insercin que se realiza o del tipo de eliminacin.
A una lista simple, se pueden insertar los elementos al inicio, al final o en
medio. As como la eliminacin de los nodos en cualquier posicin.
Para la implementacin de listas, se requiere una clase Nodo que almacene
los atributos y operaciones bsicas de manejo de apuntadores.

Pagina 49

Estructura de Datos

ITSP

Cdigo para utilizar una Pila con listas simples.

Clase NODOPILA.
public class NodoPila {
int info;
NodoPila apuntador;
public NodoPila(int contenido, NodoPila l)
{
info = contenido;
apuntador = l;
}
public NodoPila ObtenerApuntador()
{
return apuntador;
}
public int ObtenerInfo()
{
return info;
}

Pagina 50

Estructura de Datos

ITSP

Clase PILADINAMICA.
public class PilaDinamica {
NodoPila p;
public PilaDinamica()
{
p = null;
}
public void Push(int valor)
{
NodoPila nuevo;
nuevo = new NodoPila (valor, p);
p = nuevo;
}
public int Pop()
{
int valor;
valor = p.ObtenerInfo();
p = p.ObtenerApuntador();
return valor;
}
public boolean Empty()
{
if (p == null)
return true;
Pagina 51

Estructura de Datos

ITSP

else
return false;
}
}

Clase USOPILADINAMICA.
//Leer elementos enteros e insertarlos a una pila, hasta que se capture -1.
//Sacar cada elemento y visualizarlo en pantalla.

import java.io.*;
public class UsoPilaDinamica {
public static void main(String[] args) throws IOException {
int num;
String linea;
BufferedReader t;
PilaDinamica pila;
t = new BufferedReader (new InputStreamReader(System.in));
pila = new PilaDinamica();
System.out.println("Captura nmeros y finaliza con -1");
linea = t.readLine();
num = Integer.parseInt(linea);
while (num!= -1)
{
pila.Push(num);
Pagina 52

Estructura de Datos

ITSP

linea = t.readLine();
num = Integer.parseInt(linea);
}
System.out.println("Visualizacin de elementos");
while (!pila.Empty())
{
System.out.print("Elemento ");
num = pila.Pop();
System.out.println(num);
}
}

Cdigo para utilizar una Cola con listas simples.

Clase NODOCOLA.

public class NodoCola {

int info;
NodoCola apuntador;
public NodoCola(int contenido)
{
info = contenido;
apuntador=null;
}

Pagina 53

Estructura de Datos

ITSP

public NodoCola ObtenerApuntador()

{
return apuntador;
}
public int ObtenerInfo()
{
return info;
}

}
Clase COLADINAMICA.
public class ColaDinamica {
NodoCola c;
public ColaDinamica()
{
c = null;
}
public void Insertar(int valor)
{
NodoCola nuevo, aux;
if (c == null)
{
nuevo = new NodoCola (valor);
this = nuevo;
Pagina 54

Estructura de Datos

ITSP

}
else
{
aux = c;
while(aux.ObtenerApuntador()!=null)
aux = aux.ObtenerApuntador();
nuevo = new NodoCola (valor);
aux.apuntador = nuevo;
}
}
public int Borrar()
{
int valor;
valor = c.ObtenerInfo();
c = c.ObtenerApuntador();
return valor;
}
public boolean Vacio()
{
if (c == null)
return true;
else
return false;
}
Pagina 55

Estructura de Datos

ITSP

Clase USOCOLADINAMICA
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class UsoColaDinamica {

public static void main(String[] args) throws IOException {
int num;
String linea;
BufferedReader t;
ColaDinamica cola;
NodoCola aux;
t = new BufferedReader (new InputStreamReader(System.in));
cola = new ColaDinamica();
System.out.println("Captura nmeros y finaliza con -1");
linea = t.readLine();
num = Integer.parseInt(linea);
while (num!= -1)
{
cola.Insertar(num);
linea = t.readLine();
num = Integer.parseInt(linea);
Pagina 56

Estructura de Datos

ITSP

}
aux = cola.c;
System.out.println("Visualizacin de elementos");
while (!cola.Vacio())
{
System.out.print("Elemento ");
num = cola.Borrar();
System.out.println(num);
}
System.out.println("Visualizacin de elementos");
while (aux!= null)
{
System.out.print("Elemento ");
num = aux.info;
System.out.println(num);
aux = aux.ObtenerApuntador();
}
}
}

Pagina 57

Estructura de Datos

ITSP

Ejercicios de Listas.
1. Se desea almacenar las edades de personas en una estructura de
datos. Sacar cada elemento y mostrar en pantalla solamente los
mayores de edad. Mayor de edad arriba de 18 anos.
2. Almacenar en una estructura de datos, los sueldos de los trabajadores
de una empresa. Sacarlos y obtener los siguientes resultados:
a. Sumar los sueldos base.
b. A cada sueldo se le da 1% de prestaciones. Realizar la suma de
las prestaciones.
c. A cada sueldo se le aplica el 1.5% de deducciones. Realizar la
suma de las deducciones.
3. Se desea almacenar el nombre de alumnos en una estructura de
datos. Sacar cada elemento y visualizar en pantalla solamente los que
inician con M.
4. Almacenar nmeros divisores del 1000 en una estructura de datos.
5. Almacenar nmeros en una estructura de datos. Sacar cada nmero,
visualizarlo en pantalla, as como el factorial de ese numero.

Pagina 58