Vectores Universidad de Puerto Rico en Humacao

Vectores Universidad de Puerto Rico en Humacao
Departamento de Matemáticas COMP4097: Estructuras de Datos y Algoritmos Vectores José O. Sotero Esteva 23 de febrero de 2015 Esta obra está bajo una Licencia Creative Commons Atribución-Compartir Igual 4.0 Internacional.

Parte del contenido está basado en
Goodrich, Tamassia, Mount, Data Structures and Algorthms, 2nd Ed. Capitulo 4 (El material se cita aquí bajo la cláusula de uso justo de las leyes de copyright. El material de ese libro está sujeto a las restricciones de reproducción que ha establecido el editor.)

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)

Tipo de dato abstracto Lista

Ejemplo ¿Qué es una Lista? 1. ARENAS HERNANDEZ, DORCI LEE
2. CASANOVA DEL MORAL, AIDA Y. 3. COLON APONTE, MIGUEL A 4. GAMBOA NIEVES, EXEL 5. HERNANDEZ VIERA, JUAN 6. JAIME VELAZQUEZ, ASTRID M 7. MEDINA LOPEZ, MARIA M 8. MUNOZ ALICEA, LUIS A 9. NAVARRO LOPEZ, LISA R 10. PASSAPERA SANCHEZ, LIANETTE 11. QUILES RIVERA, MARIAN 12. REYES COLON, JUAN C 13. REYES TORRES, JENNY 14. ROSADO MILLAN, ARELIS 15. SANTIAGO VELEZ, JOSE L 16. TORRES COLLAZO, ALEXIS

Abstracción Lista Tiene una cantidad finita de elementos
Tiene un primer elemento tiene un último elemento cada elemento tiene una posición cada elemento tiene un sucesor (excepto el último) cada elemento tiene un predecesor (excepto el primero)

Abstracción Posición ¡La posición no tiene que ser un número entero!
En abstracto, es un indicador de dónde está el elemento en la lista. Si tenemos la posición, podemos acceder al elemento en esa posición.

TDA Posición Un tipo asociado a un tipo de contenedor que implanta la operación: element(): drvuelve referencia al elemento en esa posición. Asociado en C++ con el mecanismo iterador que responde a los siguiente mensajes: begin(), end(), next(), prev(). Todos devuelven una posición y para acceder al elemento en esa posición se usa el operador *. next() y prev() son sinónimos de operadores ++ y –-.

TDA Lista Colección de objetos que provee las siguientes operaciones (recuerde que una posición NO es un número entero): begin() : devuelve posición del primer elemento end(): devuelve posición del último elemento insertFront(e): inserta elemento e al comienzo insertBackt(e): inserta elemento e al final insert(i,e): insertar e en la posición i eraseFront(): elimina primer elmento eraseBack(): elimina último elmento erase(i): elimina elmento en la posición i Métodos accesorios: empty(): determina si estiba esta vacía size(): devuelve cantidad de elementos en la estiba

Ejemplo Lista

