1

Estructuras
De Datos

Contextualización
2

Tabla de contenido
Introducción ..............................................................................................................................3

Pregunta orientadora ................................................................................................................3

1. Arreglos de Tipo Estático ..................................................................................................4

1.1. ¿Qué es un arreglo? ............................................................................................................4

1.1.1 Tipos de Arreglos........................................................................................... 5

1.1.2 Creación de un arreglo simple ....................................................................... 7

2. Listas en Estructuras de Datos .........................................................................................8

2.1. Listas Lineales Simples ........................................................................................................8

2.2 Listas Lineales Doblemente Enlazadas ..............................................................................10

2.2 Listas Circulares.................................................................................................................11

3. Pilas ..................................................................................................................................11

4. Colas .................................................................................................................................15

Glosario ...................................................................................................................................19
3

Introducción
En el día a día de un sistema de información existen procesos definidos que debería
realizar un sistema sin excepción, en este caso todos los programas informáticos trabajan con
datos.
Los datos son el recurso más importante de una empresa o de una persona, ya que con
ellos se pueden generar estadísticas, obtener reportes con el fin de tomar las mejores decisiones
para su mejora continua.

Pero para manejar estos datos debemos saber cómo tratarlos, se deben reconocer cada
una de las maneras lógicas de manipularlos y por supuesto de generar un programa algorítmico
para establecer estructuras estables, confiables y ágiles para el manejo de información escalable.

Pregunta orientadora

Sin embargo, para poder realizar programas avanzados que manejen grandes cantidades
de información nos deberiamos realizar la siguiente pregrunta ¿ Cuales son los métodos
existentes en la informatica para manipular los datos de manera eficaz y confiable?
4

Unidad 1: Arreglos estáticos, Listas lineales, circulares

(simples, doblemente enlazadas) Pilas y Colas

1. Arreglos de Tipo Estático

1.1. ¿Qué es un arreglo?

Un arreglo es la forma de manipular los datos de manera más flexible, organizándola

estructuradamente utilizando conceptos definidos en los diferentes lenguajes de programación.
Una de las características más importantes de un arreglo es que se debe definir de forma
homogénea; es decir, de un mismo tipo de dato (numérico o alfanumérico) también se debe
establecer un tamaño para reservar la memoria a utilizar.

A continuación, veremos las propiedades que deben tener los arreglos:

• Establecimiento de tamaño.
• Accesibilidad de los elementos.
• Elementos del mismo tipo.
Figura 1

Propiedades de los arreglos

Nota. Tomada de Arrays (Vectores y matrices), de Trujillo ,2015, Practicas de informática

