Apuntes Nº4 (TDA Estructuras Lineales).pptx

APUNTES Nº4
ESTRUCTURAS DE DATOS LINEALES
Irene Zuccar Parrini
2023
Algoritmos y Estructuras de Datos

Estructura de Datos Lineales: Listas
2
 Una lista es una secuencia de 0 ó más elementos del mismo tipo (simple, compuesto o creado por ti).
 Maneja la noción de posición de sus objetos. Formalmente una lista se representa:
L = <x1, x2, x3, ..., xn-1, xn> con n  0
 Cada elemento xi es de tipo tipoDato y se tiene que:
n : es la longitud de la lista
x1 : es primer elemento
xn : es último elemento
xi : elemento de la posición i-ésima
 La principal propiedad de las listas es que sus elementos están linealmente ordenados de acuerdo a su
posición en la lista. Se dice que:
xi está antes de xi+1
xi está después de xi-1
Ejemplo: Para las siguientes listas L1, L2 y L3 ¿qué listas son iguales?
L1 = <5, 6, 7, 10> L2 = <6, 10, 5, 7> L3 = <5, 6, 7, 10>
Entonces L1 es igual a L3, pero ellas no son iguales a L2.
¿Qué es una lista?

3
Existen diversas formas de representar Listas. No obstante, a partir de un enfoque general , se
pueden dividir en Representación Dinámica y Representación Estática.
Listas - Representación Computacional

4
dirección RAM
... ...
... A1
... ...
A1 43
FF8
... ...
A7 5
NULL
... ...
B1 -3
A7
... ...
...
FF8 8
B1
L
info
sig
info
sig
info
sig
43
L
8 -3 5
Listas - Representación Computacional
info
sig
43 8 -3 5
0 1 2 3
L[0]
dirección RAM
... ...
... ...
... ...
100 43
101 8
102 -3
103 5
...
... ...
B1 ...
...
... 4
...
FF8 ...
...
Representación Estática
Al ejecutar su tamaño NO puede cambiar
Representación Dinámica
Al ejecutar su tamaño SÍ puede cambiar
n
L:
L[1]
L[2]
L[3]
L
ESTRUCTURAS
DE TIPO
“nodo”

LISTAS:
REPRESENTACIÓN DINÁMICA
5

Listas - Representación Dinámica
6
• También se les conoce como listas dinámicas, listas enlazadas, linked list, o simplemente listas (a
diferencia de la representación estática que se les conoce como arreglos)
• Esta representación permite un uso más eficiente de la memoria, generando elementos en la lista sólo
en la medida que se requiera. Por lo tanto, la lista puede crecer “infinitamente” (cuestionar!).
• Además, las modificaciones en los elementos de la lista, sólo se realizan sobre el nodo en cuestión, es
decir, no se “mueve” en la RAM el resto de los elementos.

7
#include <stdio.h>
#include <stdlib.h>
struct nodo{
int info;
struct nodo *sig;
};
typedef struct nodo tNodo;
int main()
{
tNodo *p;
p = malloc(sizeof(tNodo));
p->info = 40;
p->sig = NULL;
return 0;
}
Listas Dinámicas
40
p
sig
info
• Estas líneas permiten crear un
nodo de una lista.
• Se usarán muchas veces!!!
• Entonces, lo lógico es CREAR
UNA FUNCIÓN que haga este
trabajo.

#include <stdio.h>
#include <stdlib.h>
struct nodo{
int info;
struct nodo *sig;
};
tNodo *creaNodo(int valor)
{
tNodo *p;
p->info = 40;
p->sig = NULL;
return p;
}
int main()
{
tNodo *L;
L = creaNodo(40);
return 0;
} 8
#include <stdio.h>
#include <stdlib.h>
struct nodo{
int info;
struct nodo *sig;
};
int main()
{
tNodo *p;
p->info = 40;
p->sig = NULL;
return 0;
}
valor;
40
p
sig
info
Listas Dinámicas