Implantación de Posición basada en listas ligadas dobles
class Node { Elem elem; //node element value Node* prev; //previous node in list Node* next; //next node in list }; // continúa ...

Implantación de Posición basada en listas ligadas dobles
class Iterator { // an iterator for the list public: Elem& operator * (); // reference to the element bool operator ==(const Iterator& p) const; // compare positions bool operator !=(const Iterator& p) const; Iterator& operator ++(); // move to next position Iterator& operator −−(); // move to previous position friend class NodeList; // give NodeList access private: Node* v; // pointer to the node Iterator(Node* u); // create from node }; // continúa ... // constructor from Node* NodeList::Iterator::Iterator(Node* u) { v = u; } // reference to the element Elem& NodeList::Iterator::operator*() { return v−>elem; } // compare positions bool NodeList::Iterator::operator==(const Iterator& p) const { return v == p.v; } bool NodeList::Iterator::operator!=(const Iterator& p) const { return v != p.v; } // move to next position NodeList::Iterator& NodeList::Iterator::operator++() { v = v−>next; return *this; } // move to previous position NodeList::Iterator& NodeList::Iterator::operator−−() { v = v−>prev; return *this; }

Implantación de Posición basada en listas ligadas circulares
class Iterator { // an iterator for the list public: Elem& operator * (); // reference to the element bool operator ==(const Iterator& p) const; // compare positions bool operator !=(const Iterator& p) const; Iterator& operator ++(); // move to next position Iterator& operator −−(); // move to previous position friend class NodeList; // give NodeList access private: Node* v; // pointer to the node Iterator(Node* u); // create from node }; // continúa ... // constructor from Node* NodeList::Iterator::Iterator(Node* u) { v = u; } // reference to the element Elem& NodeList::Iterator::operator*() { return v−>elem; } // compare positions bool NodeList::Iterator::operator==(const Iterator& p) const { return v == p.v; } bool NodeList::Iterator::operator!=(const Iterator& p) const { return v != p.v; } // move to next position NodeList::Iterator& NodeList::Iterator::operator++() { v = v−>next; return *this; } // move to previous position NodeList::Iterator& NodeList::Iterator::operator−−() { v = v−>prev; return *this; }

Implantación de Lista basada en listas ligadas dobles
typedef int Elem; class NodeList {// node-based list private: // insert Node declaration here. . . public: // insert Iterator declaration here. . . NodeList(); // default constructor int size() const; // list size bool empty() const; // is the list empty? Iterator begin() const; // beginning position Iterator end() const; // just beyond last position void insertFront(const Elem& e); // insert at front void insertBack(const Elem& e); // insert at rear void insert(const Iterator& p, // insert e before p const Elem& e); void eraseFront(); // remove first void eraseBack(); // remove last void erase(const Iterator& p); // remove p // housekeeping functions omitted. . . private: // data members int n; // number of items Node* header; // head-of-list sentinel Node* trailer; // tail-of-list sentinel }; NodeList::NodeList() { // constructor n = 0; // initially empty header = new Node; // create sentinels trailer = new Node; header−>next = trailer; // have them point to each other trailer−>prev = header; } int NodeList::size() const // list size { return n; } bool NodeList::empty() const // is the list empty? { return (n == 0); } // begin position is first item NodeList::Iterator NodeList::begin() const { return Iterator(header−>next); } // end position just beyond last NodeList::Iterator NodeList::end() const { return Iterator(trailer); }

typedef int Elem; class NodeList {// node-based list private: // insert Node declaration here. . . public: // insert Iterator declaration here. . . NodeList(); // default constructor int size() const; // list size bool empty() const; // is the list empty? Iterator begin() const; // beginning position Iterator end() const; // just beyond last position void insertFront(const Elem& e); // insert at front void insertBack(const Elem& e); // insert at rear void insert(const Iterator& p, // insert e before p const Elem& e); void eraseFront(); // remove first void eraseBack(); // remove last void erase(const Iterator& p); // remove p // housekeeping functions omitted. . . private: // data members int n; // number of items Node* header; // head-of-list sentinel Node* trailer; // tail-of-list sentinel }; NodeList::NodeList() { // constructor n = 0; // initially empty header = new Node; // create sentinels trailer = new Node; header−>next = trailer; // have them point to each other trailer−>prev = header; } int NodeList::size() const // list size { return n; } bool NodeList::empty() const // is the list empty? { return (n == 0); } // begin position is first item NodeList::Iterator NodeList::begin() const { return Iterator(header−>next); } // end position just beyond last NodeList::Iterator NodeList::end() const { return Iterator(trailer); } // CONTINÚA …......

typedef int Elem; class NodeList {// node-based list private: // insert Node declaration here. . . public: // insert Iterator declaration here. . . NodeList(); // default constructor int size() const; // list size bool empty() const; // is the list empty? Iterator begin() const; // beginning position Iterator end() const; // just beyond last position void insertFront(const Elem& e); // insert at front void insertBack(const Elem& e); // insert at rear void insert(const Iterator& p, // insert e before p const Elem& e); void eraseFront(); // remove first void eraseBack(); // remove last void erase(const Iterator& p); // remove p // housekeeping functions omitted. . . private: // data members int n; // number of items Node* header; // head-of-list sentinel Node* trailer; // tail-of-list sentinel }; void NodeList::insert(const NodeList::Iterator&p, //insert e before p const Elem& e) { Node* w = p.v; // p’s node Node* u = w−>prev; // p’s predecessor Node* v = new Node; // new node to insert v−>elem = e; v−>next = w; w−>prev = v; // link in v before w v−>prev = u; u−>next = v; // link in v after u n++; } void NodeList::insertFront(const Elem& e) // insert at front { insert(begin(), e); } void NodeList::insertBack(const Elem& e) // insert at rear { insert(end(), e); } // CONTINÚA

typedef int Elem; class NodeList {// node-based list private: // insert Node declaration here. . . public: // insert Iterator declaration here. . . NodeList(); // default constructor int size() const; // list size bool empty() const; // is the list empty? Iterator begin() const; // beginning position Iterator end() const; // just beyond last position void insertFront(const Elem& e); // insert at front void insertBack(const Elem& e); // insert at rear void insert(const Iterator& p, // insert e before p const Elem& e); void eraseFront(); // remove first void eraseBack(); // remove last void erase(const Iterator& p); // remove p // housekeeping functions omitted. . . private: // data members int n; // number of items Node* header; // head-of-list sentinel Node* trailer; // tail-of-list sentinel }; void NodeList::erase(const Iterator& p) { // remove p Node* v = p.v; // node to remove Node* w = v−>next; // successor Node* u = v−>prev; // predecessor u−>next = w; w−>prev = u; // unlink p delete v; // delete this node n−−; // one fewer element } void NodeList::eraseFront() // remove first { erase(begin()); } void NodeList::eraseBack() // remove last { erase(−−end()); }

Listas en STL Plantilla (template) list<class T>
Métodos (capacidad): empty(): determina si contenedor está vacío size(): devuelve cantidad de elementos (¡no es lo mismo que el tamaño) capacity(): devuelve cantidad de elementos que se pueden almacenar en el espacio actualmente reservado max_size(): devuelve la cantidad máxima de elementos que puede almacenar el contenedor

Listas en STL (cont) Métodos (modificadores): clear(): vacía la lista
insert(i, e), erase(i): igual que Vector push_back(e), pop_back(): añade / saca elemento del final push_front(e), pop_front(): añade / saca elemento del frente resize(n): cambia la cantidad de elementos. Si n < size() remueve los últimos size() - n elementos. Si n > size() añade elementos con valor por defecto. resize(n,v): igual que resize(n) pero si n > size() añade elementos con valor v. (otros)

Listas en STL (cont) Métodos (acceso a elementos):
front(): devuelve referencia al primer elemento back(): devuelve referencia al último elemento (mas ninguno)

¿Cómo busco el elemento en una posición determinada en una lista?

¿Cómo busco el elemento en una posición determinada en una lista?
En C++ posición = iterador

Comparación índice vs iterador
int vectorSum1(const vector<int>& V) { int sum = 0; for (int i = 0; i < V.size(); i++) sum += V[i]; return sum; } int vectorSum2(vector<int> V) { typedef vector<int>::iterator Iterator; // iterator type int sum = 0; for (Iterator p = V.begin(); p != V.end(); ++p) sum += *p; return sum; }

Comparación índice vs iterador
int vectorSum2(vector<int> V) { typedef vector<int>::iterator Iterator; // iterator type int sum = 0; for (Iterator p = V.begin(); p != V.end(); ++p) sum += *p; return sum; } int vectorSum3(const vector<int>& V) { typedef vector<int>::const iterator ConstIterator; int sum = 0; for (ConstIterator p = V.begin(); p != V.end(); ++p) sum += *p; return sum; }

Algoritmos

#include <cstdlib>// provides EXIT SUCCESS
#include <iostream>// I/O definitions #include <vector>provides vector #include <algorithm>for sort, random shuffle using namespace std;// make std:: accessible int main () { int a[ ] = {17, 12, 33, 15, 62, 45}; vector<int> v(a, a + 6);// v: cout << v.size() << endl;// outputs: 6 v.pop back();// v: cout << v.size() << endl;// outputs: 5 v.push back(19);// v: cout << v.front() << " " << v.back() << endl; // outputs: 17 19 sort(v.begin(), v.begin() + 4);// v: ( ) 62 19 v.erase(v.end() − 4, v.end() − 2);// v: cout << v.size() << endl;// outputs: 4 char b[ ] = {’b’, ’r’, ’a’, ’v’, ’o’}; vector<char> w(b, b + 5);// w: b r a v o random shuffle(w.begin(), w.end());// w: o v r a b w.insert(w.begin(), ’s’);// w: s o v r a b for (vector<char>::iterator p = w.begin(); p != w.end(); ++p) cout << *p << " ";// outputs: s o v r a b cout << endl; return EXIT SUCCESS; }

Vectores Universidad de Puerto Rico en Humacao

Presentaciones similares

Presentación del tema: "Vectores Universidad de Puerto Rico en Humacao"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

Vectores Universidad de Puerto Rico en Humacao

Presentaciones similares

Presentación del tema: "Vectores Universidad de Puerto Rico en Humacao"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback