REPÚBLICA BOLIVARIANA DE VENEZUELA

INSTITUTO UNIVERSITARIO DE TECNOLOGÍA

“ANTONIO JOSÉ DE SUCRE”

SEMESTRE: 4TO. SECCIÓN “AA”

CARRERA: INFORMÁTICA

ASIGNATURA: PROCESAMIENTO DE DATOS

Declaración de listas

Informe

PROFESORA: ALUMNO:

Naudy Del Valle Albornoz Franklin Oscar Guada Cabeza

CI: 24057408

Charallave, 10 de Febrero, 2024

 INDICE

INTRODUCCIÓN_______________________________________________Pág.3

DESARROLLO_________________________________________________Pág.4

CONCLUSIÓN________________________________________________Pág.20

REFERENCIAS BIBLIOGRÁFICAS________________________________Pág.21

ANEXOS_____________________________________________________Pág.22
 INTRODUCCIÓN

El presente informe hace referencia a lo que es la declaración de listas, concepto,

características, usos de las listas, tipos de listas. Listas simples, listas circulares,
listas encuadernadas o enlazadas, listas circulares simples, listas circulares dobles.
Contiene operaciones con listas: creación, inserción, supresión; así también
contiene algoritmos para utilizar con listas, en este caso ejemplos con lenguaje de
programación C++.
Declaración de listas

La declaración de listas es el proceso de asignar memoria para una lista y

proporcionarle un nombre. La declaración de listas puede variar según el lenguaje
de programación que se utilice.

En ciencias de la computación, una lista o secuencia es un tipo de dato abstracto

que representa una secuencia ordenada de valores, donde el mismo valor puede
ocurrir más de una vez. Un caso de una lista es una representación computacional
del concepto matemático de una secuencia finita.

En programación una lista es una secuencia de nodos o elementos del mismo tipo,
tal que, cada nodo señala, apunta, conoce, o sabe cuál es el siguiente nodo, (si
existe), si no hay un nodo siguiente, entonces apunta a NULL, (una dirección
segura).

La Lista es una estructura de datos muy importante en los lenguajes de

programación donde: representa una colección de elementos ordenados. puede
contener elementos repetidos.

De esta manera se forma una lista

Las listas son conjuntos ordenados de elementos (números, cadenas, listas,

etc). Las listas se delimitan por corchetes ([ ]) y los elementos se separan por comas.
Las variables de tipo lista hacen referencia a la lista completa.

Características de las listas

1.-Una lista es una estructura de datos homogénea y dinámica, que va a estar

formada por una secuencia de elementos, donde cada uno de ellos va seguido de
otro o de ninguno.

2. -Las listas son una sucesión de cero o más elementos.

3. -Una lista permite añadir notas a cada entrada, diagramar sus elementos
repartiendo información en varias columnas, y seguir un orden cronológico o
estructurado de fácil comprensión.

Tipos de Listas

Lista Simple

Una lista simple

Repaso teórico. Una lista enlazada simple es una estructura de datos en la que cada
elemento apunta al siguiente. De este modo, teniendo la referencia del principio de
la lista podemos acceder a todos los elementos de la misma.

¿Qué es una lista simple en C++?

Listas Enlazadas Simples Lineales en C++

Consiste en una secuencia de nodos, en los que se guardan campos de datos

arbitrarios y una o dos referencias (punteros) al nodo anterior o posterior.
Listas encuadernadas o enlazadas

Una lista enlazada simple es una estructura de datos en la que cada elemento
apunta al siguiente. De este modo, teniendo la referencia del principio de la lista
podemos acceder a todos los elementos de la misma. La figura 1 representa esta
estructura de datos.

Figura 1. Representación gráfica de una lista enlazada simple

La lista enlazada se compone de nodos (objetos instanciados pertenecientes a la

clase Node), cada uno de los cuales tiene dos únicas tareas: guardar la información
de la posición i y ofrecer una referencia a la posición i+1.

La lista enlazada circular no es más que una lista enlazada en la que el último
elemento de la lista está enlazado al primer elemento de la lista, formando un círculo
cerrado. La estructura está representada en la figura 3.

Figura 3. Representación gráfica de una lista enlazada circular

Conceptos sobre Listas Enlazadas

Una lista enlazada (Linked List) – es una secuencia de nodos. Junto con el arreglo
(array), la lista enlazada es considerada una de las estructuras de datos
fundamentales y puede ser utilizada para implementar otras estructuras más
complejas. El acceso a los nodos en una lista enlazada es normalmente secuencial,
excepto el acceso al primer nodo y posiblemente, el acceso al último nodo.