#include <stdio.h>
#include <stdlib.h>
struct nodo{
int info;
struct nodo *sig;
};
tNodo *creaNodo(int valor)
{
tNodo *p;
p->info = valor;
p->sig = NULL;
return p;
}
int main()
{
tNodo *L;
L = creaNodo(40);
return 0;
}
Lista
Lista
Lista
9
typedef tNodo *Lista;
Listas Dinámicas

Al imprimir en C Corresponde a:
printf("%p", L); A1
printf("%i", L->sig->sig->info); 100
printf("%i", L->sig->info); -8
printf("%p", L->sig->sig->sig); NULL
printf("%p", L->sig); A7
printf("%p", L->sig->sig); B1
printf("%i", L->info); 43
10
43
L
-8 100
RAM
... ...
... A1
... ...
A1 43
A7
... ...
A7 -8
B1
... ...
B1 100
NULL
... ...
L
EJERCICIO AUTÓNOMO: Realiza los ejercicios que aparecen en EjercicioListas.c
info
sig
info
sig
info
sig
Ejemplo de generación de una lista dinámica de 3 enteros:
info sig info sig info sig
Listas Dinámicas

Lista insertaInicio(Lista L, int dato)
{
Lista pNodo;
pNodo = creaNodo(dato);
pNodo->sig = L;
L = pNodo;
pNodo = NULL;
return L;
}
11
Insertar al inicio: Esta función recibe una lista (con 0 o más elementos) y un número, luego inserta un nodo
nuevo al principio de la lista con tal número, y finalmente retorna la lista.
Listas Dinámicas – Operaciones (Algoritmos)
L
32
int main()
{
Lista L;
L = NULL;
L = insertaInicio(L, 32);
L = insertaInicio(L, -8);
return 0;
}
32
32
pNodo
L

{
Lista pNodo;
pNodo->sig = L;
L = pNodo;
pNodo = NULL;
return L;
}
12
L
32
int main()
{
Lista L;
L = NULL;
return 0;
}
-8
-8
pNodo
L
-8

{
Lista pNodo;
pNodo->sig = L;
L = pNodo;
pNodo = NULL;
return L;
}
13
L
32
int main()
{
Lista L;
L = NULL;
return 0;
}
15
15
pNodo
L
15 -8
¿Cómo sería el algoritmo que
permita insertar al final de la lista?

14
 Para crear funciones sobre listas, debemos pasar por cada nodo de ella.
 Entonces ¿Cómo recorro una lista?
 Debemos usar un CICLO
 Pero, no podemos mover al puntero L !!!
 Debemos usar un puntero auxiliar.

15
Lista aux;
aux = L;
while (aux != NULL)
{
aux = aux->sig;
}
aux aux aux aux
Estas instrucciones debes usar si quieres pasar por cada nodo de la lista:
aux
Listas Dinámicas – DISEÑO de Operaciones (Algoritmos)
Dentro del while:
• Buscar un nodo
• Analizar contenido del nodo
• Actualizar cada nodo
• Imprimir cada nodo
• Contar cada nodo
AHORA TÚ!!
Realiza la actividad 6
Ejercicio 2, N°1 y N°2

16
Lista aux;
aux = L;
while (aux->sig != NULL)
{
aux = aux->sig;
} aux aux aux
Estas instrucciones debes usar si quieres dejar una flecha apuntando al último nodo de la lista:
Insertar al final: Para generar esta función se requiere:
• Recibir la lista (con 0 o más elementos) y un dato que se quiera agregar a la lista.
• Crear el nuevo nodo con el dato recibido.
• Si la lista está vacia se ingresa el nuevo nodo.
• Pero, si la lista no está vacía …. ¡Se necesita llegar hasta el último nodo para enlazar al nuevo nodo!
• Y finalmente retornar la lista modificada.
aux
AHORA TÚ!!
Ejercicio 2, N°3

