TECNOLÓGICO NACIONAL DE MÉXICO

CAMPUS TUXTLA GUTIERREZ

EXTENSION SAN MARTIN CHAMIZAL

Tecnológico Nacional de México

Campus Tuxtla Gutiérrez
Extensión San Martin Chamizal.

Asignatura: Estructura de Datos.

Docente: ING. FEBE GUZMÁN VAZQUEZ.

ALUMNO: ARTEMIO HERNNADEZ GALLEGOS.

TRABAJO: REPORTE DE PRACTICAS

 ESTRUCTURAS LINEALES.

FECHA DE ENTREGA: 09/10/18

 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

Índice
Introducción:....................................................................................................................... 3
3.1 Pila: ................................................................................................................................. 4
3.1.1 Representación en Memoria: ........................................................................... 4
3.1.2 Operaciones Básicas: ........................................................................................ 4
Código: ............................................................................................................................. 4
3.2 Cola: ............................................................................................................................... 8
3.2.1 Representación en Memoria: ........................................................................... 8
3.2.2 Operaciones Básicas: ........................................................................................ 8
Código: ............................................................................................................................. 8
3.2.4 Aplicaciones: ...................................................................................................... 12
3.3 Lista: ............................................................................................................................. 12
3.3.1 Operaciones Básicas: ...................................................................................... 12
Código: ........................................................................................................................... 12
3.3.2 Tipos de Listas: .................................................................................................. 15
3.3.3 Aplicaciones: ...................................................................................................... 15
Conclusión: ....................................................................................................................... 16
 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

Introducción:
En dicho documento se habla de los tres tipos básicos de Estructuras Lineales en
la cual se encuentra las Listas, las Colas y las Pilas. De la misma forma se menciona
las características de la cada tipo de Estructura lineal, juntos con sus respectivos
códigos de programación en donde se expresan el uso adecuado de sus respectivas
operaciones básicas de cada uno de las estructuras.
De esa forma dar a conocer el uso adecuado de las operaciones básicas, junto con
un conocimiento teórico que servirá de ayuda para una óptima comprensión del
lector, de cómo funcionan estructuras lineales básicas
 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

Según Laura Garay:

Las estructuras Lineales de datos se caracterizan por que sus elementos están en
secuencia, relacionados en forma lineal uno con el otro.
Cada elemento de la estructura puede estar conformado por uno o varios
subelementos o campos que pertenecen a cualquier tipo de dato, pero normalmente
son tipos de datos básicos.

3.1 Pila:
Una pila se representa una estructura lineal de datos en la que se puede agregar o
quitar elementos únicamente por uno de los extremos (Parte Superior).

3.1.1 Representación en Memoria:

Las Pilas se pueden representar de dos formas:
 En forma de Arreglos.
 En forma de Listas Enlazadas.

3.1.2 Operaciones Básicas:

 Crear una Pila (Constructor).
 Insertar Dato (Push).
 Quitar Dato (Pop).
 Pila Vacía (Método; stackempty).
 Pila Llena (Método; strackempty).
 Limpiar Pila (Método).
 Sima Pila (Método; si retorna; stacktop).
 Tamaño de Pila (Arreglo).