Cada nodo de una lista enlazada es un objeto autoreferenciado (self-

referential object) ya que contiene, además de una referencia a los datos que
almacena, una referencia a otro nodo. La siguiente es una definición simple de la
clase que describe cada nodo en una lista simplemente enlazada:
class Node<T> {
T data;
Node<T> next;
}

Las listas enlazadas pueden clasificarse como:

a. Lista Simplemente Enlazada (Singly Linked List) – es aquella en la
cual cada nodo contiene un enlace al próximo nodo. El último nodo
contiene un enlace a null. La siguiente imagen de Wikipedia muestra
una lista simplemente enlazada:
 b. Lista Doblemente Enlazada (Doubly Linked List) – es aquella en la
cual cada nodo contiene un enlace al próximo nodo y un enlace al
nodo anterior. El último nodo contiene un enlace a null como su
sucesor. El primer nodo contiene un enlace a null como su
antecesor. La siguiente imagen de Wikipedia muestra una lista
doblemente enlazada:

c. Lista Enlazada Circular (Circular Linked List) – es aquella en la cual

el último nodo está enlazado con el primero. La siguiente imagen de
Wikipedia muestra una lista enlazada circular:

La principal ventaja de las listas enlazadas con respecto a los arreglos es que se
pueden añadir o eliminar nodos dinámicamente sin necesidad de realizar
desplazamientos. Por ejemplo, la siguiente imagen de Wikipedia muestra cómo
añadir un nuevo nodo al centro de una lista enlazada:

¿Qué es una lista enlazada?

Una lista enlazada es una estructura de datos lineal similar a un arreglo. Sin
embargo, a diferencia de los arreglos, los elementos no son almacenados en una
ubicación de la memoria o índice en particular. Más bien, cada elemento es un
objeto separado que contiene un puntero/apuntador o enlace al siguiente objeto en
esa lista.

Cada elemento (comúnmente llamados nodos) contiene otros dos: el dato

almacenado y un enlace al siguiente nodo. El dato puede ser de cualquier tipo
válido. Puedes ver esto ilustrado en el diagrama de abajo.

El punto de entrada a una lista enlazada es llamado la cabecera. La cabecera es

una referencia al primer nodo en la lista enlazada. El último nodo en la lista apunta
a nulo. Si una lista está vacía, la cabecera es una referencia nula.

En JavaScript, una lista enlazada se ve así:

const lista = {
cabecera: {
valor: 6
siguiente: {
valor: 10
siguiente: {
valor: 12
siguiente: {
valor: 3
siguiente: null
}
}
}
}
 }
};
Una ventaja de las listas enlazadas
• Los nodos pueden ser fácilmente removidos o agregados a una lista enlazada sin
tener que reorganizar la estructura de datos entera. Esta es una ventaja que tiene
sobre los arreglos.

Desventajas de las listas enlazadas

• Las operaciones de búsqueda son lentas en las listas enlazadas. A diferencia de los
arreglos, el acceso aleatorio a elementos de datos no está permitido. Se accede a
los nodos de manera secuencial empezando desde el primer nodo.

• El uso de memoria es mayor que en los arreglos debido al almacenamiento de los

punteros/apuntadores.

Tipos de listas enlazadas

Hay tres tipos de listas enlazadas:

• Listas enlazadas individuales: Cada nodo contiene solo un puntero/apuntador al

siguiente nodo. Esto es de lo que hemos estado hablando hasta ahora.
• Listas doblemente enlazadas: Cada nodo contiene dos punteros/apuntadores;
un puntero/apuntador al siguiente nodo, y otro al nodo anterior.
• Listas circulares enlazadas: Son una variación de la lista enlazada en donde el
último nodo apunta al primer nodo o a otro nodo antes de ese, formando así un
bucle.
Implementación de un nodo de lista en JavaScript
Como se mencionó antes, un nodo de lista contiene dos elementos, el dato y el
puntero/apuntador al siguiente nodo. Podemos implementar un nodo de lista en
JavaScript de la siguiente manera:

class NodoLista {
constructor(dato) {
this.dato = dato
this.siguiente = null
 }
}
Implementación de una lista enlazada en JavaScript
El código de abajo muestra la implementación de una clase de lista enlazada con
un constructor. Nota que, si el nodo de cabecera no es pasado, la cabecera se
inicializa a nulo.