17
Lista aux;
aux = L;
while (aux->sig != NULL)
{
aux = aux->sig;
}
El auxiliar pasa por cada nodo
excepto el último
El auxiliar pasa por cada nodo,
incluyendo al último
Lista aux;
aux = L;
while (aux != NULL)
{
aux = aux->sig;
}
Saber usar estos “esqueletos” de códigos te permitirá
resolver CUALQUIER EJERCICIO
(Solemne 1 y Tarea 1)
AHORA TÚ!!
Ejercicio 1

18
Insertar en posición p de una lista de enteros
Lista insertaPosicion(Lista L, int p, int dato) /* Validación externa: p ≤ largo de L + 1. */
{
Lista pNodo, aux;
int i;
if (p == 1) /* Inserta en la primera posición. */
{
pNodo->sig = L;
L = pNodo;
}
else
{
aux = L;
i = 1;
while (i < p-1) /* Posiciona a aux en la posición ANTERIOR donde se insertará. */
{
aux = aux->sig;
i++;
}
pNodo->sig = aux->sig;
aux->sig = pNodo;
}
return L;
}

{
Lista pNodo, aux;
int i;
{
pNodo->sig = L;
L = pNodo;
}
else
{
aux = L;
i = 1;
{
aux = aux->sig;
i++;
}
aux->sig = pNodo;
}
return L;
}
19
L
32
dato=32 p=1
pNodo
Inserta al principio
de una lista vacía.

{
Lista pNodo, aux;
int i;
{
pNodo->sig = L;
L = pNodo;
}
else
{
aux = L;
i = 1;
{
aux = aux->sig;
i++;
}
aux->sig = pNodo;
}
return L;
}
20
L
120
100
5
-10
32
dato=32 p=1
pNodo
Inserta al principio

{
Lista pNodo, aux;
int i;
{
pNodo->sig = L;
L = pNodo;
}
else
{
aux = L;
i = 1;
{
aux = aux->sig;
i++;
}
aux->sig = pNodo;
}
return L;
}
21
L
120
100
5
-10
32
dato=32 p=4
pNodo
aux
i = 1
aux
i = 2
aux
i = 3
Inserta al “medio”
¿i < 3?

{
Lista pNodo, aux;
int i;
{
pNodo->sig = L;
L = pNodo;
}
else
{
aux = L;
i = 1;
{
aux = aux->sig;
i++;
}
aux->sig = pNodo;
}
return L;
}
22
L
120
100
5
-10
32
dato=32 p=5
pNodo
aux
i = 1
aux
i = 2
aux
i = 3
¿i < 4?
aux
i = 4
Inserta al final
AHORA TÚ!!
Ejercicio 2

23
Insertar ordenado de menor a mayor en una lista de enteros
Lista insertaOrdenado(Lista L, int dato)
{
Lista pNodo, aux;
if (L == NULL)
{
L = pNodo;
}
else
{
if (dato < L->info)
{
pNodo->sig = L;
L = pNodo;
}
else {
aux = L;
while (aux->sig != NULL && (dato < aux->info || dato > aux->sig->info))
{
aux = aux->sig;
}
aux->sig = pNodo;
}
}
return L;
}

{
Lista pNodo, aux;
if (L == NULL)
{
L = pNodo;
}
else
{
if (dato < L->info)
{
pNodo->sig = L;
L = pNodo;
}
else {
aux = L;
{
aux = aux->sig;
}
aux->sig = pNodo;
}
}
return L;
}
24
L
10
dato=10
pNodo

{
Lista pNodo, aux;
if (L == NULL)
{
L = pNodo;
}
else
{
if (dato < L->info)
{
pNodo->sig = L;
L = pNodo;
}
else {
aux = L;
{
aux = aux->sig;
}
aux->sig = pNodo;
}
}
return L;
}
25
L
15
10
7
2
-5
dato=-5
pNodo
L
-5