Código:
public class OpBasPila {
private static int i;

/**
* @param args the command line arguments
*/
public static void main(String[] args) {

int Opcion=0, Tamaño, Dato;

Tamaño= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el tamaño de

la pila"));

Pila Objeto = new Pila(Tamaño);

 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

do{
Opcion= Integer.parseInt(JOptionPane.showInputDialog("----------------
Menú----------------\n"
+ "1.- Ingresa el dato de tu pila\n"
+ "2.- Sacar el dato de la pila\n"
+ "3.- Verificar la Pila si esta vacia\n"
+ "4.- Verificar la pila si esta llena\n"
+ "5.- Obtener la Cima de la pila\n"
+ "6.- Obtener el tamaño de la pila\n"
+ "7.- Salir\n"));
switch(Opcion)
{
case 1:
if(!Objeto.Llena())
{
for(i=0;i<Objeto.TamañoPila();i++)
{
Dato=Integer.parseInt(JOptionPane.showInputDialog("Ingresar
Valores a la Pila"));
Objeto.Push(Dato);
}
}
else
{
JOptionPane.showMessageDialog(null, "La pila se escuentra
llena");
}
break;
case 2:
if(!Objeto.Vacio())
{

JOptionPane.showMessageDialog(null,"Elemento eliminado\n
"+Objeto.Pop());

}
else
{

JOptionPane.showMessageDialog(null, "Pila sin datos\n");

}
break;

case 3:
if(!Objeto.Vacio())
 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

{
JOptionPane.showMessageDialog(null, "La Pila contiene
Datos.\n");
}
else
{
JOptionPane.showMessageDialog(null, "La Pila esta Vacia.\n");
}
break;

case 4:
if(!Objeto.Llena())
{
JOptionPane.showMessageDialog(null, "La pila no esta llena\n");
}
else
{
JOptionPane.showMessageDialog(null,"La pila esta Llena.\n");
}
break;

case 5:
JOptionPane.showMessageDialog(null,""+ Objeto.Cima());
break;

case 6:
JOptionPane.showMessageDialog(null,""+ Objeto.TamañoPila());
break;

case 7:
JOptionPane.showMessageDialog(null, "Fin del Programa.");
default:
}
}while(Opcion!=7);
}
}

public class Pila {

int VectorPila[];
int Indice;

public Pila(int Tamaño)

{
VectorPila=new int[Tamaño];
 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

Indice= -1;
}

public void Push(int Dato)

{
Indice ++;
VectorPila[Indice]=Dato;
}

public int Pop()

{
int Eliminado = VectorPila[Indice];
return Eliminado;
}

public boolean Vacio()

{
return Indice == -1;
}

public boolean Llena()

{
return VectorPila.length-1 == Indice;
}

public int Cima()

{
return VectorPila[Indice];
}

public int TamañoPila()

{
return VectorPila.length;
}
}
3.1.3 Aplicaciones:

o Llamadas a subprogramas.
o Tratamiento de expresiones aritméticas.
o Recursividad.
o Ordenación.
 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

3.2 Cola:
Una cola constituye una estructura lineal de datos en la que nuevos elementos se
introducen por un extremo y los ya existentes se eliminan por el otro lado.
Es importante mencionar que los componentes de la cola se eliminan en el mismo
orden en el cual se insertaron. Es decir, El primer elemento que se introduce en la
estructura será el que se eliminara en primer orden.

La estructura de datos tipo cola consiste en un conjunto ordenado de elementos del

mismo tipo en el que solo podemos introducir elementos en la cola por un extremo
y sacarlos por el extremo contrario.

(FIFO) First-in, First-out. El primero en entrar es el primero en salir.

3.2.1 Representación en Memoria:

Las colas se pueden representar de dos formas:

 Como Un Arreglo.
 Como una Lista Ordenada.

3.2.2 Operaciones Básicas:

 Inicializar Cola: Crear una cola vacía.

 Cola Vacía: Averiguar si la cola esta vacía.
 Cola Llena: Averiguar si la cola está Llena.
 Poner Cola: Añadir un elemento en la cola.
 Sacar Cola: Sacar un elemento de la cola.

Código:
public class OpBasCola {
private static int i;

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
int Opcion=0, Tamaño, Elemento;

Tamaño= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el tamaño

de la Cola\n"));

Cola Objeto= new Cola();

 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

do{
Opcion= Integer.parseInt(JOptionPane.showInputDialog("----------------------
MENÚ----------------------\n"
+ "1.- Insertar el elemnto de la Cola\n"
+ "2.- Quitar el elemento de la Cola\n"
+ "3.- ¿La Cola esta Vacia?\n"
+ "4.- Elemento Ubicado el Inicio de la Cola\n"
+ "5.- Tamano de la Cola\n"
+ "6.- Salir\n"));

switch(Opcion)
{
case 1:
if(Objeto.Vacia())
{
for(i=0;i<Objeto.TamañoCola();i++)

{
Elemento=Integer.parseInt(JOptionPane.showInputDialog("Ingresa
Valores a la Cola\n"));
Objeto.Insertar(Elemento);
}
}
else
{
JOptionPane.showMessageDialog(null,"Cola Llena.\n"
+ "Dato no Ingresado.\n");
}

break;

case 2:
if(!Objeto.Vacia())
{
JOptionPane.showMessageDialog(null, "Elemento eliminado"+
Objeto.Quitar());
}
else
{
JOptionPane.showMessageDialog(null, "Cola Vacia.\n");
}
break;
case 3:
if(Objeto.Vacia())
{
 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

JOptionPane.showMessageDialog(null, "La Cola se encuentra

Llena");
}
else
{
JOptionPane.showMessageDialog(null, "La Cola esta Llena");
}
break;
case 4:
JOptionPane.showMessageDialog(null, ""+ Objeto.InicioCola());
break;
case 5:
JOptionPane.showMessageDialog(null, "El Tamaño de la Cola es:"+
Objeto.TamañoCola());
break;

case 6:
JOptionPane.showMessageDialog(null, "Saliento del programa...\n"
+ "Presiones Enter para COntinuar.\n");
default:

}
}while(Opcion!=6);

}
}

public class NodoCola {

int Dato;
NodoCola Siguiente;

public NodoCola(int d)
{
Dato= d;
Siguiente= null;

}
}

public class Cola {

NodoCola Inicio, Fin;
int Tamaño;

public Cola()
 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

{
Inicio= Fin= null;
Tamaño= 0;
}

public boolean Vacia()

{
return Inicio== null;
}

public void Insertar(int Elemento)

{
NodoCola Nuevo= new NodoCola(Elemento);
if(Vacia())
{
Inicio= Nuevo;
}
else
{
Fin.Siguiente= Nuevo;
}
Fin=Nuevo;
Tamaño++;
}

public int Quitar()

{
int A= Inicio.Dato;
Inicio= Inicio.Siguiente;
Tamaño--;
return A;
}

public int InicioCola()

{
return Inicio.Dato;
}

public int TamañoCola()

{
return Tamaño;
}
}
 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

3.2.3 Tipos de Colas:

 Cola Simple: El primer elemento en entrar en el primero que sale.

 Cola Doble: la Bicola o doble cola es un tipo de cola especial que permiten
la inserción y eliminación de ambos extremos de la cola.

 Cola Circular: o Anillo es una estructura de datos en la que los elementos

están de forma circular y cada elemento tiene un sucesor y un predecesor
Se inserta como la cola simple, solo que cuando se llena se pasa el
posicionador al inicio de la cola.

3.2.4 Aplicaciones:

o Modelar Colas reales en el mundo de la computadoras; colas de impresión,

colas de tareas, colas de proceso.
o Simulaciones.
o Búsqueda de anchura.

3.3 Lista:
Conjunto ordenado de elementos homogéneos en donde no hay restricciones de
acceso, la introducción o borrado de elementos.

3.3.1 Operaciones Básicas:

 Inicializar Lista.
 Insertar elemento a la Lista.
 Eliminar elemento a la Lista.
 Buscar Elemento.
 Recorrer Lista.
 Comprobar la Lista si está vacía.
Código:
public class nodo {
nodo nododer;
int dato;
public nodo(int dato){
this.dato=dato;
this.nododer= null;
}
}

public class lista

 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

{
private nodo primero; //cabeza de la lista
private nodo ultimo;
private int tamaño; //variable que que registra el tamaño de la lista.

public void lista(){

this.primero= null;
this.ultimo=null;
this.tamaño = 0;

// metodo utilizado para denotar si la lista se encuentra vacia.

public boolean sivacio()
{
return (this.primero== null);
}

// metodo para agregar al final de la lista

public lista addlast(int dato)
{
if(sivacio())
{
nodo nuevo= new nodo(dato);
primero= nuevo;
ultimo= nuevo;
nuevo.nododer=nuevo;

}
else{
nodo nuevo= new nodo(dato);
nuevo. nododer= null;
ultimo.nododer= nuevo;
ultimo = nuevo;

}
this.tamaño++;
return this;

//metodo para borar al final de la lista.

public nodo deleteLast()
 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

{
nodo eleminar= null;
if(sivacio())
{
JOptionPane.showMessageDialog(null," la lista se encuentra vacia");
return null;
}
if(primero== ultimo)
{
primero = null;
ultimo = null;

}
else{
nodo actual= primero;
while(actual.nododer != ultimo){
actual = actual.nododer;

}
eleminar =actual.nododer;
actual.nododer= null;
ultimo= actual;
}
this.tamaño--;
return eleminar;
}
// metodo que imprime el tamaño de la lista.

public void tamaño ()

{
JOptionPane.showMessageDialog(null, "el tamaño es:\n"+ this.tamaño);

}
// metodo que imprime la lista y los valores ingresados.
public void imprimir()
{
if(tamaño !=0)
{
nodo temp= primero;
String str= "";
for(int i = 0; i < this.tamaño; i++)
{
str= str + temp.nododer.dato + "\n";
temp=temp.nododer;
 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

}
JOptionPane.showMessageDialog(null,str);
}
}
}

3.3.2 Tipos de Listas:

 Lista Simplemente Enlazada: Donde el primer nodo apunta al siguiente

nodo.
Nodo Principal => Cabeza.
Nodo Final => Cola que apunta al null.
 Lista Doblemente Enlazada: son un tipo de Lista lineal en la que cada nodo
tiene dos enlaces, uno que apunta al nodo siguiente, y el otro que apunta al
nodo anterior.
 Lista Circular: Una lista Circular en lista lineal en la que el ultimo nodo
apunta la primero.
 Lista Circulares Dobles: En las listas Circulares Doblemente enlazadas
cada nodo tiene un par de campos de enlace, uno la nodo siguiente y otro al
nodo anterior.
3.3.3 Aplicaciones:
o Lista simple:
 Hallar elementos de una fila de personas.
 Cronograma de actividades.
 A un sistema Digiturno.

o Lista Doble:
 Para almacenar información.
 Transacciones en los bancos.
o Listas Circulares:
 Red de Datos.
 Almacenar una sucesión de imágenes de un experimento.
 Reproductor de música.
 TECNOLÓGICO NACIONAL DE MÉXICO
CAMPUS TUXTLA GUTIERREZ
EXTENSION SAN MARTIN CHAMIZAL

Conclusión:
A partir de ahora el lector tiene el conocimiento de las estructuras lineales básicas
a través de la observación, el manejo de los códigos de programación que se
dieron a conocer en este reporte llegando al uso correcto en cuestión de las
operaciones básicas en conjunto con el conocimiento teórico del funcionamiento de
dichas estructuras.