class ListaEnlazada {
constructor(cabecera = null) {
this.cabecera = cabecera
}
}
Poniéndolo todo junto
Vamos a crear una lista enlazada con la clase que hemos creado. Primero, creamos
dos nodos de lista, nodo1 y nodo2 y un puntero/apuntador del nodo 1 al nodo 2.
let nodo1 = new NodoLista(2)
let nodo2 = new NodoLista(5)
nodo1.siguiente = nodo2
A continuación, crearemos una Lista Enlazada con el nodo1.
let lista = new ListaEnlazada(nodo1)
Intentemos acceder a los nodos de la lista que hemos creado.

console.log(lista.cabecera.siguiente.dato) //devuelve 5
Algunas funciones de lista Enlazada
A continuación, implementaremos cuatro funciones de ayuda para la lista enlazada,
los cuales son:

1. magnitud()

2. vaciar()

3. obtenerUltimo()

4. obtenerPrimero()
Operaciones básicas de las listas enlazadas

Las operaciones típicas de la lista incluyen: Crear la lista, verificar si está vacía,
insertar elementos, eliminar elementos, mostrar elementos. La lista no tiene ninguna
restricción en cuanto a dónde puede eliminar o agregar nodos y es precisamente
esta característica lo que la hace la estructura más versátil.

Listas Circulares

En las listas circulares, nunca se llega a una posición en la que ya no sea posible
desplazarse. Cuando se llegue al último elemento, el desplazamiento volverá a
comenzar desde el primer elemento. Lista es el tipo para declarar listas, tanto
abiertas como circulares.

Listas circulares simples

Una lista circular es una lista lineal en la que el último nodo apunta al primero. Las
listas circulares evitan excepciones en las operaciones que se realicen sobre ellas.

Lista Circular Simplemente Enlazada, es aquella en la que el último elemento (cola

de la lista) se enlaza al primer elemento (cabeza de la lista), de tal modo que la lista
puede ser recorrida de modo circular (en anillo).
Listas circulares simples y dobles

Lista de enlace doble: cada nodo contiene dos partes de enlace al siguiente nodo y
al anterior nodo. Lista de enlace circular simple: cada nodo contiene una parte de
enlace al siguiente nodo, pero su diferencia esta que el último nodo se enlaza con
el primer nodo de la lista.

Características particulares tienen de las listas circulares

En las listas circulares, nunca se llega a una posición en la que ya no sea posible
desplazarse (no existe el nil). Cuando se llegue al último elemento, el
desplazamiento volverá a comenzar desde el primer elemento. Es una estructura
de datos homogénea, dinámica y lineal.

Lista doblemente circular

Una lista doble circular es una estructura donde el último elemento tiene como
referencia siguiente al primer elemento y la referencia al anterior del primer
elemento de la lista también es el último.

Lista circular en estructura de datos

Una lista circular es una lista lineal en la que el último nodo a punta al primero. Las
listas circulares evitan excepciones en las operaciones que se realicen sobre ellas.
No existen casos especiales, cada nodo siempre tiene uno anterior y uno siguiente.

Listas circulares en Java

Las listas circulares son estructuras de datos en la

que el último nodo apunta al primero lo cual la
convierte en una lista sin fin, cada nodo siempre tiene
uno anterior y uno siguiente, su estructura es muy
similar a las listas simples por lo cual comparten características tanto en su
implementación como en su manejo.

Operaciones con listas: creación, inserción, supresión

Desde el punto de vista de la informática, existen tres estructuras lineales

especialmente importantes: las pilas, las colas y las listas. Su importancia radica en
que son muy frecuentes en los esquemas algorítmicos.

Las operaciones básicas para dichas estructuras son:

• crear la secuencia vacía

• añadir un elemento a la secuencia
• borrar un elemento a la secuencia
• consultar un elemento de la secuencia
• comprobar si la secuencia está vacía

La diferencia entre las tres estructuras que se estudiarán vendrá dada por la
posición del elemento a añadir, borrar y consultar:

• Pilas: las tres operaciones actúan sobre el final de la secuencia

• Colas: se añade por el final y se borra y consulta por el principio
• Listas: las tres operaciones se realizan sobre una posición privilegiada de la
secuencia, la cual puede desplazarse

Se presenta el TAD de las pilas de elementos arbitrarios. Tras especificarlo, se

muestra su implementación en vector (posteriormente se verá su implementación
con memoria dinámica) y se discuten sus ventajas y desventajas.

Después se muestran las colas siguiendo un proceso idéntico al del subtema