{
Lista pNodo, aux;
if (L == NULL)
{
L = pNodo;
}
else
{
if (dato < L->info)
{
pNodo->sig = L;
L = pNodo;
}
else {
aux = L;
{
aux = aux->sig;
}
aux->sig = pNodo;
}
}
return L;
}
L
40
20
5
1
30
dato=30
pNodo
aux aux aux
26
40
30
30 30
1 5
5 20
20 40

27
Lista eliminaPosicion(Lista L, int p) /* Validación externa: p ≤ largo de L. */
{
Lista aux, auxNodo;
int i;
aux = L;
if (p == 1)
{
L = L->sig;
free(aux);
}
else
{
i = 1;
while (i < p - 1) /* Deja a aux en la pos ANTERIOR donde se eliminará. */
{
aux = aux->sig;
i++;
}
auxNodo = aux->sig;
aux->sig = auxNodo->sig;
free(auxNodo);
}
return L;
}
Elimina nodo de la posición p de una lista de enteros

{
Lista aux, auxNodo;
int i;
aux = L;
if (p == 1)
{
L = L->sig;
free(aux);
}
else
{
i = 1;
{
aux = aux->sig;
i++;
}
auxNodo = aux->sig;
free(auxNodo);
}
return L;
}
28
p=1
120
100
5 32
L
L
aux
-10

{
Lista aux, auxNodo;
int i;
aux = L;
if (p == 1)
{
L = L->sig;
free(aux);
}
else
{
i = 1;
{
aux = aux->sig;
i++;
}
auxNodo = aux->sig;
free(auxNodo);
}
return L;
}
p=4
120
100
5
-10
L
aux
i = 1
aux
i = 2
aux
i = 3
¿i < 3?
29
auxNodo
32
AHORA TÚ!!
Realiza la actividad 7:
Ejercicios de generación de
código

30
Lista actualizaLista(Lista L, int p, int dato) /* Validación externa: p  largo L. */
{
Lista aux;
int i;
aux = L;
i = 1;
while (i < p)
{
aux = aux->sig;
i++;
}
aux->info = dato;
return L;
}
¿i < 4?
Actualiza la información del nodo en la posición p de una lista de enteros
p=4
120
100
5
-10 32
L
aux
i = 1
aux
i = 2
aux
i = 3
aux
i = 4
18
dato=18

31
int largoLista(Lista L)
{
Lista aux;
int cont;
cont = 0;
aux = L;
while (aux != NULL)
{
cont++;
aux = aux->sig;
}
return cont;
}
Calcula la cantidad de nodos que posee una lista de enteros

{
Lista aux;
int cont;
cont = 0;
aux = L;
while (aux != NULL)
{
cont++;
aux = aux->sig;
}
return cont;
}
32
L aux
0
cont = 0

33
5
cont = 0
120
100
5
-10 32
L
aux aux aux aux aux
aux
cont = 1
cont = 2
cont = 3
cont = 4
cont = 5
NOTA IMPORTANTE:
Observa que, si se manejara una variable global n, que
aumente en 1 por cada inserción y disminuya en 1 por
cada eliminación, no sería necesario usar un ciclo por lo
que será más eficiente este algoritmo.
{
Lista aux;
int cont;
cont = 0;
aux = L;
while (aux != NULL)
{
cont++;
aux = aux->sig;
}
return cont;
}

34
int posicionElementoLista(Lista L, int dato)
{
Lista aux;
int i;
aux = L;
i = 1;
while (aux != NULL)
{
if (aux->info == dato)
{
return i; //Encontrado
}
aux = aux->sig;
i++;
}
return -1; //NO Encontrado
}
Determina la posición de un elemento dentro de la lista de enteros. Si no lo encuentra retorna -1

