Estructuras de Datos

Mgr. Wendoline Arteaga

Listas
Estructura básica y elemental.
Algunas operaciones son bastante
ineficientes en tiempo y si son
recursivas peligra el espacio
Pero puede ser muy útiles en algunos
casos dependiendo el problema.
Definición
• Sucesión de elementos, que podría estar vacía, se caracteriza
porque hay un primer y un último elemento y porque todo
elemento tiene su anterior (salvo el primero) y todo
elemento tiene su siguiente (salvo el último).

Ej. Lista del conjunto alumnos de la clase:

Lista1 = (Juan, Rosa, Ana, María, Lucas, Tania, Pepe)

PRIMER ÚLTIMO
Definición Recursiva
• Una lista es vacía o consta de cabeza y cola; la cabeza es el
primer elemento y la cola es la lista que resulta de eliminar la
cabeza de la lista original.

Ej. Lista de alumnos de la clase:

Lista1 = (Juan, Rosa, Ana, María, Lucas, Tania, Pepe)

CABEZA COLA
OPERACIONES
Operaciones que Operaciones que
modifican la LISTA exploran la LISTA

Insertar un nuevo Buscar un elemento

elemento Encontrar el mayor
Eliminar un elemento Identificar el siguiente
Ordenar de un elemento dado
Invertir Recorrer la Lsita
Algoritmos sobre listas
Buscar( elem, L)  Resp
Si (L = Vacía) entonces
Resp  No
C/c
e_actual  Prim_el (L)
Mientras (e_actual ≠ Ultimo (L)) y (e_actual ≠ elem)
e_actual  Siguiente(e_actual, L)
Si (e_actual = elem), entonces
Resp  Si
C/c Resp  No
Terminar devolviendo Resp
Análisis de tiempo
• Es fácil ver este algoritmo pertenece al orden O(N), ya
que en el peor de los casos (por eso el <=) para
encontrar un elemento debemos recorrer toda la lista.

TBuscar (N) <= 2 + 2 * (N-1) + 2 = 2 + 2N

• Donde N es la cantidad de elementos de la lista

Análisis de espacio
• Se necesitan guardar N elementos de la Lista en el
segmento de datos o en el Heap (montón), por lo tanto:

EBuscar (N) = x*N + x1

• Donde N es el tamaño de la lista, x es el número de

bytes necesarios para guardar un elemento y x1 es el
número de bytes necesarios para guardar las variables
locales del programa
Algoritmo Recursivo
Buscar_Rec( elem, L)  Resp
Si (L = Vacía) entonces
Resp  No
C/c
Si (elem = cabeza(L)) entonces
Resp  Si
C/c
Resp  Buscar_ Rec(elem, cola(L))
Terminar devolviendo Resp
Análisis de tiempo
• Este algoritmo también pertenece al orden O(N), ya que la
recurrencia que lo define el tiempo es:

Tbuscar_REC (0) = 2
Tbuscar_REC (N) ≤ 2 + TB_Lr (N-1)

Nos lleva a:
Tbuscar_REC (N) <= 2N + 2

• Donde N es la cantidad de elementos de la lista

Análisis de espacio
• En este caso se necesitan guardar N elementos de la Lista, pero
también debemos pensar en los datos que se guardan en la
pila, de debido a la recursividad, no olvide que la Pila tiene un
espacio 64 Kbytes.
(65.000 bytes) aprox 16.000

EBuscar (N) = (x*N + x1 )+ (z * N)

• Donde (z * N) representa las N llamadas recursivas y z son las

variables que se guardan en la pila en cada llamada.
Ej. Si z ocupa 4 bytes (int), ¿ Con que N se llenará la pila?
Otros Algoritmos
Insertar_principio( elem, Lista)  Lista
Si (Lista = Vacía) entonces
Primer(Lista) elem
Último(Lista) elem
C/c
Segundo Primer(Lista)
Primer(Lista) elem
Siguiente(elem, Lista)  Segundo
Anterior (Segundo, Lista)  elem
Terminar devolviendo Lista

Pensar como insertar al final de la lista

Otros Algoritmos
Eliminar_principio(Lista)  Resp
Si (Lista = Vacía) entonces
Resp No
C/c
Si (Primer= Ultimo) entonces //Lista tiene un solo elemento
Primer(Lista)  Eliminar
Último(Lista)  Eliminar
Resp SI
C/c //Lista tiene más de un elemento
elem Primer(Lista)
Primer(Lista) Siguiente(elem, Lista)
Anterior (elem, Lista)  Eliminar
Resp SI
Terminar devolviendo Resp

– Pensar como eliminar un elemento dado de la lista

Primera forma de Programación
último

ARRAY vaca Puerco rana loro mon0

Primer elemento de la lista ocupa la posición 0, el último puede estar apuntado por índice,
El siguiente de un elemento que ocupa la iésima posición esta en i+1, Anterior i-1
InsertarFinal O(1 ) . EliminarFinal O(1 ). Insertar_Principio O( N ) . Eliminar_Principio O( N ).

Segunda forma de Programación

primer
último
LISTA
ARRAY mono vaca Puerco rana loro
int PRIMER; // -1
int ULTIMO; // -1
T array[100];
Primer elemento de la lista y el último pueden estar apuntados por índices,
El Siguiente de un elemento que ocupa la iésima posición esta en i+1 SI i <> TAM-1 InsertarFinal O(1 )
El Anterior de un elemento que ocupa la iésima posición esta en i-1 SI i <> 0 EliminarFinal O(1 )
Insertar_Principio O( 1 )
InsertarFinal O(1 ) . EliminarFinal O(1 ). Eliminar_Principio O( 1 )
Insertar_Principio O( 1 ) . Eliminar_Principio O( 1 ). MostrarLista O( N)
MostrarLista O( N ). BuscarRec O ( N ) . BuscarNoRec O ( N ) BuscarRec O ( N )
BuscarNoRec O ( N )

Lista = { vaca, puerco, rana, loro, mono }

Segunda forma de Programación
bool Lista :: Insertar_principio( T elem)
resp=´s´
Si ( primer==-1 ) entonces
Primer 0
Último 0
array[Primer]  elem
C/c
Si(primer==0)
Si (ultimo != Tam-1) primer=Tam-1;
c/c resp=´n´; // array se lleno
c/c
Si (ultimo != primer-1) primer= primer-1
c/c resp=´n´; // array se lleno

Si (resp!=´n´)
array[Primer]  elem
Terminar devolviendo resp
Segunda forma de Programación

bool Lista :: BuscarRecursivo( T elem)

…