anterior. Se presenta y discute la implementación en vector circular (también
posteriormente se verá su implementación en memoria dinámica).
Respecto a las listas, dado que hay muchas versiones diferentes se escoge una
como base. Concretamente las listas con punto de interés, donde existe un
elemento que sirve de referencia a las operaciones de inserción, supresión y
consulta. Estas listas tienen el interés añadido de que son equivalentes a la noción
de secuencia que los estudiantes conocen de Programación. Se da una
especificación formal de estas listas y se discuten las diferentes implementaciones.
Tras considerar una implementación secuencial, que resulta ineficiente en general,
se detalla la representación encadenada, mucho más eficiente (coste constante en
todas las operaciones), usando vectores. En la representación encadenada se ve la
utilidad de introducir un elemento fantasma, que evita casos especiales en los
algoritmos y simplifica el código.

Ante el problema de previsión de memoria necesaria a reservar, se presenta la

utilización de memoria dinámica. Se exponen todos los inconvenientes asociados al
uso de memoria dinámica (generación de basura, referencias colgadas,
compartición de memoria, etc.) y se ilustran los peligros asociados a las
implementaciones que los usan. Se muestra de forma muy natural la
implementación con punteros de las listas, y se recuerdan las pilas y las colas
comentando su implementación dinámica.
 Ejemplo de Lista
Lenguaje: C++

/*Enunciado:

Se desea implementar una lista enlazada para almacenar nombres de personas.

La lista debe tener las siguientes operaciones:

Agregar un nombre al final de la lista.

Eliminar un nombre de la lista, dado su nombre.
Buscar un nombre en la lista y retornar si está presente o no.
Imprimir la lista completa. */
#include <iostream>

using namespace std;

struct Nodo {
string nombre;
Nodo* siguiente;
};

class Lista {
private:
Nodo* primero;
Nodo* ultimo;
public:
Lista();
~Lista();
void agregar(string nombre);
 void eliminar(string nombre);
void buscar(string nombre);
void imprimir();
};

Lista::Lista() {
primero = ultimo = nullptr;
}

Lista::~Lista() {
while (primero != nullptr) {
Nodo* aux = primero;
primero = primero->siguiente;
delete aux;
}
}

void Lista::agregar(string nombre) {

Nodo* nuevo = new Nodo();
nuevo->nombre = nombre;
nuevo->siguiente = nullptr;

if (primero == nullptr) {
primero = ultimo = nuevo;
} else {
ultimo->siguiente = nuevo;
ultimo = nuevo;
}
}

void Lista::eliminar(string nombre) {

if (primero == nullptr) {
return;
}

if (primero->nombre == nombre) {
Nodo* aux = primero;
primero = primero->siguiente;
delete aux;
return;
}

Nodo* anterior = nullptr;

Nodo* actual = primero;

while (actual != nullptr && actual->nombre != nombre) {

anterior = actual;
actual = actual->siguiente;
}

if (actual != nullptr) {
anterior->siguiente = actual->siguiente;
if (actual == ultimo) {
ultimo = anterior;
}
delete actual;
 }
}

void Lista::buscar(string nombre) {

Nodo* actual = primero;

while (actual != nullptr && actual->nombre != nombre) {

actual = actual->siguiente;
}

if (actual != nullptr) {
cout<<actual->nombre <<" esta en la lista"<<endl;
}
}

void Lista::imprimir() {
Nodo* actual = primero;

while (actual != nullptr) {

cout << actual->nombre << " ";
actual = actual->siguiente;
}

cout << endl;

}

int main() {
Lista lista;
 lista.agregar("Ana");
lista.agregar("Juan");
lista.agregar("Pedro");

lista.imprimir();

lista.eliminar("Juan");

lista.imprimir();

lista.buscar("Pedro");

return 0;
}
 CONCLUSIÓN

Al concluir este informe nos deja mucho aprendizaje sobre la declaración de las
listas su concepto, características, usos de las listas, tipos de listas lo que son las
listas simples, listas encuadernadas o enlazadas, listas circulares simples, listas
circulares dobles, además operaciones con listas: creación, inserción, supresión,
con punto de interés, a las operaciones de inserción, supresión y consulta. Se
realizó ejercicios con algoritmos para utilizar con listas, en este caso ejemplos con
lenguaje de programación C++.
 REFERENCIAS BIBLIOGRÁFICAS

https://calcifer.org/documentos/librognome/glib-lists-queues.html

https://www.uv.mx/personal/ermeneses/files/2021/08/Clase5-
ListasEnlazadasFinal.pdf

https://www.it.uc3m.es/java/2011-12/units/pilas-
colas/guides/2/guide_es_solution.html

https://profesor.uprb.edu/mvelez/cursos/sici4036/ConceptosListasEnlazadas.html

https://webdiis.unizar.es/~elvira/eda/addeda/teruel/Estructuras_Lineales.html
ANEXOS