Estructuras de datos lineales
|
|
- Lorenzo Díaz Márquez
- hace 6 años
- Vistas:
Transcripción
1 Tema 6. Estructuras de datos lineales INTRODUCCIÓN...1 IMPLEMENTACIÓN DE ESTRUCTURAS DE DATOS CON PUNTEROS...2 PILAS...3 ESPECIFICACIÓN ALGEBRAICA (PILA NO ACOTADA)...3 ESPECIFICACIÓN ALGEBRAICA (PILA ACOTADA)...4 POSIBLES IMPLEMENTACIONES...5 EJEMPLO: IMPLEMENTACIÓN ESTÁTICA (IMPERATIVA)...6 EJEMPLO: IMPLEMENTACIÓN ESTÁTICA (GENÉRICA, POO)...7 EJEMPLO: IMPLEMENTACIÓN DINÁMICA...8 APLICACIÓN: EVALUACIÓN DE EXPRESIONES EN NOTACIÓN POLACA...10 COLAS...14 ESPECIFICACIÓN ALGEBRAICA (COLA NO ACOTADA)...14 POSIBLES IMPLEMENTACIONES...15 EJEMPLO: IMPLEMENTACIÓN ESTÁTICA...15 LISTAS...18 ESPECIFICACIÓN ALGEBRAICA...19 INTERFAZ DE UNA CLASE LISTA...20 POSIBLES IMPLEMENTACIONES...21 MODIFICACIÓN DE LA DEFINICIÓN DEL TAD: INSERTAR EN ORDEN...23 OTROS TIPOS DE LISTAS...27 LISTA CON PUNTO DE INTERÉS...29 ESPECIFICACIÓN ALGEBRAICA DE LA LISTA CON PUNTO DE INTERÉS...30 Página 0
2 Tema 6. Estructuras de datos lineales Introducción Es necesario el uso de TADs que permitan almacenar una colección de elementos de un determinado tipo. Estructuras de datos lineales: para almacenar secuencias: cada elemento tiene un único sucesor (excepto el último) y un único predecesor (excepto el primero). Operaciones necesarias: crear, insertar un elemento, eliminar un elemento, consultar, etc. Según cómo se realicen las operaciones consideradas, tendremos TADs distintos. Podemos considerar estructuras de datos: - Estáticas: hay un número máximo de elementos; implementadas con un vector. - Dinámicas: sin número máximo de elementos, si suponemos memoria infinita; implementadas con punteros. Para un TAD con un comportamiento determinado pueden existir varias implementaciones distintas. Si los costes de las operaciones en distintas implementaciones son diferentes, hay que seleccionar la más adecuada según la aplicación donde se vaya a utilizar. Página 1
3 Implementación de estructuras de datos con punteros Ventajas: - No es necesario determinar la dimensión máxima de la estructura (aunque la memoria no es infinita, realmente) - El programador no tiene que gestionar el espacio libre (aunque el SO puede hacerlo de manera ineficiente) El problema de la asignación: p q - Un único objeto está identificado por dos o más punteros; no hay copia - Solución: todo TAD debe ofrecer una operación duplica que se usará en lugar de la asignación El problema de la comparación: p = q - Se comparan direcciones, no los objetos - Solución: todo TAD debe ofrecer una operación igual para comparar El problema de los parámetros de entrada - Cuando usamos un parámetro de entrada, se pasa una copia del puntero, que no variará, pero sí pueden modificarse los datos de la estructura - Solución: Prohibido modificar los parámetros de entrada; si es necesario, hacer una copia con duplica El problema de las variables auxiliares - Se debe liberar toda la memoria utilizada por las estructuras con punteros creadas como variables auxiliares - Solución: llamar a una función destruir que libere todo el espacio (o confiar en el recolector de basura, si existe) El problema de la reinicialización - Si aplicamos la operación de creación sobre una estructura con información, dejaremos espacio inaccesible en la memoria - Solución: Llamar a la operación destruir cuando la información de la estructura ya no es necesaria Página 2
4 Pilas Pila: Stack: LIFO (Last In, First Out) Ejemplo informático: gestión de memoria; almacenamiento de las llamadas a procedimientos y variables locales. Operaciones básicas: Crear (create), Apilar (push), Desapilar (pop), Cima (top, peek), Vacía? (empty) Si tenemos un espacio limitado en la pila, serán necesarias operaciones para saber si la pila está llena y su profundidad (número de elementos). Especificación algebraica (pila no acotada) TAD Pila TIPO: Pila (elemento) SINTAXIS: crear () Pila vacía (Pila) Boolean cima (Pila) Elemento apilar (Pila, Elemento) Pila desapilar (Pila) Pila SEMÁNTICA: P Pila; i Elemento vacía (crear) Cierto vacía (apilar (P,i)) Falso cima (crear) Error cima (apilar (P,i)) i desapilar (crear) crear o Error desapilar (apilar (P,i)) P Página 3
5 Especificación algebraica (pila acotada) TAD Pila TIPO: Pila (elemento, Máximo) SINTAXIS: crear ( ) Pila vacía (Pila) Boolean cima (Pila) Elemento apilar (Pila, Elemento) Pila desapilar (Pila) Pila profundidad (Pila) Natural llena (Pila) Boolean SEMÁNTICA: P Pila; i Elemento vacía (crear) Cierto vacía (apilar (P,i)) Falso cima (crear) Error cima (apilar (P,i)) i desapilar (crear) crear o Error desapilar (apilar (P,i)) P profundidad (crear) cero profundidad (apilar(p, i)) sucesor( profundidad (P) ) llena (P) igual( profundidad(p), Máximo) apilar (P, i) si llena(p) entonces Error si no apilar (P, i) Página 4
6 Posibles implementaciones Implementación estática n A B C?...? Cima: 3 - Inserciones y extracciones por el final del vector, indicado por Cima. - Sin el atributo Cima el coste de todas las operaciones sería lineal. Implementación dinámica Cima A B C - Inserciones y extracciones por el principio, apuntado por Cima. Página 5
7 Ejemplo: Implementación estática (imperativa) // pila.h // Definición de la interfaz del TAD Pila // Implementación estática #define Max 100 // Nº máximo de elementos; typedef int dato; // Tipo de los elementos typedef dato vector[max]; typedef struct pila vector elemento; int cont; ; // Tipo de la pila // Operaciones void crear (pila &p); boolean estavacia (pila p); boolean estallena (pila p); void apilar (pila &p, dato e); void cima (pila p, dato &e); void eliminar (pila &p); // pila.cpp #include "pila.h" void crear (pila &p) p.cont = 0; boolean estavacia (pila p) if (p.cont == 0) return(true); else return(false); boolean estallena (pila p) return( (p.cont == Max)); void apilar (pila &p, dato e) // error si la pila estuviera llena p.elemento[p.cont] = e; p.cont++; void cima (pila p, dato &e) // error si la pila estuviera vacía e = p.elemento[p.cont-1]; void eliminar (pila &p) // error si la pila estuviera vacía p.cont--; Página 6
8 Ejemplo: Implementación estática (genérica, POO) # include <iostream.h> template <class Tipo> class pila Tipo *datos; int top, num; public: pila(int max=100); void insertar(tipo c); Tipo cima(void); int vacia(void); void borrar(void); ~pila(); ; template <class Tipo> pila<tipo>::pila(int max) datos=new Tipo[max]; top=-1; num=max; template <class Tipo> pila<tipo>::~pila() delete [] datos; template <class Tipo> Tipo pila<tipo>::cima(void) if (top == -1) return 0; else return datos[top] ; template <class Tipo> void pila<tipo>::borrar(void) if (top == -1) cout << "pila vacía \n"; else top--; template <class Tipo> int pila<tipo>::vacia(void) return (top == -1); ; template <class Tipo> void pila<tipo>::insertar(tipo c) if (top == num-1) cout << " pila llena \n"; else top++; datos[top] = c; ; Página 7
9 Ejemplo: Implementación dinámica Data Structures and Algorithm Analysis in C++ (Second Edition). Mark Allen Weiss. // Stack class -- linked list implementation // // CONSTRUCTION: with no parameters // //**PUBLIC OPERATIONS*************** // void push( x ) --> Insert x // void pop( ) --> Remove most recent item // Object top( ) --> Return most recent item // Object topandpop( ) --> Return and remove // bool isempty( ) --> Return true if empty// bool isfull( ) --> Return true if full// void makeempty( ) --> Remove all items // ******************ERRORS************* // Overflow and Underflow thrown as needed class Stack public: Stack( ); Stack( const Stack & rhs ); ~Stack( ); bool isempty( ) const; bool isfull( ) const; const Object & top( ) const; void makeempty( ); void pop( ); void push( const Object & x ); Object topandpop( ); const Stack & operator=( const Stack & rhs ); private: struct ListNode Object element; ListNode *next; ListNode( const Object & theelement, ListNode * n = NULL ) : element( theelement ), next( n ) ; ListNode *topofstack; ; /** * Construct the stack. Stack<Object>::Stack( ) topofstack = NULL; /** * Copy constructor. Stack<Object>::Stack( const Stack<Object> & rhs ) topofstack = NULL; *this = rhs; /** * Destructor. Stack<Object>::~Stack( ) makeempty( ); /** * Test if the stack is logically full. * Return false always, in this implementation. bool Stack<Object>::isFull( ) const return false; /** * Test if the stack is logically empty. * Return true if empty, false otherwise. bool Stack<Object>::isEmpty( ) const return topofstack == NULL; Página 8
10 /** * Make the stack logically empty. void Stack<Object>::makeEmpty( ) while(!isempty( ) ) pop( ); /** * Get the most recently inserted item. * Return the most recently inserted item * or throw an exception if empty. const Object & Stack<Object>::top( ) const if( isempty( ) ) throw Underflow( ); return topofstack->element; /** * Remove the most recently inserted item from the stack. * Exception Underflow if the stack is empty. void Stack<Object>::pop( ) if( isempty( ) ) throw Underflow( ); ListNode *oldtop = topofstack; topofstack = topofstack->next; delete oldtop; /** * Return and remove the most recently inserted * item from the stack. Object Stack<Object>::topAndPop( ) Object topitem = top( ); pop( ); return topitem; /** * Insert x into the stack. void Stack<Object>::push( const Object & x ) topofstack = new ListNode( x, topofstack ); /** * Deep copy. const Stack<Object> & Stack<Object>:: operator=( const Stack<Object> & rhs ) if( this!= &rhs ) makeempty( ); if( rhs.isempty( ) ) return *this; ListNode *rptr = rhs.topofstack; ListNode *ptr = new ListNode( rptr- >element ); topofstack = ptr; for( rptr = rptr->next; rptr!= NULL; rptr = rptr->next ) ptr = ptr->next = new ListNode( rptr- >element ); return *this; Página 9
11 Aplicación: Evaluación de expresiones en notación polaca Notación infija Notación polaca (postfija) * * + (2 + 3) * * 9 / 6 ^ (1 + 3) * 4 5 * ^ / 4 * 5 9 * - Con una fórmula en notación polaca no es necesario considerar ni los paréntesis ni la prioridad de los operadores. Para evaluar una expresión en notación polaca, se recorre de izquierda a derecha, aplicando los operadores sobre los dos últimos operandos. Cómo se evalúa una expresión en notación polaca? Clase Expresión: Secuencia de elementos de la clase Símbolo. Operaciones: Obtener primero, Eliminar primero, Insertar al final, Vacía? Clase Símbolo: Para almacenar números y operadores. Operaciones: EsOperador?, Valor (para los números), Operador (para los operadores) Usaremos una Pila de enteros para ir almacenando los resultados. Página 10
12 Función Evaluación (ent e: Expresión): entero; var p: PilaEnteros; s: Símbolo; r: entero; Inicio p.crearpila; Mientras no e.vacía? hacer s e.primero; Si no s.esoperador? entonces p.inspila(s.valor) Si no r Eval(p, s.operador); p.inspila(r) Fin Si e.eliminar Fin Mientras retorna (p.cimapila) Fin Función Eval(ent/sal p: PilaEnteros; ent op: Operador): entero; var v1, v2, ev: entero; Inicio v1 p.cimapila; p.borpila; Fin v2 p.cimapila; p.borpila; Opcion op de suma: ev v2 + v1; resta: ev v2 - v1; producto: ev v2 * v1; división: ev v2 / v1; FinOpción retorna (ev) Página 11
13 Transformación de una expresión infija en notación polaca Infija Pila Postfija 2 * (3 + 2) * 5 λ * (3 + 2) * 5 λ 2 (3 + 2) * 5 * ) * 5 * ( 2 + 2) * 5 * ( 2 3 2) * 5 * ( ) * 5 * ( * 5 * * * * * 5 λ * 5 * Los operandos se van añadiendo al final de la expresión postfija. Antes de apilar un nuevo operador, se sacan de la pila aquellos operadores cuya prioridad sea mayor o igual que la prioridad del operador que se está tratando. El paréntesis abierto siempre se mete en la pila, y hay que sacarlo siempre que lo encontremos en la pila. El paréntesis cerrado nunca se mete en la pila; se trata explícitamente en el algoritmo: se sacan todos los operadores hasta encontrar el paréntesis abierto. Tenemos que considerar distintas prioridades en la pila y en la expresión para poder manejar correctamente los paréntesis. El paréntesis abierto tendrá una prioridad mínima (0) en la pila, y máxima en la entrada (10). Página 12
14 Procedimiento InfijaPostfija (ent e1: Expresión; sal e2: Expresión); var p: PilaOperaciones; s: Símbolo; op: Operador; Inicio p.crearpila; p.inspila(operadornulo); e1.añadir(operadornulo); e2.crear; Mientras no e1.vacía? hacer s e1.primero; Si no s.esoperador? entonces e2.añadir(s) Si no op s.operador; Si op = = p_cerrado entonces Mientras no (p.cimapila == p_abierto) hacer e2.añadir(p.cimapila); p.borpila; Fin Mientras; p.borpila el paréntesis abierto Si no Mientras p.cimapila.priorpila >= op.priorexp hacer e2.añadir(p.cimapila); p.borpila Fin Mientras p.inspila(op) Fin Si Fins Si e1. Eliminar Fin Mientras Fin En la pila, insertamos inicialmente un OperadorNulo, que tendrá una prioridad de pila tal que nunca saldrá de la pila (la más baja posible -1; así no hace falta comprobar esta condición). También insertamos el OperadorNulo al final de la expresión infija, que tendrá una prioridad de entrada tal que obligue a sacar de la pila todos los símbolos que haya, excepto el nulo (prioridad 0, por ejemplo). Página 13
15 Colas Cola: Queue: FIFO (First In, First Out) Ejemplo informático: cola de procesos en un sistema operativo, en una impresora; en un servidor. Operaciones básicas: Crear, Insertar, Eliminar, Consultar, está vacía? Si tenemos un espacio limitado en la cola, serán necesarias operaciones para saber si está llena y, a veces, su longitud (número de elementos). Especificación algebraica (cola no acotada) TAD Cola TIPO: Cola (elemento) SINTAXIS: crear ( ) vacía (Cola) insertar (Cola, Elemento) borrar (Cola) frente (Cola) Cola Boolean Cola Cola Elemento SEMÁNTICA: C Cola; i Elemento vacía (crear) Cierto vacía (insertar (C,i)) Falso frente (crear) Error frente (insertar (C,i)) Si vacía (C) i si no frente (C ) borrar (crear) Error borrar (insertar (C,i)) Si vacía (C ) entonces crear si no insertar (borrar (C ), i) Problema: Escribir la especificación algebraica de una cola acotada y de una cola con prioridad Página 14
16 Posibles implementaciones Implementación estática MaxCola? B C D?...? Frente Final Frente: 2 Cont: 3 Final: 5 Inserciones por Final y extracciones por Frente. Añadimos el contador para diferenciar entre cola llena y vacía. Implementación dinámica Frente Final A B C Inserciones por Final y extracciones por Frente. Ejemplo: Implementación estática // Queue class -- array implementation // CONSTRUCTION: with or without a // capacity; default is 10 // **PUBLIC OPERATIONS************* // void enqueue( x ) --> Insert x // void dequeue( ) --> Return and remove // Object getfront( ) --> Return // bool isempty( ) --> Return true if empty // bool isfull( ) --> Return true if full // void makeempty( ) --> Remove all items // **ERRORS************************** // Overflow and Underflow thrown as needed class Queue Página 15
17 public: explicit Queue( int capacity = 10 ); bool isempty( ) const; bool isfull( ) const; const Object & getfront( ) const; void makeempty( ); Object dequeue( ); void enqueue( const Object & x ); private: vector<object> thearray; int currentsize; int front; int back; void increment( int & x ); ; #include "QueueAr.h" /** Construct the queue. Queue<Object>::Queue( int capacity ) : thearray( capacity ) makeempty( ); /** Test if the queue is logically empty. * Return true if empty, false otherwise. bool Queue<Object>::isEmpty( ) const return currentsize == 0; /** Test if the queue is logically full. * Return true if full, false otherwise. bool Queue<Object>::isFull( ) const return currentsize == thearray.size( ); /** Make the queue logically empty. void Queue<Object>::makeEmpty( ) currentsize = 0; front = 0; back = -1; /** Get the least recently inserted item. * Return the least recently inserted item * or throw Underflow if empty. const Object & Queue<Object>::getFront( ) const if( isempty( ) ) throw Underflow( ); return thearray[ front ]; /** Return and remove the least recently * inserted item from the queue. * Throw Underflow if empty. Object Queue<Object>::dequeue( ) if( isempty( ) ) throw Underflow( ); currentsize--; Object frontitem = thearray[ front ]; increment( front ); return frontitem; /** Insert x into the queue. * Throw Overflow if queue is full void Queue<Object>::enqueue(const Object & x ) if( isfull( ) ) throw Overflow( ); increment( back ); thearray[ back ] = x; currentsize++; /** * Internal method to increment x with wraparound. void Queue<Object>::increment( int & x ) if( ++x == thearray.size( ) ) x = 0; Página 16
18 Ejemplo: Implementación dinámica (Genérica, POO) template<class Tipo> class ColaPolimorfica typedef struct Nodo Tipo Info; Nodo *Suce; tiponodo; tiponodo *frente, *fin; int ElementosCola; public: ColaPolimorfica(); void Insertar(Tipo Dato); void BorradoTotal(); void BorrarFrente(); Tipo FrenteCola(); int Vacia(); ; template<class Tipo>ColaPolimorfica<Tipo>::ColaPolimorfica() frente=fin=null; ElementosCola=0; template <class Tipo>void ColaPolimorfica<Tipo>::Insertar(Tipo Dato) tiponodo *nuevo; nuevo=(tiponodo*)malloc(sizeof(tiponodo)); nuevo->info=dato; nuevo->suce=null; if (Vacia()) frente=nuevo; else fin->suce=nuevo; fin=nuevo; ElementosCola++; template <class Tipo>void ColaPolimorfica<Tipo>::BorrarFrente() Nodo* paux; paux=frente; frente=frente->suce; free(paux); ElementosCola--; template <class Tipo>void ColaPolimorfica<Tipo>::BorradoTotal() while (!Vacia()) BorrarFrente(); if (Vacia()) fin=null; template <class Tipo>Tipo ColaPolimorfica<Tipo>::FrenteCola() return (frente->info); template <class Tipo> int ColaPolimorfica<Tipo>::Vacia() return(frente==null); Página 17
19 Listas Definición: Una lista es una secuencia de 0 ó más elementos de un tipo dado (DatosLista). Podemos representar una lista por a 1,..., a n ; con n>=0, y tipo de a i es DatosLista. Hay que tener en cuenta que: Si n >= 1, entonces a 1 es el primer elemento y a n es el último. Si n = 0, entonces la lista está vacía. Diremos que a i está en la posición i. Por la linealidad de la estructura, diremos que: a i precede a a i+1 i = 1, 2,..., n-1 a i sucede a a i-1 i = 2, 3,..., n El primer elemento sólo tienen sucesor. El último sólo tiene predecesor. Definición recursiva de lista: Lista = ( ) Lista vacía (elemento, lista) Posibles operaciones: - Creación de la lista vacía - Inserción de un elemento: al principio, al final, en orden - Borrado de un elemento: el primero, el último, uno determinado - Obtención de un elemento: el primero, uno determinado -... Página 18
20 Especificación algebraica TAD Lista TIPO: Lista (elemento) SINTAXIS: CrearLista () ListaVacia (Lista) Primero (Lista) InsLista (Lista, Elemento) Resto (Lista) Modificar (Lista, Elemento) SupLista (Lista, Elemento) Lista Boolean Elemento Lista Lista Lista Lista SEMÁNTICA: L Lista; x,y Elemento ListaVacia (CrearLista) Cierto ListaVacia (InsLista (L,x)) Falso Primero (CrearLista) Error Primero (InsLista (L,x)) x Resto (CrearLista) Error Resto (InsLista (L,x)) L Modificar (CrearLista) Error Modificar (InsLista (L,y),x) InsLista (L,x) SupLista (CrearLista, x) CrearLista SupLista (InsLista (L,y),x) Si x = y L si no InsLista (SupLista(L,x), y) Página 19
21 Interfaz de una clase Lista typedef... tipodatos; class Lista struct nodol tipodatos info; struct nodol * suce; ; ; struct nodol * E_Lista; public: Lista (); boolean ListaVacia(); void InsLista (tipodatos A); tipodatos Primero (); Lista Resto (); void Modificar (tipodatos A); void SupLista (tipodatos A); void MostrarTodo(); Función para ver si un elemento pertenece o no a una lista: boolean Pertenece (Lista L, tipodatos x) boolean enc=false; tipodatos y; while (!L.ListaVacia() && (!enc)) y = L.primero(); if (x == y)//habría que sobrecargar el operador == enc=true; else L=L.Resto(); return(enc); Página 20
22 Posibles implementaciones Posibles estructuras de datos usadas para implementar listas: Implementación dinámica. L Implementación estática. Con un vector. A B C Posibles representaciones (implementación estática): Secuencial: los elementos consecutivos en la secuencia se almacenan seguidos en el vector. Encadenada: existe un elemento que indica dónde se almacena el siguiente elemento de la secuencia. Posibles implementaciones: Vector; representación secuencial Vector con indicador de último elemento (o primero libre); representación secuencial. Vector; representación encadenada (campo adicional); es necesario un apuntador al primero y otro al último Igual que el anterior, con los espacios libres formando una lista (pila) Estructura dinámica Página 21
23 Una implementación estática encadenada: Tendremos 2 listas en una: Libres y ocupados. Una lista vacía será: Libre = 1 CursorLista = 0 Si insertamos un elemento (por el principio): Libre = 2 CursorLista = 1 Si insertamos más elementos: Libre = 4 CursorLista = 3 Página 22
24 Implementación del procedimiento InsOrden para inserciones en una lista ordenada (desde fuera de la clase Lista): Lista InsOrden (Lista L, tipodatos x); tipodatos y; if (L.ListaVacia()) L.InsLista(x); else y = L.Primero(); if (x < y) L.InsLista(x) else L=L.Resto(); L = InsOrden(L, x); L.InsLista(y); return L; Modificación de la definición del TAD: Insertar en orden Especificación de la operación: InsOrden (CrearLista, x) InsLista (CrearLista, x) InsOrden (InsLista (L,y),x) Si x <= y InsLista (InsLista (L,y), x) si no InsLista (InsOrden (L,x),y) Ejercicio: Implementar la operación InsOrden utilizando las operaciones del TAD y/o trabajando directamente con algunas de las implementaciones. Página 23
25 Ejemplo: Implementación dinámica en C++ (Genérica, POO) #include <conio.h> #include <iostream.h> #include <alloc.h> #include <process.h> // Definición de la clase genérica lista template <class tipodato> class lista struct nodolista // Estructura de un nodo tipodato datos; // Datos del nodo. nodolista *suce; // Apunta a otro nodo de la lista. ; nodolista *E_Lista;// Apunta a un nodo de la lista. int num_elementos; // Mantiene el n mero de elementos de la lista. public: lista(void); // Constructor ~lista(void); // Destructor int vacia(void); // Comprueba si la lista está vacía. tipodato frente(void);// Devuelve el elemento apuntado de la lista void insertar(tipodato dat);// Inserta un nuevo dato dat en lista. void borrar(void); // Elimina el frente de la lista int cuantos_elem(); // Devuelve número de elementos void modificar(tipodato dat); // Modifica el dato frente de lista void borrartodo(); // Elimina toda la lista tipodato devolver(int pos);// Devuelve un elemento de la lista. void sup_lista(tipodato dat); // Elimina un dato dat de la lista void resto(); // Devuelve el resto de la lista ; // lista. /* =========IMPLEMENTACION DE LAS FUNCIONES DEL TAD LISTA ========= template <class tipodato> lista<tipodato>::lista() // Constructor de la lista. Crea una nueva lista vacía y por tanto con // cero elementos. num_elementos = 0; E_Lista = NULL; template <class tipodato> int lista<tipodato>::vacia() // Comprueba si la lista está vacía, devuelve 0 si no está vacía y // otro valor si lo está. return (E_Lista == NULL); template <class tipodato> tipodato lista<tipodato>::frente() // Devuelve el primer elemento de la lista, el accesible desde el // atributo miembro E_Lista. return E_Lista->datos; template <class tipodato> void lista<tipodato>::insertar(tipodato dat) // Inserta un nuevo elemento en la lista, la inserción se realiza al // principio de la lista. nodolista *p; p = new nodolista; // Crea un nuevo nodo. if(p==null) exit(1); p->datos = dat; Página 24
26 p->suce = E_Lista; E_Lista = p; num_elementos++; // Incrementa el número de elementos template <class tipodato> void lista<tipodato>::borrar(void) nodolista *p; if (!vacia()) p = E_Lista; E_Lista=E_Lista->suce; num_elementos--; delete(p); template <class tipodato> tipodato lista<tipodato>::devolver(int pos) // Devuelve el elemento de la lista que está en la posición dada por // el parámetro pos. register int i = 1; nodolista *aux = E_Lista; if (!E_Lista) exit(1); while (i!= pos) if (aux!= NULL) aux = aux->suce; i++; else exit(1); // Se pretende acceder a una posición que desborda //la lista. return aux->datos; template <class tipodato> int lista<tipodato>::cuantos_elem() // Devuelve el número de elementos de la lista. return num_elementos; template <class tipodato> void lista<tipodato>::sup_lista(tipodato dat) // Elimina un elemento de la lista, el elemento a eliminar es el que // viene dado por el parámetro dat. nodolista *ant, *p; int enc = 0; p = E_Lista; while ((!enc) && (p!=null)) // Mientras no encontremos el nodo a eliminar o no lleguemos al // final de la lista, buscamos el nodo. if (p->datos == dat) enc = 1; else ant = p; p = p->suce; if (enc) // Puedeo ourrir que sea el primer elemento o que sea otro if (p == E_Lista) E_Lista = E_Lista->suce; else ant->suce = p->suce; delete (p); num_elementos--; // Decrementamos el numero de elementos Página 25
27 template <class tipodato> void lista<tipodato>::resto() // Si la lista no está vacía adelanta el puntero de la lista. if (!vacia()) E_Lista = E_Lista->suce; template <class tipodato> void lista<tipodato>::modificar(tipodato dat) // Modifica un dato de la lista, el dato a modificar ser el accesible // por el atributo miembro E_Lista, y el nuevo valor ser el que le // pasemos por parámetro. if (!vacia()) E_Lista->datos = dat; template <class tipodato> lista<tipodato>::~lista() // Destructor de la clase lista. Libera la memoria asignada por los // nodos de la lista. Esto sólo habrá que hacerlo mientras la lista no // esté vacía. while (!vacia()) nodolista *p; p = E_Lista; E_Lista = E_Lista->suce; delete (p); num_elementos--; template <class tipodato> void lista<tipodato>::borrartodo() // Es una variante del destructor de la clase lista y sirve para // eliminar un tipo de lista que almacena como datos de la lista // punteros otros elementos asignados dinámicamente. nodolista *aux = E_Lista; while ( E_Lista!= NULL ) aux = E_Lista; E_Lista = E_Lista->suce; //delete aux->datos;// Libera el puntero al que apunta el dato. delete aux; // Libera el nodo. num_elementos--; // Decrementa el número de elementos. Página 26
28 Otros tipos de listas Listas circulares Listas doblemente enlazadas Listas circulares doblemente enlazadas Listas circulares.- El sucesor del último elemento será el primer elemento. LC void ListaCircular::InsLista (tipodatos x) // Suponiendo que tenemos el objeto ListaCircular struct nodol *p; p = new nodol; p->dato = x; if (ListaVacia()) p->suce = p; E_lista = p; else p->suce = E_lista->suce; E_lista->suce = p; // Obviamente se complica si queremos que la lista esté ordenada En la eliminación de elementos hay que tener en cuenta: - Si la lista tiene un único elemento. - Si la componente que se va a eliminar es la indicada por la variable externa o es otra cualquiera. Página 27
29 Recorrido de una lista circular p = LC; if (! LC.VaciaLista ()) do p = p->suce; << tratar los datos de la componente p->info >> while (p!= LC); Listas doblemente enlazadas.- En la inserción: - Por el principio? - Por el final? - Quiero que esté ordenada la lista? En la eliminación de elementos hay que tener en cuenta: - Si queda un único elemento - Se trata de eliminar el primer elemento - Se trata de eliminar el último elemento - Se elimina un elemento intermedio Listas circulares doblemente enlazadas.- Página 28
30 Lista con punto de interés TAD ListaPI es Crear, Vacía, Inicio, Avanza, Fin, Insertar, Consultar, Borrar Operaciones Crear retorna ListaPI efecto Devuelve una LPI vacía Vacía (L:ListaPI) retorna Boolean efecto Devuelve True si la LPI está vacía y False en caso contrario. Inicio (L:ListaPI) modifica L efecto Modifica la LPI de manera que el punto de interés queda apuntando al primer elemento de la lista. Si la lista está vacía, el PI apuntará a NIL. Avanza(L:ListaPI) modifica efecto Fin (L:ListaPI) retorna Boolean efecto Insertar (L:ListaPI; D: TipoDato) modifica L efecto Consultar(L:ListaPI) retorna efecto Borrar (L:ListaPI)modifica efecto L Modifica la LPI de manera que el punto de interés queda apuntando al siguiente elemento al que apuntaba. Si estuviera apuntando al último antes de ejecutar esta operación, acabará apuntando a NIL. Devuelve True si el punto de interés está apuntando a NIL (es decir, si ha llegado al final de la LPI) y False en caso contrario (es decir, si apunta a un elemento de la lista). Inserta D en la LPI, a continuación del nodo al que apunta el punto de interés. Después de la inserción, el PI queda apuntando al nuevo elemento. Si la lista está vacía, el nuevo nodo se inserta. Si el PI está apuntando a NIL pero la lista no está vacía, esta operación no hace nada. TipoDato Devuelve el dato al que apunta el punto de interés. Si PI apunta a NIL, no hace nada. L Elimina el nodo al que apunta el punto de interés. (Se podría añadir una operación para retroceder el punto de interés.) Página 29
31 Especificación algebraica de la Lista con punto de interés TAD ListaPI TIPO: ListaPI (Elemento) SINTAXIS: crear ( ) ListaPI insertar (ListaPI, Elemento) ListaPI borrar (ListaPI) ListaPI inicio (ListaPI) ListaPI avanza (ListaPI) ListaPI consultar (ListaPI) Elemento fin (ListaPI) Boolean vacía (ListaPI) Boolean Privada: <_, _>: (Pila,Pila) ListaPI SEMÁNTICA: crear p, p 1, p 2 Pila; v Elemento <Pila.crear, Pila.crear> insertar (<p 1, p 2 >, v) <Pila.apilar(p 1, v), p 2 > borrar (<p 1, Pila.crear>) Error borrar (<p 1, Pila.apilar(p 2, v)>) <p 1, p 2 > inicio (<p 1, p 2 >) <Pila.crear, concatenar(p 1, p 2 )> avanza (<p 1, Pila.crear>) Error avanza (<p 1, Pila.apilar(p 2, v)>) <Pila.apilar(p 1, v), p 2 > consultar (<p 1, Pila.crear>) Error consultar (<p 1, Pila.apilar(p 2, v)>) v fin (<p 1, p 2 >) Pila.vacía(p 2 ) vacía(<p 1, p 2 >) Pila.vacía(p 2 ) Pila.vacía(p 2 ) Ejercicios: Especificar la concatenación de pilar; posibles implementaciones; recorrido de una lista con punto de interés; búsqueda de un elemento en una lista con punto de interés Página 30
Tema 8. Listas. José M. Badía, Begoña Martínez, Antonio Morales y José M. Sanchiz
Tema 8. Listas http://aulavirtual.uji.es José M. Badía, Begoña Martínez, Antonio Morales y José M. Sanchiz {badia, bmartine, morales, sanchiz}@icc.uji.es Estructuras de datos y de la información Universitat
Más detallesIngeniera de Sistemas: Luz Esperanza Espitia Tutora de Estructura de datos.
Ingeniera de Sistemas: Luz Esperanza Espitia Tutora de Estructura de datos. Con relación a la Estructura LISTA Indicar objetos reales que se puedan modelar con dicha estructura. Listas de Ordenes de visitas
Más detallesSolución práctico 6 Tipos Abstractos de Datos Lista, Pila y Cola
Objetivos Trabajar sobre el Tipo Abstracto de Datos Lista, reforzando el desacople entre especificación e implementación. Retomar las implementaciones vistas, como ser Listas Doblemente Encadenadas, Listas
Más detallesAlgoritmos y Estructuras de Datos Pilas LIFO y Colas FIFO. Guillermo Román Díez
Algoritmos y Estructuras de Datos Pilas LIFO y Colas FIFO Guillermo Román Díez groman@fi.upm.es Universidad Politécnica de Madrid Curso 2015-2016 Guillermo Román, UPM AED: Pilas LIFO y Colas FIFO 1/12
Más detallesProgramación TADs Lineales Lista Pila Cola
Programación 2 7- TADs Lineales Lista Pila Cola 1 TAD LISTA 2 Definición Hemos visto la definición inductiva de listas. Más precisamente, definimos inductivamente los tipos Alista, para cualquier tipo
Más detallesUNIVERSIDAD AUTONOMA DE MADRID ESCUELA POLITÉCNICA SUPERIOR ESTRUCTURAS DE DATOS Y ALGORITMOS
UNIVERSIDAD AUTONOMA DE MADRID ESCUELA POLITÉCNICA SUPERIOR ESTRUCTURAS DE DATOS Y ALGORITMOS Curso 2008-09 Examen parcial APELLIDOS: NOMBRE: 1. (0.5 puntos) Enumera las características de un algoritmo
Más detallesTema 6. Gestión dinámica de memoria
Tema 6. Gestión dinámica de memoria http://aulavirtual.uji.es José M. Badía, Begoña Martínez, Antonio Morales y José M. Sanchiz {badia, bmartine, morales, sanchiz@icc.uji.es Estructuras de datos y de la
Más detallesPILAS. Prof. Ing. M.Sc. Fulbia Torres
S ESTRUCTURAS DE DATOS 2006 Prof. UNIDAD II ESTRUCTURAS DE DATOS PILAS Definición. Operaciones. Implementación secuencial. Aplicaciones. Ejemplos. Ejercicios. DEFINICIÓN Una PILA (o stack) es una estructura
Más detallesProgramación de sistemas Pilas y Colas
Programación de sistemas Pilas y Colas Departamento de Ingeniería Telemática 1 Contenidos Pilas (stacks) Colas (queues) Colas dobles (deques double-ended queues) 2 Pilas Estructura de datos lineal Inserción
Más detallesLISTAS. Prof. Ing. M.Sc. Fulbia Torres
LISTAS ESTRUCTURAS DE DATOS 2006 Prof. UNIDAD II ESTRUCTURAS DE DATOS LISTAS Definición. Representación de Listas. Lista Lineal Simplemente Enlazada. Operaciones TAD LLSE. Implementación Dinámica. Otras
Más detallesImplementación de las Clases Pila, Cola, Lista y Arbol
1/1 Implementación de las Clases Pila, Cola, Lista y Arbol Josefina Sierra Santibáñez 28 de noviembre de 2017 2/1 Implementación de Estructuras de Datos Implementaremos cada estructura de datos en dos
Más detallesSegundo Parcial de Programación 2 7 de junio de 2017
Instituto de Computación. Facultad de Ingeniería. Universidad de la República Segundo Parcial de Programación 2 7 de junio de 2017 Problema 1 (30 puntos) Considere un TAD T que permita almacenar a lo sumo
Más detallesProfesor: José Miguel Rubio L.
Profesor: José Miguel Rubio L. Magíster en Ingeniería Informática Ingeniero Civil en Informática Licenciado en Ciencias de la Ingeniería Técnico en Programación Oficina: 3-20 e-mail 1: jose.rubio.l@ucv.cl
Más detallesUNIDAD 8 Tipos de datos dinámicos: Punteros Asignación dinámica de memoria. Uso de punteros. Inicialización y asignación de punteros.
Tipos de datos dinámicos: Punteros Asignación dinámica de memoria. Uso de punteros. Inicialización y asignación de punteros. Procedimientos para asignación y liberación de memoria. Tipos de datos recursivos.
Más detallesPILAS Fundamentos
Alg. y Estr. Datos-I / Fund. Progr.-II (R. Ferrís, J. Albert) 11 PILAS 11.1 Fundamentos En este tema y en el siguiente se analizarán las estructuras de datos lineales pilas y colas. Las pilas y las colas
Más detallesUNIDAD 8 Tipos de datos dinámicos: Punteros Asignación dinámica de memoria. Uso de punteros. Inicialización y asignación de punteros.
Tipos de datos dinámicos: Punteros Asignación dinámica de memoria. Uso de punteros. Inicialización y asignación de punteros. Procedimientos para asignación y liberación de memoria. Tipos de datos recursivos.
Más detallesTema 7- Modelo y Aplicación de Pila, Cola y. Tema 7- Modelo y Aplicación de. Lista Con Punto de Interés
Tema - Modelo y Aplicación de Pila, Cola y Lista con Punto de Interés Tema - Modelo y Aplicación de Pila, Cola y Lista con Punto de Interés Índice general:. Modelo y Aplicación de Lista con Punto de Interés
Más detallesProgramación de sistemas Listas enlazadas
Programación de sistemas Listas enlazadas Departamento de Ingeniería Telemática 1 Contenidos *** Introducción a los genéricos Estructuras de datos Listas enlazadas La clase Node La clase LinkedList Ventajas
Más detallesTipos Recursivos de Datos
1/1 Tipos Recursivos de Datos Josefina Sierra Santibáñez 27 de noviembre de 2016 2/1 Introducción La recursividad no sólo se puede aplicar a la definición de procedimientos (i.e. funciones o acciones),
Más detalles4. Pilas ESTRUCTURAS DE DATOS 1
4. Pilas Una Pila es una colección de elementos homogéneos dispuestos en orden tal que se recuperan en orden inverso a como se introdujeron. La extracción e inserción de elementos en la Pila se realiza
Más detallesESTRUCTURAS DINÁMICAS DE DATOS (PILAS)
200 UNAN LEON Departamento de Computación Ingeniería en Sistema y Telemática Docente: Ing. Juan Carlos Antón S. Asignatura: Algoritmo y Estructuras de Datos ESTRUCTURAS DINÁMICAS DE DATOS (PILAS) Pilas
Más detalles11. PILAS Introducción Fundamentos
11. PILAS 11.0 INTRODUCCIÓN... 31 11.1 FUNDAMENTOS... 31 11.2. REPRESENTACIÓN DE LAS PILAS EN C++... 32 Implementación mediante estructuras estáticas... 36 Implementación mediante estructuras dinámicas...
Más detallesEstructuras de datos en memoria principal
Estructuras de datos Estructuras de datos en memoria principal Franco Guidi Polanco Escuela de Ingeniería Industrial Pontificia Universidad Católica de Valparaíso, Chile fguidi@ucv.cl Actualización: 11
Más detallesEstructura de datos y de la información Boletín de problemas - Tema 10
Estructura de datos y de la información Boletín de problemas - Tema 10 1. En el caso de que sea posible, dar un ejemplo de los siguientes puntos. Si no, explicar por qué no lo es. Considerar un valor genérico
Más detallesESTRUCTURAS DINÁMICAS DE DATOS (PILAS) EN C
2013 ESTRUCTURAS DINÁMICAS DE DATOS (PILAS) EN C Departamento de Computación UNAN-León TEMA 4: ESTRUCTURAS DINÁMICAS DE DATOS (PILAS) 4.1 INTRODUCCIÓN: En términos de listas lineales, una pila puede ser
Más detallesProgramación de sistemas
Programación de sistemas Pilas y Colas Julio Villena Román MATERIALES BASADOS EN EL TRABAJO DE DIFERENTES AUTORES: Carlos Delgado Kloos, Jesús Arias Fisteus, Carlos Alario Hoyos 1
Más detallesEste material es de uso exclusivo para estudio, los textos fueron tomados textualmente de varios libros por lo que está prohibida su impresión y
Este material es de uso exclusivo para estudio, los textos fueron tomados textualmente de varios libros por lo que está prohibida su impresión y distribución. Listas Enlazadas Estructuras de datos dinámicas
Más detallesColas. Carlos Delgado Kloos Dep. Ingeniería Telemática Univ. Carlos III de Madrid. Java: Colas / 1
Colas Carlos Delgado Kloos Dep. Ingeniería Telemática Univ. Carlos III de Madrid cdk@it.uc3m.es Java: Colas / 1 Ejemplo La cola del autobús La cola de la impresora cdk@it.uc3m.es Java: Colas / 2 Características
Más detallesEstructuras de datos en memoria principal
Estructuras de datos en memoria principal Franco Guidi Polanco Escuela de Ingeniería Industrial Pontificia Universidad Católica de Valparaíso, Chile fguidi@ucv.cl Estructuras de datos v Estructuras básicas
Más detallesEstructuras Dinámicas de datos.
Estructuras Dinámicas de datos. Las estructuras dinámicas de datos son estructuras que crecen a medida que ejecuta un programa. Una estructura dinámica de datos es una colección de elementos llamadas nodos
Más detalles11. PILAS Introducción Fundamentos
11. PILAS 11.0 INTRODUCCIÓN... 25 11.1 FUNDAMENTOS... 25 11.2. REPRESENTACIÓN DE LAS PILAS EN C++... 26 Implementación mediante estructuras estáticas... 31 Implementación mediante cursores... 35 Implementación
Más detallesCapitulo V Listas Enlazadas
Capitulo V Listas Enlazadas Muere lentamente, quien abandona un proyecto antes de iniciarlo, no preguntando de un asunto que desconoce o no respondiendo cuando le indagan sobre algo que sabe. Evitemos
Más detallesListas enlazadas. Programación de Sistemas
Listas enlazadas Programación de Sistemas 1 Estructuras de datos Abstracción que representa un conjunto de datos en un programa con el objeto de facilitar su manipulación Diferentes estructuras de datos
Más detallesPilas y Colas. Cursos Propedéuticos Dr. René Cumplido M. en C. Luis Rodríguez Flores
Pilas y Colas Cursos Propedéuticos 2015 Dr. René Cumplido M. en C. Luis Rodríguez Flores Contenido de la sección Pilas Estructura Operaciones Ejemplos de aplicación Implementación Colas Definición Operaciones
Más detalles12. COLAS Introducción Fundamentos
Ricardo Ferrís Castell Algoritmos y Estructuras de Datos I 12. COLAS 12.0 INTRODUCCIÓN...41 12.1 FUNDAMENTOS...41 12.2. REPRESENTACIÓN DE LAS COLAS EN C++...42 Implementación mediante estructuras estáticas:
Más detallesTAD Lineales: Pila, Cola y Lista
TAD Lineales: Pila, Cola y Lista Objetivos Conocer los TAD lineales, su funcionamiento y aplicaciones Conocer la especificación de cada uno de ellos Saber realizar implementaciones alternativas Saber usar
Más detallesEstructura de Datos. Árboles Binarios de Búsqueda ABB. Primer Semestre, 2010
Estructura de Datos Árboles Binarios de Búsqueda ABB Prof.: Mauricio Solar Prof.: Lorna Figueroa Primer Semestre, 20 1 Arboles de Búsqueda Binaria El árbol binario de búsqueda (ABB) toma su nombre del
Más detallesLas FILAS. ING PEDRO BELTRÁN CANESSA Estructuras de Datos 1
Las FILAS Estructuras de Datos 1 LA FILA (Conceptos...) Es un contenedor que utiliza el protocolo FIFO (First In, First Out) o bien, PEPS (Primeras Entradas, Primeras Salidas) Entrada Salida Estructuras
Más detallesEstructura de datos y algoritmos. Tema IV: TIPOS DE DATOS ABSTRACTOS DINÁMICOS LINEALES
Estructura de datos y algoritmos Tema IV: TIPOS DE DATOS ABSTRACTOS DINÁMICOS LINEALES TIPOS DE DATOS ABSTRACTOS DINÁMICOS LINEALES 4.1 Introducción 4.2 Ejemplos de TDA dinámicos lineales 4.3 Pilas 4.3.1
Más detallesUNIDAD 2. ESTRUCTURAS DE DATOS SECUENCIALES. 1. Pilas (Stacks)
UNIDAD 2. ESTRUCTURAS DE DATOS SECUENCIALES 1. Pilas (Stacks) Una pila es una coleccion de elementos en la que sólo se pueden insertar y eliminar datos por uno de los extremos de la lista. Al igual que
Más detallesTAD: Pila. TALLER: TAD Pila
TALLER: TAD Una pila (stack) es un conjunto de elementos del mismo tipo que solamente puede crecer o decrecer por uno de sus extremos. Una pila también se la conoce con el nombre de estructura de tipo
Más detallesEstructura de Datos. Listas Enlazadas
Estructura de Datos Listas Enlazadas Conceptos de Lista enlazada Una lista enlazada es una secuencia de nodos que se interconectan mediante sus campos de enlace. Nodo: un objeto creado desde una clase
Más detalles1.2.4 Listas enlazadas
1.2.4 Listas enlazadas Las listas enlazadas son tipos de datos dinámicos que se construyen con nodos. Un nodo es un registro con al menos, dos campos, uno de ellos contiene las componentes y se le denomina
Más detallesEstructura de Datos. Unidad de Aprendizaje: Unidad de Competencia II: Estructuras de Datos Lineales. M. en C. Edith Cristina Herrera Luna
Ingeniería en Computación Unidad de Aprendizaje: Estructura de Datos Unidad de Competencia II: Estructuras de Datos Lineales Marzo 2015 M. en C. Edith Cristina Herrera Luna ESTRUCTURAS DE DATOS Propósito
Más detallesTema 5. Estructura de datos Pila
Tema 5. Estructura de datos Pila http://aulavirtual.uji.es José M. Badía, Begoña Martínez, Antonio Morales y José M. Sanchiz {badia, bmartine, morales, sanchiz}@icc.uji.es Estructuras de datos y de la
Más detallesIMPLEMENTACIÓN DE PILAS CON LISTAS EN C++
IMPLEMENTACIÓN DE PILAS CON LISTAS EN C++ Fichero nodo.h #ifndef NODO_H #define NODO_H const int cantidad_nodos = 10; class Nodo private: string dato; Nodo* siguiente; public: Nodo(); void setdato(string
Más detallesAPUNTADORES. Un apuntador es un objeto que apunta a otro objeto. Es decir, una variable cuyo valor es la dirección de memoria de otra variable.
APUNTADORES Un apuntador es un objeto que apunta a otro objeto. Es decir, una variable cuyo valor es la dirección de memoria de otra variable. No hay que confundir una dirección de memoria con el contenido
Más detallesUniversidad Autónoma del Estado de México 2016, Año del 60 Aniversario de la Universidad Autónoma del Estado de México
Universidad Autónoma del Estado de México 2016, Año del 60 Aniversario de la Universidad Autónoma del Estado de México Unidad Académica Profesional Tianguistenco Ingeniería de Software Estructura de Datos
Más detallesMemoria en C++ Punteros - Referencias Clases Y ahora, a trabajar! Memoria Dinámica en C++
Qué es una variable? Variables Memoria Matemática: una etiqueta que representa a un valor en una expresión: f (y) = y 2 + 2y Programación: Nombre simbólico dado a un valor residente en la memoria. Propiedades
Más detallesEstructura de datos Colas
Estructura de Datos Estructura de datos Colas Temario Unidad II 2.1 Definición y operaciones 2.2 Implementación estática 2.3 Implementación dinámica 2.4 Colas de prioridad 2.5 Casos de estudio 1 Definición
Más detallesCapítulo. Listas, pilas y colas en C. Contenido. Introducción
Capítulo 32 Listas, pilas y colas en C Contenido Listas enlazadas Clasificación de listas enlazadas Operaciones en listas enlazadas Inserción de un elemento en una lista Búsqueda de un elemento de una
Más detallesHoja de ejercicios del Tema 9
Facultad de Informática Universidad Complutense Fundamentos de la programación Curso 2013 2014 Hoja de ejercicios del Tema 9 1. Sin ejecutarlo, qué mostraría el siguiente código? int x = 5, y = 12, z;
Más detallesDepartamento de Informática Universidad de Valladolid Campus de Segovia TEMA 3: ESTRUCTURAS DINÁMICAS LINEALES. LISTAS ENLAZADAS, PILAS Y COLAS
Departamento de Informática Universidad de Valladolid Campus de Segovia TEMA 3: ESTRUCTURAS DINÁMICAS LINEALES. LISTAS ENLAZADAS, PILAS Y COLAS ÍNDICE Listas enlazadas Pilas Colas DEFINICIÓN DEL TIPO LISTA
Más detallesEstructuras Enlazadas AyED UTN-BA
Funciones para estructuras enlazadas Sin Plantilla El Nodo Con plantilla para un dato genérico en info El Nodo struct Nodo1 int info; Nodo* sig; ; Nodo1* p1 = new Nodo1(); struct Nodo2 string info; Nodo*
Más detallesTema 02: TAD Pila. M. en C. Edgardo Adrián Franco Martínez edgardoadrianfrancom
Tema 02: TAD Pila M. en C. Edgardo Adrián Franco Martínez http://www.eafranco.com edfrancom@ipn.mx @edfrancom edgardoadrianfrancom Estructuras de datos (Prof. Edgardo A. Franco) 1 Contenido Descripción
Más detalles6. El TDA Lista Implementación con listas enlazadas. es de tipo genérico T. Pueden existir elementos repetidos (a diferencia de los conjuntos).
6. El TDA Lista 6.1. Definición 6.2. Operaciones del TDA 6.3. Implementación con vectores 6.4. Implementación con listas enlazadas 6.5. Comparativa Bibliografía: -Weiss - Aho, Hopcroft y Ullman 6.1. Definición
Más detalles(1) Recordemos qué es una pila...
(1) Recordemos qué es una pila... TAD Pila(α) observadores básicos vacía? : pila(α) bool tope : pila(α) p α desapilar : pila(α) p pila(α) generadores vacía : pila(α) apilar : α pila(α) pila(α) otras operaciones
Más detallesClases y Objetos en C++
Informática II Clases y Objetos en C++ Introducción Las variables de los tipos fundamentales de datos no son suficientes para modelar adecuadamente objetos del mundo real. alto, ancho y longitud para representar
Más detallesA l g o r i t m o y E s t r u c t u r a d e D a t o s Ing. en Sistemas de Información - 1º año -
Trabajo práctico Nº 7 (Resolución de problemas Estructura: pila y cola). Realiza el programa de cada situación problemática. 1- Cargar en una pila n letras del abecedario.(n debe ser menor a 30) 2- En
Más detallesESTRUCTURA DE DATOS Y ALGORITMOS Titulación: Ingeniero Técnico en Informática de Gestión Curso: 2º Nombre y apellidos: Nota:
Nombre y apellidos: Nota: 1. Ejercicio (3 puntos) a) Qué estructura de datos utilizarías para transformar la siguiente expresión a su equivalente expresión postfija? Argumenta tu decisión. Ej. entrada:
Más detallesEstructuras de Datos y Algoritmos. Contenido
Estructuras de Datos y Algoritmos Listas, Pilas y Colas Contenido Listas Tipos abstractos de datos (ADTs( ADTs) El ADT lista Implementación n usando arreglos Listas encadenadas Aplicaciones Implementación
Más detallesDEFINICION. Ing. M.Sc. Fulbia Torres Asignatura: Estructuras de Datos Barquisimeto 2006
ARBOLES ESTRUCTURAS DE DATOS 2006 DEFINICION Un árbol (tree) es un conjunto finito de nodos. Es una estructura jerárquica aplicable sobre una colección de elementos u objetos llamados nodos; uno de los
Más detallesPilas, Colas. Andrea Rueda. Estructuras de Datos. Pontificia Universidad Javeriana Departamento de Ingeniería de Sistemas
Pilas, Colas Estructuras de Datos Andrea Rueda Pontificia Universidad Javeriana Departamento de Ingeniería de Sistemas Quiz: STL Quiz: STL Standard Template Library (STL) std::vector - Arreglo dinámico,
Más detallesTema: Tipos Abstractos de Datos (TAD s) en C++.
Programación II. Guía 12 1 Facultad: Ingeniería Escuela: Computación Asignatura: Programación II Tema: Tipos Abstractos de Datos (TAD s) en C++. Objetivos Específicos Explicar el concepto "Tipo Abstracto
Más detallesTEMA 3. Árboles. Objetivos. Contenidos. Bibliografía. Básica
TEMA 3. Árboles Objetivos En este tema se estudia una de las estructuras de datos no lineal más importante en computación, el árbol. Comenzaremos introduciendo la terminología asociada a los árboles y
Más detallesTema 8- Implementación de Pila, Cola y. Tema 8- Implementación de Pila, Cola y Lista con Punto de Interés. Representación Eficaz de una EDA
Tema 8- Implementación de Pila, Cola y Lista con Punto de Interés Tema 8- Implementación de Pila, Cola y Lista con Punto de Interés Índice general: 1. Representación Eficaz de una EDA Lineal 2. Implementación
Más detallesLISTAS ENLAZADAS FUNDAMENTOS TEORICOS
LISTAS ENLAZADAS FUNDAMENTOS TEORICOS Una lista enlazada es una colección o secuencia de elementos dispuestos uno detrás de otro, en la que cada elemento se conecta al siguiente elemento por un «enlace»
Más detallesIntroducción: una simple colección
Introducción: una simple colección Implemente una clase denominada Lista. La clase deberá mantener una colección de números y proveer los siguientes i métodos: Listas dinámicas simplemente enlazadas Franco
Más detallesSegundo parcial de Programación 2
Generalidades: Segundo parcial de Programación 2 a. La prueba es individual y sin material. b. La duración es 3hs. c. Sólo se contestan dudas acerca de la letra. 8 de Julio de 2016 d. Escriba las hojas
Más detallesÁRBOL BINARIO. T der. Árbol binario homogéneo es aquel cuyos nodos tienen grado 0 ó 2(no hay ninguno de grado 1).
ÁRBOL BINARIO - Un árbol binario puede definirse como un árbol que en cada nodo puede tener como mucho grado 2, es decir, a lo más 2 hijos. Los hijos suelen denominarse hijo a la izquierda e hijo a la
Más detalles3.3. Pilas 3.3. PILAS 3
3.3. PILAS 3 3.3. Pilas Una Pila es una estructura de datos lineal que sólo permite insertar, eliminar y consultar elementos en uno de sus extremos, que denominamos cima. Es, por tanto, una estructura
Más detallesProgramación de sistemas
Programación de sistemas Árboles Julio Villena Román MATERIALES CREADOS EN EL TRABAJO DE DIFERENTES AUTORES: Carlos Delgado Kloos, M.Carmen Fernández Panadero, Raquel M.Crespo García,
Más detallesTema 5. Tipos Abstractos de Datos
. E.U.Politécnica. I.T.Industrial (Electricidad) Tema 5. Tipos Abstractos de Datos. E.U. Politécnica Curso 2004-2005 Departamento Lenguajes y Ciencias de la Computación. Universidad de Málaga José Luis
Más detallesA l g o r i t m o y E s t r u c t u r a d e D a t o s Ing. en Sistemas de Información - 1º año -
Trabajo práctico Nº 7 (Resolución de problemas Estructura: pila y cola). Realiza el programa de cada situación problemática. 1- Cargar en una pila n letras del abecedario.(n debe ser menor a 30) 2- En
Más detallesEstructuras Dinámicas
Departamento de Lenguajes yciencias de la Computación 4 Estructuras Dinámicas Contenido 1. Gestión dinámica de memoria. 2. El tipo puntero. 3. Operaciones con punteros. 4. Operaciones básicas sobre listas
Más detallesImplementaciones de pilas, colas y afines. Memoria dinámica.
Implementaciones de pilas, colas y afines. Memoria dinámica. 1 1 Departamento de Computación, FCEyN, Universidad de Buenos Aires, Buenos Aires, Argentina Algoritmos y Estructuras de Datos II, segundo cuatrimestre
Más detallesEDA. Tema 8 Colas de Prioridad: Heaps
EDA. Tema 8 Colas de Prioridad: Heaps Natividad Prieto Sáez. DSIC EDA, T-8. Curso 02/03. N.Prieto p.1/55 Objetivos Estudio de las definiciones asociadas a las Colas de Prioridad: Especificación: operaciones
Más detallesProgramación Estructuras Arborescentes
Programación 2 4 - Estructuras Arborescentes 1 Definición La recursión puede ser utilizada para la definición de estructuras realmente sofisticadas. Una estructura árbol (árbol general o finitario) con
Más detallesEstructura de Datos. Pilas Colas. Primer Semestre, Indice. TDA: Pilas TDA: Colas Colas de Prioridad Anillos BiColas BiColas Circulares
Estructura de Datos Pilas Colas Prof.: Mauricio Solar Prof.: Lorna Figueroa Primer Semestre, 2010 Indice TDA: Pilas TDA: Colas Colas de Prioridad Anillos BiColas BiColas Circulares Pilas - Stack Una de
Más detallesExamen Teórico Convocatoria de Junio de 2012
Examen Teórico Convocatoria de Junio de 2012 Nombre: DNI: Titulación: 1. Sobre el control de errores en Java: a) El siguiente método contiene un error de compilación debido al uso de excepciones. Explica
Más detalles1. El Tipo Abstracto de Datos.
Tipo Abstracto de s TAD Pila y TAD Cola 1. El Tipo Abstracto de s. 2. Definición de un TAD Pila. 3. Operaciones sobre el TAD Pila. 4. Implementación dinámica del TAD Pila en C. 5. Definición de un TAD
Más detallesUnidad Nº V Listas Enlazadas
Instituto Universitario Politécnico Santiago Mariño Unidad Nº V Listas Enlazadas Lista Enlazadas Es una colección o secuencia de elementos dispuestos uno detrás de otro, en la que cada elemento se conecta
Más detallesClase adicional 9. Listas enlazadas. Temas. Listas enlazadas Árboles Problemas de la clase adicional Ejercicios de diseño
Clase adicional 9 Temas Listas enlazadas Árboles Problemas de la clase adicional Ejercicios de diseño Listas enlazadas Previamente en este curso, ya habrá trabajado con dos de las estructuras de datos
Más detallesUno de los conceptos más útiles en ciencias de la computación es la pila.
23. PILA. (Stack). Tipos de Datos Abstractos. 23.1 Conceptos. Uno de los conceptos más útiles en ciencias de la computación es la pila. Una pila es una colección ordenada de elementos de igual tipo, en
Más detallesEstructura de datos Tema 3: El TAD Lista lineal. Universidad de Valladolid. Departamento de informática. Campus de Segovia
Universidad de Valladolid Departamento de informática Campus de Segovia Estructura de datos Tema 3: El TAD Lista lineal Prof. Montserrat Serrano Montero ÍNDICE El TAD lista lineal Implementación con estructuras
Más detallesAlgoritmos y Estructuras de Datos Iteradores. Guillermo Román Díez
Algoritmos y Estructuras de Datos Iteradores Guillermo Román Díez groman@fi.upm.es Universidad Politécnica de Madrid Curso 2015-2016 Guillermo Román, UPM AED: Introducción 1/26 Iteradores Es muy común
Más detallesCapítulo. Listas, pilas y colas en C++ Contenido. Introducción
Capítulo 34 Listas, pilas y colas en C++ Contenido Tipo abstracto de datos lista Operaciones de listas enlazadas, clase lista Inserción en una lista Buscar un elemento y recorrer una lista enlazada Borrado
Más detallesContenido PARTE II: ESTRUCTURAS DE DATOS AVANZADAS
Contenido PARTE II: ESTRUCTURAS DE DATOS AVANZADAS TEMA 4. - La Estructura de datos Árbol 4.1. Árboles, definiciones 4.2 Árboles binarios y su representación 4.3 Operaciones básicas de un árbol binario
Más detallesTema 3. Estructura de datos lineales. J.T.P. Maria Eugenia Valesani - Programacion 1 - Fa.Ce.Na.
Tema Estructura de datos lineales . Introducción Las estructuras de datos dinámicas son una colección de elementos (también llamados nodos) que normalmente son registros con la particularidad que crecen
Más detallesEstructuras de Datos y Algoritmos TDA LISTA
Estructuras de Datos y Algoritmos TDA LISTA Metáfora del TDA (repaso) Conjunto de operaciones forman una pared forman una interfase entre los programas y la estructura de datos Diseño de una Clase (repaso)
Más detallesEjercicio 2 Considere la representación para Lista de Naturales y Árbol Binario de Naturales de la Figura 1.
Ejercicios Resueltos del Práctico 4 Ejercicio 2 Considere la representación para Lista de Naturales y Árbol Binario de Naturales de la Figura 1. 1 2 struct NodoLista { 3 int elem ; 4 NodoLista * sig ;
Más detallesTIPO DE DATO ABSTRACTO (TDA)
TIPO DE DATO ABSTRACTO (TDA) Ing. Eduard Antonio Lozano Córdoba Nota: Toda la información fue copiada de: Libros físicos e Internet Actividad Extra Clases #include #include int binario(int
Más detallesEstructuras de Datos Avanzadas Contenido del Tema
T E M A 5 Estructuras de Datos Avanzadas Contenido del Tema 5.1. Introducción 5.2. Pilas 5.3. Colas 5.4. Listas 5.5. Arboles Binarios Arboles Binarios de Búsqueda Programación Modular Introducción Objetivos
Más detallesPUBLICACIÓN DEL ENUNCIADO: Semana del 10 de noviembre de ENTREGA: Clase de laboratorio de la semana del 8 de diciembre de 2003.
TELECOMUNICACIÓN Página 12 PRÁCTICAS 6ª, 7ª y 8ª: Operaciones con polinomios. OBJETIVOS: Repaso de listas dinámicas. Objetos como datos miembro de otros objetos (introducción a la herencia). Objetos con
Más detallesUn elemento de cualquier clase llamada Info; Un puntero a un nuevo nodo llamado sig; De tal forma una unión de nodos hace que tengamos una lista:
Tipos Abstractos de Datos: TAD Lista en educación Profesional 1.- Introducción Los tipos abstractos de datos son fundamentales para la informática puesto que de ellos se sirven todos los programas para
Más detallesProgramación Introducción al Diseño de Tipos Abstractos de Datos
Programación 2 11- Introducción al Diseño de Tipos Abstractos de Datos 1 Sobre TADs Especificación TAD Imp. 1 Imp. m Aplicaciones void P1( ){ } void Pn( ){ } void P1( ){ } void Pn( ){ } 2 Algunas preguntas
Más detallesLISTAS, PILAS Y COLAS
1 LISTAS, PILAS Y COLAS Muchos algoritmos requieren una representación apropiada de los datos para lograr ser eficientes Esta representación junto con las operaciones permitidas se llama Estructura de
Más detallesEstructuras de datos y algoritmos
Estructuras de datos y algoritmos 1. Introducción 2. Estructuras de datos lineales 3. Estructuras de datos jerárquicas 4. Grafos y caminos 5. Implementación de listas, colas, y pilas 6. Implementación
Más detallesEJERCICIO 2 (3 PUNTOS) A) Sea el árbol binario AVL de la figura siguiente: B) Dada la estructura de la figura siguiente:
ASIGNATURA TITULACIÓN APELLIDOS ESTRUCTURA DE DATOS Y DE LA INFORMACIÓN EJERCICIO 1 (3 PUNTOS) GRUPO CURSO CONVOCATORIA NOMBRE 23 / 24 EXTRAORDINARIA- SEPTIEMBRE CALIFICACIÓN Dado el tipo abstracto de
Más detallesTEMA 8: Gestión dinámica de memoria
TEMA 8: Gestión dinámica de memoria 8.1.-Tipo de datos puntero Hasta ahora, los tipos de datos que hemos visto (a excepción de strings y ficheros) eran estructuras de datos estáticas, es decir, estructuras
Más detalles