int posicionElementoLista(Lista L, int dato)
{
Lista aux;
int i;
aux = L;
i = 1;
while (aux != NULL)
{
if (aux->info == dato)
{
return i; //Encontrado
}
aux = aux->sig;
i++;
}
return -1; //NO Encontrado
}
35
120
100
5
-10 32
L
dato = 100
aux aux aux
3
i=1 i=2 i=3
Determina la posición de un elemento dentro de la lista de enteros. Si no lo encuentra retorna -1

36
Determina el elemento que está en una posición p dentro de una lista de enteros.
int elementoPosicionLista(Lista L, int p) /* Validación externa: p  largo L */
{
Lista aux;
int i;
aux = L;
i = 1;
while (i < p)
{
aux = aux->sig;
i++;
}
return aux->info;
}

int elementoPosicionLista(Lista L, int p) /* Validación externa: p  largo L */
{
Lista aux;
int i;
aux = L;
i = 1;
while (i < p)
{
aux = aux->sig;
i++;
}
return aux->info;
}
37
p=4
120
100
5
-10 32
L
aux
i = 1
aux
i = 2
aux
i = 3
¿i < 4?
aux
i = 4
32
Determina el elemento que está en una posición p dentro de una lista de enteros.

38
Operaciones sobre una Lista - Constructora:
 creaNodo(dato)  L
Esta función crea un nodo de una lista, con el dato en su campo de información, y luego retorna la
dirección de ese nodo.
Operaciones sobre una Lista - Modificadoras:
En las siguientes operaciones, el tipo de dato de dato es del tipo de dato almacenado en la lista L:
 insertaLista(dato, p, L)  L
Esta función inserta dato en la posición p de la lista L, poniendo los elementos de la posición p y
siguientes, a continuación de dato.
 eliminaLista(p, L)  L
Elimina el elemento de la posición p de la lista L. El resultado está indefinido (error) si L no tiene la
posición p.
 actualizaLista(p, dato, L)  L
Actualiza el elemento de la posición p con el elemento dato. El resultado está indefinido (error) si L no
tiene la posición p.
Listas Dinámicas – Operaciones Resumen

39
Operaciones sobre una Lista - Analizadoras:
 LargoLista(L)  n
Entrega el número de elementos que posee L.
 posicionElementoLista(dato, L)  p
Entrega la posición de dato en L. Si dato está repetido, entrega la primera posición de éste. El
resultado está indefinido (error) si L no tiene al elemento dato.
 elementoPosicionLista(p, L)  dato
Entrega el elemento dato (una copia) que está en la posición p en la lista L. El resultado está
indefinido (error) si L no tiene la posición p.
Listas Dinámicas – Operaciones Resumen

Listas Especiales:
Pilas y Filas
40

41
Definición:
 Una pila (o stack) es una clase particular de lista en donde todas las inserciones, eliminaciones y
recuperaciones (lecturas) ocurren solo al principio de la lista.
 También se le conoce como listas tipo LIFO (Last-In, First-Out): Es decir, el último en entrar es el primero
en salir.
 Ejemplos:
 Representar los contenedores en un puerto.
 Llamadas a funciones dentro de un programa (Segmento de stack de la RAM).
 A la función que inserta en una Pila, se le conoce como “Push” (También se le dice APILAR).
 A la función que elimina en una Pila se le conoce como “Pop” (también se le dice DESAPILAR).
 NOTA: La estructura que debes definir es igual que para una lista cualquiera!!!!!
Listas especiales: Pila o Stack

42
Listas especiales: Pila o Stack
Pila Push(Pila P, int dato)
{
Pila pNodo;
pNodo->sig = P;
P = pNodo;
pNodo = NULL;
return P;
}
Pila Pop(Pila P)
{
Pila aux;
if (P != NULL) {
aux = P;
P = P->sig;
aux->sig = NULL;
free(aux);
}
aux = NULL;
return P;
}
int Primero(Pila P)
{
return P->info;
}
//La pila debe tener al menos
un dato
P
pNodo
P
P
aux

