elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Arreglado, de nuevo, el registro del warzone (wargame) de EHN


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Aporte C++ - Clases Pila y Cola.
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Aporte C++ - Clases Pila y Cola.  (Leído 2,026 veces)
xaps

Desconectado Desconectado

Mensajes: 157



Ver Perfil
Aporte C++ - Clases Pila y Cola.
« en: 21 Diciembre 2013, 17:52 pm »

He desarrollado una clase Pila y una Clase cola para estudiar de cara a la universidad y se me ha ocurrido publicarla aquí, ya que estoy viendo publicaciones en las que se hacen preguntas sobre la implementación de estas clases y podrían ayudar a más de uno. Si alguien encuentra algún error que lo comente, por favor.

Aquí los archivos:

Stack.h
Código
  1. #include <cstddef>
  2.  
  3. template <class T>
  4. class Stack
  5. {
  6.  private:
  7.    struct Node
  8.    {
  9.      Node* nextNode;
  10.      T data;
  11.    };
  12.  
  13.    Node* topNode = NULL;
  14.    int dataSize = 0;
  15.  
  16.    static Node* copyNode(Node* node)
  17.    {
  18.      Node* newNode = NULL;
  19.      if (node)
  20.      {
  21. newNode = new Node;
  22. newNode->data = node->data;
  23. newNode->nextNode = copy(node->nextNode);
  24.      }
  25.      return newNode;
  26.    }
  27.    static void deleteNode(Node* node)
  28.    {
  29.      if (node)
  30.      {
  31. deleteNode(node->nextNode);
  32. delete node;
  33.      }
  34.    }
  35.  
  36.  public:
  37.    Stack();
  38.    Stack(const Stack& original);
  39.    ~Stack();
  40.  
  41.    T top() const;
  42.    bool empty() const;
  43.    int size() const;
  44.  
  45.    void push(const T& data);
  46.    void pop();
  47.    void clear();
  48.  
  49.    Stack& operator =(const Stack& original);
  50. };
  51.  
  52. template <class T>
  53. Stack<T>::Stack() {}
  54.  
  55. template <class T>
  56. Stack<T>::Stack(const Stack &original)
  57. {
  58.  if (this != &original)
  59.  {
  60.    dataSize = original.dataSize;
  61.    topNode = copy(original.topNode);
  62.  }
  63. }
  64.  
  65. template <class T>
  66. Stack<T>::~Stack()
  67. {
  68.  deleteNode(this->topNode);
  69. }
  70.  
  71. template <class T>
  72. Stack<T>& Stack<T>::operator =(const Stack& original)
  73. {
  74.  if (this != &original)
  75.  {
  76.    dataSize = original.dataSize;
  77.    deleteNode(topNode);
  78.    topNode = copyNode(original.topNode);
  79.  }
  80.  return *this;
  81. }
  82.  
  83. template <class T>
  84. T Stack<T>::top() const
  85. {
  86.  return topNode->data;
  87. }
  88.  
  89. template <class T>
  90. void Stack<T>::push(const T& data)
  91. {
  92.  Node* newTop = new Node;
  93.  newTop->data = data;
  94.  newTop->nextNode = topNode;
  95.  topNode = newTop;
  96.  
  97.  dataSize = dataSize + 1;
  98. }
  99.  
  100. template <class T>
  101. void Stack<T>::pop()
  102. {  
  103.  Node* auxNode = topNode;
  104.  topNode = topNode->nextNode;
  105.  delete auxNode;
  106.  
  107.  dataSize = dataSize - 1;
  108. }
  109.  
  110. template <class T>
  111. bool Stack<T>::empty() const
  112. {
  113.  return (topNode == NULL);
  114. }
  115.  
  116. template <class T>
  117. int Stack<T>::size() const
  118. {
  119.  return dataSize;
  120. }
  121.  
  122. template <class T>
  123. void Stack<T>::clear()
  124. {
  125.  deleteNode(topNode);
  126.  topNode = NULL;
  127.  dataSize = 0;
  128. }