(http://iescastulolinares.blogspot.com/p/pascal.html).
5

1.1.1 Tipos de Arreglos

A continuación, veremos los diferentes tipos de arreglos que existen en las estructuras de
datos:
• Unidimensionales. Es una serie de datos de un mismo tipo que se almacena en
forma de lista. Cada una de sus posiciones guarda en memoria la información y
podemos consultarla por medio de su índice que va a tener un número asignado
iniciándose desde el 0 a N.
Los arreglos Unidimensionales son más conocidos como vectores y gráficamente se
representarían de la siguiente manera:

Figura 2

Arreglos Unidimensionales

Nota. Tomada de Arrays unidimensionales en Java, de Educando con TIC,2021,

(https://educandocontic.com/arrays-unidimensionales-en-java/).

• Bidimensionales. Es una estructura definida de un mismo tipo compuesta por filas y

columnas, estos tipos de arreglos utilizan dos subíndices para poder acceder a los datos
de forma específica, se puede relacionar a una matriz y las podemos utilizar para guardar
grandes cantidades de información.
Figura 3

Arreglos Bidimensionales
6

Nota. Tomada de Arreglos Bidimensionales, de J.Villareal,2021, Programación Básica VB

(https://sites.google.com/site/programacionbasicavb/arreglos/arreglos-bidimensionales).

• Multidimensionales. Como lo indica su propio nombre, son arreglos de más de una

dimensión en el sistema, esto quiere decir que podemos establecer N cantidades de
subíndices en muchas matrices.
Figura 4

Arreglos Multidimensionales

Nota. Tomada de Arreglos Multidimensionales, de K. Rodriguez,2021, Consulta todos los tipos

de arreglos en programación (https://mecambioya.com/c-tecnologia/tipos-de-arreglos-en-
programacion/).
7

1.1.2 Creación de un arreglo simple

Se va a implementar un código para la creación de un arreglo simple, en él vamos a

realizar un análisis de su estructura, ejemplo: Se necesita crear un programa para ingresar un
listado de materias definido por el usuario, se utilizará un vector para guardar los nombres.
Figura 5

Código para la creación de un arreglo simple

8

2. Listas en Estructuras de Datos

En el desarrollo de software es muy importante tener definido el concepto de listas,

que lo podemos interpretar como un grupo de elementos de un tipo de dato especifico que
puede variar la cantidad definida al inicio de la ejecución del programa.
Para implementar una lista, lo ideal es que se realice por medio de arrays
dimensionando un tamaño para guardar los elementos en la lista, cuando se obtiene una lista
definida podemos realizar diferentes operaciones en sus objetos o elementos que pueden
ser:
• Buscar
• Insertar
• Eliminar
• Ordenar
• Copiar

2.1. Listas Lineales Simples

Las listas en un contexto más práctico se forman en un enlace de nodos que funcionan
como un contendor guardando el valor y el enlace del siguiente nodo.
La estructura básica de un nodo es sencilla; tenemos el valor que simplemente hace
referencia al valor del dato a guardar y enlace que es el apuntamiento en memoria del siguiente
nodo.
Figura 6

Estructura de listas lineales simples

Nota. Tomada de listas simples en Java, de B. Acosta,2015, código libre

(http://codigolibre.weebly.com/blog/listas-simples-en-java).
9

Pero por el momento no nos centraremos en la creación de un nodo y un enlace, lo

importante es conocer el concepto y más adelante en el curso se crearán las listas necesarias,
vamos a representar una lista con el siguiente ejemplo:
Se crea un vector con 8 posiciones y se insertan inicialmente 7 nombres, al momento que
creamos un método para insertar un nuevo nombre en la lista le indicamos el nombre del vector,
el valor y la posición en la que se va a situar.
Figura 7

Ejemplo de repaso

En este momento ya nuestra lista se encuentra llena, así que si deseamos realizar el
mismo proceso con otro nombre nos generará un error.
Figura 8

Ejemplo de repaso
10

2.2 Listas Lineales Doblemente Enlazadas

Las listas doblemente enlazadas son una estructura de datos de tipo lista donde en cada
nodo se tienen dos enlaces, el primero que apunta al siguiente nodo y el otro apunta al anterior,
en un lenguaje más práctico podemos interpretar que una lista doblemente enlazada puede
recorrer hacia adelante y hacia atrás excepto el primer elemento de la lista que no puede tener
un predecesor y el último elemento que no tiene un sucesor.
Una representación gráfica de estas listas seria la siguiente:
Figura 9

Listas lineales doblemente enlazadas

En un ejemplo más práctico veremos gráficamente como se inserta al inicio y al final un

elemento en una lista:
Figura 10

Ejemplo listas lineales doblemente enlazadas

Representaremos el mismo ejemplo eliminando de la lista un elemento definido,

gráficamente se ubica la posición y se elimina uniendo los nodos que quedaron libres de sucesor
y predecesor.
Figura 11

Ejemplo eliminar un elemento de una lista

11

2.2 Listas Circulares

Las listas circulares son listas enlazadas que tienen como gran característica que el
ultimo nodo creado tiene como sucesor el primer elemento creado, y por supuesto el primer
elemento creado tiene como predecesor el último de la lista.
Figura 12

Ejemplo lista circular

Como lo vemos en la imagen no se tiene definido en donde inicia o en donde finaliza la

lista, por el concepto indicado al inicio. Pero en estas listas se tiene una cabeza que es la
indicación del elemento donde se puede acceder a esta lista.

3. Pilas

Una pila es una lista ordenada en las estructuras de datos, que nos permite almacenar y
acceder a los datos ingresados a ese espacio en memoria, este tipo de estructura es de tipo LIFO
(Last In – First Out) Ultimo que entra último en salir.
Podemos simular el concepto a una caja donde se van a guardar libros, el primer libro en
ingresar se envía al fondo de la caja, el segundo libro se ingresa a la caja quedando al fondo,
pero sobre el primer libro y así sucesivamente hasta llegar al tope de la caja. Si se desea ingresar
12

a tomar el primer libro ingresado toca por obligación empezar a desarmar la pila en el orden del
último que entro hasta el libro buscado que en este caso será el primero que ingreso a la caja.
Gráficamente lo veremos de la siguiente forma:
Figura 13

Estructura de una pila

Nota. Tomada de estructura y organización de datos (pila), de Gloster,2015,

(https://edu.glogster.com/glog/estructura-y-organizacion-de-datos-pila/2c7tqer8pv6).

Para generar una pila con un arreglo se tiene como limitante que se debe reservar el
espacio de memoria con anticipación, una vez que se llega al tope del máximo establecido no es
posible ampliar su espacio, si se intenta realizar este proceso nos generará un error de
desbordamiento de memoria.
A continuación, crearemos una pila en un vector, se creará la pila y la llenaremos de forma
aleatoria con un numero de 0 a 100, pediremos el vector máximo de la pila y la cantidad de
elementos a llenarla (números aleatorios), al final imprimiremos de esos números aleatorios
cuantos son pares e impares.
Recordemos que cuando queramos utilizar la consola en JAVA y obtener datos de esta,
debemos importar la librería Scanner.
Figura 14

Importar la librería Scanner

13

Primero crearemos un proyecto en JAVA por consola con nombre de PrimeraPila en el

método main que es el primero que se va a ejecutar, pediremos el tamaño del vector la cantidad
de elementos a registrar y realizaremos una pequeña validación de que el tamaño del vector no
puede ser menor a los elementos a registrar ya que podemos tener un desbordamiento.
Figura 15

Ejemplo de construcción de una pila

Crearemos un método único para generar nuestra pila, este método recibirá la cantidad
de elementos a ingresar, el total del tamaño de la pila y el vector que contendrá los elementos.
En este mismo método vamos a generar aleatoriamente un número del 0 a 100 con la función
Math y realizaremos el conteo de cuantos números son pares e impares.
14

Figura 16

Ejemplo de construcción de una pila

Crearemos un método de tipo void para que no retorne ningún resultado y lo llamaremos
imprimir, este método recibirá un vector de números enteros el cual tendremos que imprimir. Al
imprimir un vector lo más recomendable es utilizar la sentencia cíclica del FOR indicándole que
su cantidad de veces que va a recorrer será la cantidad de elementos ingresados a la pila.
Figura 17

Ejemplo de construcción de una pila

15

Podemos evidenciar que al salir del FOR estamos imprimiendo el tope de la pila y el
máximo de elementos que puede contener la pila.
Finalmente crearemos un método para imprimir la cantidad de números pares e impares
de nuestra pila que se generaron aleatoriamente.
Figura 18

Ejemplo de construcción de una pila

4. Colas

Las colas son estructuras de datos que se caracteriza por ser de tipo FIFO (First In Forst
Out) debido a que el primer elemento que entra es el primero que sale.
Las colas son especialmente utilizadas en los sistemas informáticos para generar un
orden en un proceso, por ejemplo, en el almacenamiento y envió de documentos, administración
de turnos en centros de atención, etc.
Para representar gráficamente una cola es de la siguiente forma:
Figura 18

Estructura de una cola

16

Nota. Tomada de Colas en Java, de D. Caballero,2014, Programación (https://yosoy.dev/colas-

en-java/).
Vamos a crear un proyecto llamado PrimeraCola en ese proyecto en nuestro método main
vamos a pedir el tamaño del vector y la cantidad de elementos a registrar, validaremos que el
vector sea mayor que la cantidad de elementos a insertar. A diferencia de las pilas vamos a
generar un primer número aleatorio que se llamará base, este número aleatorio será hasta el
máximo de tamaños del vector.
Figura 19

Crear ejemplo de una cola

Después crearemos un método llamado generar, en el vamos a recibir la cantidad de

elementos a registrar en la cola, el total de elementos de la cola, el elemento base de la cola, el
tope de la cola y el vector donde vamos a ingresar los elementos aleatoriamente de 0 a 100. Para
llenar nuestro vector vamos a utilizar un while y por último realizaremos las operaciones
necesarias para generar un promedio.
17

Figura 20

Crear ejemplo de una cola

Finalmente crearemos un método imprimir, para visualizar los elementos ingresados a

nuestra cola, el método pedirá como parámetros de entrada los mismo que la generación.
Utilizamos un While para recorrer la cantidad de elementos a imprimir y realizamos una validación
si elemento es menor al totalCola restándole un 1.
Figura 21

Crear ejemplo de una cola

18

Recursos Complementarios

Díaz, G. (2015). Listas Enlazadas (Doctoral dissertation, Universidad de Los Andes, Mérida 5101
Venezuela). Programación digital III.
http://webdelprofesor.ula.ve/ingenieria/gilberto/pr3/index.html

Referencias

Gómez, M. y Cervantes, J. (2013). Inicialízate en la Programación.

http://www.cua.uam.mx/pdfs/conoce/libroselec/Libro_InicialIzate.pdf

Sanches, J. (2015). Pilas y Colas. [Diapositiva de PowerPoint]. Repositorio Institucional UAEM.

http://hdl.handle.net/20.500.11799/34181

Landassuri, V. (2016). Unidad II. Estructuras de datos lineales-pilas. [Diapositiva de PowerPoint].

Universidad Autónoma del Estado de
Mexico.http://ri.uaemex.mx/bitstream/handle/20.500.11799/63390/secme-
26370.pdf?sequence=1

Vásquez, Y. (2019). Estructura y base de datos. Concepto y tipos de datos, Arrays, listas
enlazadas, pilas, colas. Organización de base de datos. Tipos de base de datos,
entidades y objetos. Uso de herramientas de cuarta generación en la base de datos.
Aplicaciones a la realidad cotidiana. Monografía, Universidad Nacional de Educación
Enrique Guzmán y Valle. Lima-Perú. https://repositorio.une.edu.pe/handle/UNE/5113
19

Glosario
• FIFO: In computing and in systems theory, FIFO (an acronym for first in, first out) is a
method for organising the manipulation of a data structure (often, specifically a data buffer)
where the oldest (first) entry, or "head" of the queue, is processed first.
• LIFO: is an abbreviation for last in, first out. It is a method for handling data structures
where the first element is processed last and the last element is processed first.