43
Definición:
 Una cola (o fila) es una clase particular de lista en donde todas las inserciones se realizan al final de la
lista, y las eliminaciones se realizan al principio de la lista.
 También se le conoce como listas tipo FIFO (First-In, First-Out) que significa el primero en entrar es el
primero en salir.
 A la función que inserta en una Fila, se le conoce como “enqueue” o “encolar”. (enkiú)
 A la función que elimina de una Fila se le conoce como “dequeue” o “desencolar”. (dekiú)
 La eficiencia del algoritmo para encolar en la representación dinámica puede mejorar con la siguiente
premisa:
“Si el acceso siempre debe ser al final de la Fila, se puede manejar un puntero que apunte siempre al último
elemento, para evitar recorrer la Fila completa.”
 De esta manera, encolar sólo será agregar un enlace más a la Fila evitando el proceso de recorrerla.
Listas especiales: Fila o Cola

Fila encolar(Fila F, Fila U, int dato) #U apunta SIEMPRE al último elemento.
{
Fila pNodo;
if (F == NULL)
{
F = pNodo;
}
else
{
U->sig = pNodo;
}
U = pNodo;
pNodo = NULL;
return F, U; //OJO AQUÍ
}
44
F
dato
pNodo
U
Operaciones Modificadoras: INSERTAR en una Fila manejando el primer y el último elemento.

Fila encolar(Fila F, Fila U, int dato) #U apunta SIEMPRE al último elemento.
{
Fila pNodo;
if (F == NULL)
{
F = pNodo;
}
else
{
U->sig = pNodo;
}
U = pNodo;
pNodo = NULL;
return F, U; //OJO AQUÍ
}
45
Operaciones Modificadoras: INSERTAR en una Fila manejando el primer y el último elemento.
F
100
120
-8
32
dato=32
pNodo
…
U
32
U

46
Lo que no vimos en la representación dinámica:
 Existen otras variaciones de la representación dinámica de una lista, que no forman parte del programa
de este curso, pero que es importante que sepas de su existencia (imágenes de internet).
 Listas doblemente enlazadas:
 Listas circulares:
 Listas circulares doblemente enlazadas:
L
L
L

47
Lo que no vimos en la representación dinámica:
 Existen otras variaciones de la representación dinámica de una lista, que no forman parte del programa
de este curso, pero que es importante que sepas de su existencia (imágenes de internet).
 Listas doblemente enlazadas - ESTRUCTURA y CONSTRUCTOR en C:
#include <stdio.h>
#include <stdlib.h>
struct Nodo{
int info;
struct Nodo *ant;
struct Nodo *sig;
};
typedef struct Nodo tNodo;
typedef tNodo *ListaDoble;
ListaDoble creaNodo(int valor)
{
ListaDoble aux;
aux = (ListaDoble)malloc(sizeof(tNodo));
if (aux != NULL)
{
aux->info = valor;
aux->ant = NULL;
aux->sig = NULL;
}
else
{
printf("nNo hay memoria suficiente.");
exit(0);
}
return aux;
}

48
… Resumiendo
 Las listas nos sirven para manejar los datos en forma lineal.
 Existen 2 formas de representarlas: estática y dinámica.
 Cada una de ellas tiene ventajas y desventajas que deberás tener presente al momento de escoger una
representación.
 En términos de uso de memoria, la dinámica solo ocupa el espacio que necesita (más eficiente), mientras
que la estática subutiliza espacio ( o puede quedarse sin espacio!)
 La programación sobre la representación estática suele ser más fácil para los programadores, que la
dinámica.

Apuntes Nº4 (TDA Estructuras Lineales).pptx

Recomendados

Recomendados

Más contenido relacionado

Similar a Apuntes Nº4 (TDA Estructuras Lineales).pptx

Similar a Apuntes Nº4 (TDA Estructuras Lineales).pptx (20)

Último

Último (20)

Apuntes Nº4 (TDA Estructuras Lineales).pptx