Escolar Documentos
Profissional Documentos
Cultura Documentos
Las listas son una estructura de datos fundamental, empleadas para almacenar una
colección de elementos. Su importancia radical reside en que puede utilizarse para
implementar una amplia variedad de otros tipos de datos. Es decir TAD Lista sirve como
bases para implementar otros TAD más complicados.
Las listas constituyen una estructura flexible, ya que puede crecer y acortarse según se
requiera, los elementos son accesibles y se pueden insertar y suprimir en cualquier
posición de la lista. También se puede operar sobre listas, por ejemplo concatenarlas,
dividirlas en sub-listas o mezclarlas.
Listas
Una lista es una secuencia de ceros o más elementos de un determinado tipo y se
definir como una n-tupla dinámica (donde dinámica significa que los elementos
pueden cambiar con el tiempo) de la siguiente forma:
No se impone ninguna restricción en los elementos de una lista, si todos los elementos
son de un mismo tipo (p.e. enteros) se dice que es homogénea. Sin embargo diferentes
tipos (p.e. enteros, flotantes, complejos) pueden ser almacenados en la lista entonces
se dice que la lista es heterogénea. En algunas aplicaciones se trabaja con lista de
listas:
L=((3),(4,5,6),(12,8,(10,11),2,()))
Estructuras para el manejo de Listas
#define MAX_ELEMENTOS 15
typedef struct{
int longitud;
int actual;
int elementos[MAX_ELEMENTOS];
} Lista;
typedef struct{
nodo_t *ini,*fin;
…
} lista_t;
prox prox prox
Estructuras para el manejo de Listas
typedef struct{
nodo_t *ini,*fin; lista
} lista_t;
ini fin
typedef struct{
nodo_t *ini,*fin; lista
} lista_t;
ini fin
En estas listas los elementos están ordenados de modo que su clave es la relativa a la
clave de los elementos que le precede. Por ejemplo, digamos que se tienen los
siguientes elementos, a, b, c, d, con retrasos de 10, 15, 12 y 22 unidades de tiempo de
espera respectivamente. Se pueden representar en una cola de prioridad (con clave los
tiempo de espera) de la siguiente formas: a, c, b, d, con claves de 10, 2, 3 y 7,
respectivamente.
TAD Pila
Pop(S), suprime el primer elemento de la pila S, puede ser conveniente que retorne
el primer elemento.
typedef struct{
nodo_t *top;
} stack; …
prox prox prox
stack * newStack()
{
stack *s;
if((s = (stack *)malloc(sizeof(stack))) == NULL)
exit(1);
s->top = NULL;
return s;
};
TAD Pila (Implementación con Listas)
newp->next = s->top;
newp->elemento = value;
s->top = newp;
return 1;
}
TAD Pila (Implementación con Listas)
int main(){
stack *s = newStack();
int x;
printf("Vacio: %d\n", vacia(s));
push(s,1);
push(s,2);
push(s,3);
push(s,4);
top(s, &x);
printf("Element At Top: %d\n", x);
pop(s, &x);
printf("Element Removed: %d\n", x);
top(s, &x);
printf("Element At Top: %d\n", x);
Anula(s);
printf("Vacio: %d\n", vacia(s));
return 0;
}
TAD Pila (Implementación con Arreglos)
printf("Implementacion de Pila\n");
anula(&S);
push(&S,1);
push(&S,2);
push(&S,3);
push(&S,4);
push(&S,5);
top(&S,&e);
printf("El elemento del tope es %d\n",e);
while(pop(&S,&e))
printf("%d\n",e);
Implementacion de Pila
El elemento del tope es 5
5
4
3
2
1
TAD Cola
Las operaciones ofrecidas por el TAD Lista pueden ser utilizadas para implementar el TAD
cola. A continuación se muestran operaciones sobre colas, donde Q es una cola y x un
elementos.
queue
typedef struct nodo{
int elemento; ini fin
struct nodo *next;
} nodo_t;
typedef struct{
nodo_t *ini;
nodo_t *fin; …
} queue; ant sig ant sig ant sig
queue * newQueue()
{
queue *q;
if((q = (queue *)malloc(sizeof(queue))) == NULL)
exit(1);
q->ini = q->fin = NULL;
return q;
};
TAD Cola (Implementación con Listas)
newp->next = NULL;
newp->elemento = value;
if(!q->ini){
q->ini = q->fin = newp;
}else{
q->fin->next = newp;
q->fin = newp;
}
return 1;
}
TAD Cola (Implementación con Listas)
int main(){
queue *q = newQueue();
int x;
printf("Vacio: %d\n", vacia(q));
poner_en_cola(q,1);
poner_en_cola(q,2);
poner_en_cola(q,3);
poner_en_cola(q,4);
frente(q, &x);
printf("Element in front: %d\n", x);
quitar_de_cola(q, &x);
printf("Element Removed: %d\n", x);
frente(q, &x);
printf("Element in front: %d\n", x);
Anula(q);
printf("Vacio: %d\n", vacia(q));
return 0;
}
TAD Cola (Arreglos Circulares)
typedef struct{
int elem[MAX_COLA];
int cuenta;
int frente;
int ultimo;
}cola_t;
cola_t Q;
int e;
printf("Implementacion de cola\n");
anula(&Q);
poner_en_cola(&Q,1);
poner_en_cola(&Q,2);
poner_en_cola(&Q,3);
poner_en_cola(&Q,4);
poner_en_cola(&Q,5); Implementacion de cola
frente(&Q,&e); Primer elemento:1
printf("Primer elemento:%d\n",e); 1
while(quitar_de_cola(&Q,&e)) 2
printf("%d\n",e); 3
4
5