Queue.h
Código
  1. #include <cstddef>
  2.  
  3. template <class T>
  4. class Queue
  5. {
  6.  private:
  7.    struct Node
  8.    {
  9.      T data;
  10.      Node* prevNode;
  11.    };
  12.  
  13.    int dataSize;
  14.    Node* frontNode;
  15.    Node* lastNode;
  16.  
  17.    static Node* copyNode(Node* node, Node* last)
  18.    {
  19.      Node* newNode = NULL;
  20.      if(node)
  21.      {
  22. newNode = new Node;
  23. newNode->data = node->data;
  24. newNode->prevNode = copyNode(node->prevNode);
  25. if (newNode->nextNode == NULL) last = newNode;
  26.      }
  27.      return newNode;
  28.    }
  29.  
  30.    static void deleteNode(Node* node)
  31.    {
  32.      if(node)
  33.      {
  34. deleteNode(node->prevNode);
  35. delete node;
  36.      }
  37.    }
  38.  
  39.  public:
  40.    Queue();
  41.    Queue(const Queue& original);
  42.    ~Queue();
  43.  
  44.    T front() const;
  45.    bool empty() const;
  46.    int size() const;
  47.  
  48.    void push(const T &data);
  49.    void pop();
  50.    void clear();
  51.  
  52.    Queue& operator =(const Queue& original);
  53. };
  54.  
  55. template <class T>
  56. Queue<T>::Queue()
  57. {
  58.  dataSize = 0;
  59.  frontNode = NULL;
  60.  lastNode = NULL;
  61. }
  62.  
  63. template <class T>
  64. Queue<T>::Queue(const Queue& original)
  65. {
  66.  if (this != &original)
  67.  {
  68.    dataSize = original.dataSize;
  69.    frontNode = copyNode(original.frontNode);
  70.  }
  71. }
  72.  
  73. template <class T>
  74. Queue<T>::~Queue()
  75. {
  76.  deleteNode(frontNode);
  77. }
  78.  
  79. template <class T>
  80. T Queue<T>::front() const
  81. {
  82.  return frontNode->data;
  83. }
  84.  
  85. template <class T>
  86. bool Queue<T>::empty() const
  87. {
  88.  return (frontNode == NULL);
  89. }
  90.  
  91. template <class T>
  92. int Queue<T>::size() const
  93. {
  94.  return dataSize;
  95. }
  96.  
  97. template <class T>
  98. void Queue<T>::push(const T &data)
  99. {
  100.  Node* newNode = new Node;
  101.  newNode->data = data;
  102.  newNode->prevNode = NULL;
  103.  if (!frontNode) frontNode = newNode;
  104.  else lastNode->prevNode = newNode;
  105.  lastNode = newNode;
  106.  
  107.  dataSize = dataSize + 1;
  108. }
  109.  
  110. template <class T>
  111. void Queue<T>::pop()
  112. {
  113.  Node* aux = frontNode;
  114.  frontNode = frontNode->prevNode;
  115.  delete aux;
  116.  
  117.  dataSize = dataSize - 1;
  118. }
  119.  
  120. template <class T>
  121. void Queue<T>::clear()
  122. {
  123.  deleteNode(frontNode);
  124.  frontNode = NULL;
  125.  lastNode = NULL;
  126.  dataSize = 0;
  127. }
  128.  
  129. template <class T>
  130. Queue<T>& Queue<T>::operator =(const Queue& original)
  131. {
  132.  if (this != &original)
  133.  {
  134.    dataSize = original.dataSize;
  135.    deleteNode(frontNode);
  136.    frontNode = copyNode(original.frontNode);
  137.  }
  138.  return *this;
  139. }

Saludos.


En línea

"The programmers of tomorrow are the wizards of the future" - Gave Newel
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Pila & Cola
Programación C/C++
¡Micronet! 2 4,008 Último mensaje 23 Octubre 2010, 13:02 pm
por Saberuneko
Ayuda Urgente! Cola con Templates Clases
Programación C/C++
¡Micronet! 0 1,064 Último mensaje 28 Octubre 2010, 04:34 am
por ¡Micronet!
Implementar una pila con una cola en c++
Programación C/C++
alvareteb 9 5,773 Último mensaje 25 Enero 2012, 19:36 pm
por Xandrete
Motivos para ordenar una pila y una cola?
Programación General
milx86 3 2,432 Último mensaje 15 Marzo 2014, 16:57 pm
por milx86
[C] (Aporte) Estructura de pila y cola con memoria dinámica
Programación C/C++
class_OpenGL 2 2,927 Último mensaje 23 Agosto 2016, 04:56 am
por class_OpenGL
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines