Skip to content

implementacion de metodos en refugio y listas. #16

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
RoccoDelgado10 wants to merge 2 commits into from
Closed

implementacion de metodos en refugio y listas. #16

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
629d417
hice la implementacion de los metodos de refugio y agregue las funcio…
RoccoDelgado10 Apr 3, 2025
028abc6
correcciones
RoccoDelgado10 Apr 3, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
227 changes: 94 additions & 133 deletions include/dataStructures/list.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -55,9 +55,9 @@ class LinkedList
*/
void push_front(const TData& value)
{
auto nuevo = new ListNode<TData>(value);
nuevo->next = head;
head = nuevo;
auto node = new ListNode<TData>(value);
node->next = head;
head = node;
}

/**
Expand All @@ -67,40 +67,31 @@ class LinkedList
*/
void remove_at(size_t position)
{
if (head == nullptr)
{
return;
}
if (head == nullptr){return;} //si esta vacia no hace nada

if (position == 0)
int contador = 0;

if (position == 0) //caso de posicion 0
{
auto temp = head;
auto temporalNode = head;
head = head->next;
delete temp;
delete temporalNode;
return;
}

// Para cualquier otra posicion necesitamos mantener un puntero al nodo anterior
auto prev = head;
auto current = head->next;
size_t current_position = 1;

// Avanzamos hasta encontrar la posicion o llegar al final de la lista
while (current != nullptr && current_position < position)
auto current = head;
ListNode<TData> previous = nullptr;
while (current != nullptr && contador < position)
{
prev = current;
previous = current;
current = current->next;
current_position++;
contador++;
}
if (current)
{
previous->next = current->next;
delete current;
}

// Si current es nullptr quiere decir que la posicion especifica es mas grande que la lista,
// no se encuentra la posicion
if (current == nullptr) return;

// Hacemos que el nodo anterior apunte al nodo siguiente actual
prev->next = current->next;

delete current;
}

/**
Expand All @@ -109,47 +100,49 @@ class LinkedList
*/
ListNode<TData>* take(size_t startPosition, size_t nElements)
{
// Si la lista esta vacia retornamos nullptr
if (head == nullptr)
{
return nullptr;
}
if (head == nullptr) {return nullptr;}

// Buscamos el nodo de inicio
ListNode<TData>* current = head;
size_t current_position = 0;
auto current = head;
int contador=0;

// Avanzamos hasta la posicion de inicio
while (current != nullptr && current_position < startPosition)
while (current!=nullptr && contador < startPosition)
{
current = current->next;
current_position++;
contador++;
}
if (current==nullptr) {return nullptr;}

// Si current es nullptr, la posicion esta fuera de rango
if (current == nullptr) return nullptr;

// Creamos el primer nodo de la nueva lista
ListNode<TData>* new_head = new ListNode<TData>(current->data);
ListNode<TData>* new_current = new_head;

// Avanzamos al siguiente nodo en la lista original
current = current->next;

// Copiamos los siguientes mElements-1 nodos (ya copiamos 1)
for (size_t i = 1; i < nElements && current != nullptr; i++)
//punteros controladores
ListNode<TData> newhead = nullptr, newtail = nullptr;
for (size_t i = 0; i < nElements; i++)
{
// Creamos un nuevo nodo con el valor actual
new_current->next = new ListNode<TData>(current->data);

// Avanzamos en ambas listas
new_current = new_current->next;
current = current->next;
auto copia = new ListNode(current->data);
if (newhead == nullptr) //primer nodo,es cabeza y cola
{
newhead = copia;
newtail = copia;
} else //si no es el primer nodo lo mandamos al final de la lista
{
newtail->next = copia;
newtail = copia;
}
current = current->next; //avanzamos al siguiente nodo
}

return new_head;
return newhead;
}

// Devuelve el tamaño de la lista
/* size_t size() const {
size_t count = 0;
auto current = head;
while (current) {
count++;
current = current->next;
}
return count;
}*/

/**
* @brief Imprime todos los elementos de la lista
*/
Expand Down Expand Up @@ -229,9 +222,16 @@ class DoublyLinkedList
*/
void push_front(const TData& value)
{
auto nuevo = new DoublyListNode<TData>(value);
nuevo->next = head;
head = nuevo;
auto node = new DoublyListNode<TData>(value);
if (head == nullptr)
{
head = node;
return;
}
node->next = head;
head->prev = node;
node->prev = nullptr;
head = node;
}

/**
Expand All @@ -241,28 +241,17 @@ class DoublyLinkedList
*/
void push_back(const TData& value)
{
auto nuevo = new DoublyListNode<TData>(value);
// nuevo->next = nullptr; No haria falta pq cuando se crea un DoublyListNode next y prev se inicilizan en nullptr

// Si la lista esta vacia
if (!head)
auto node = new DoublyListNode<TData>(value);
if (head == nullptr){head=node; return;}
node->next = nullptr; //apuntamos el nodo al nullptr
auto current = head;
while ( current->next != nullptr) //vamos al final de la lista
{
head = nuevo;
current =current->next;
}
else
{
// Si la lista tiene elementos, recorrer hasta el ultimo nodo
// DoublyListNode<TData>* temp = get_head();
auto temp = get_head();
while (temp->next != nullptr) // Buscamos el ultimo nodo
{
temp = temp->next;
}
current->next = node; //que el siguiente elemento del ultimo sea el nodo
node->prev = current; // que el previo al nodo sea el current

// temp es el ultimo nodo, se conecta con el nuevo ultimo nodo
temp->next = nuevo;
nuevo->prev = temp; // El prev de nuevo apunta al antiguo ultimo nodo, osea temp
}
}

/**
Expand All @@ -272,57 +261,29 @@ class DoublyLinkedList
*/
void remove_at(size_t position)
{
// Si la lista esta vacia no hay nada que eliminar
if (head == nullptr)
{
return;
}

// Caso que el nodo a eliminar sea el primero (nodo 0)
if (position == 0)
if (head == nullptr){return;} //si esta vacia no hace nada
int contador = 0;
if (position == 0) //caso de posicion 0
{
DoublyListNode<TData>* temp = head;
auto temporalNode = head;
head = head->next;

// Si hay mas nodos despues del primero actualizamos el prev del nuevo head
if (head != nullptr)
{
head->prev = nullptr;
}

delete temp;
delete temporalNode;
return;
}

// Para cualquier otra posicion recorremos la lista, hacemos un contador para llevar track de
// la posicion en la lista
DoublyListNode<TData>* current = head;
size_t current_position = 0;

while (current != nullptr && current_position < position)
auto current = head;
// DoublyListNode<TData> previous = nullptr; ya no hace falta guardar un previous
while (current != nullptr && contador < position)
{
// previous = current;
current = current->next;
current_position++;
}

// Si current es nullptr quiere decir que la posicion especifica es mas grande que la lista,
// no se encuentra la posicion
if (current == nullptr) return;

// current es el nodo que queremos eliminar, conectamos sus
// nodos adyacentes
if (current->prev != nullptr)
{
current->prev->next = current->next;
contador++;
}

if (current->next != nullptr)
if (current)
{
current->next->prev = current->prev;
}

delete current;

(current->prev)->next = current->next;
(current->next)->prev = current->prev;
delete current;
}else {return;} //si no se encuntra el nodo retornar
}

/**
Expand All @@ -332,20 +293,20 @@ class DoublyLinkedList
*/
void copy_list(const DoublyLinkedList& other)
{
// PREGUNTAR: Borramos los nodos actuales?
while (head != nullptr)
//caso donde no hay elementos en la lista nueva
if (other.head == nullptr){std::cout<<"no hay elementos que copiar"<<std::endl; return;}
while (head != nullptr) //eliminamos los elementos de la lista vieja
{
auto temporalNode = head;
auto current = head;
head = head->next;
delete temporalNode;
delete current;
}

// Copiamos los nodos de la otra lista con push_bakc()
auto current = other.get_head();
while (current != nullptr)
//hacemos un pushback en la lista vieja con los elementos de la lista nueva
auto current2 = other.head;
while (current2 != nullptr)
{
push_back(current->data);
current = current->next;
push_back(current2->data);
current2 = current2->next;
}
}

Expand Down
12 changes: 11 additions & 1 deletion include/dataStructures/wrapperVector.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,9 +5,11 @@
#ifndef WRAPPERVECTOR_HPP
#define WRAPPERVECTOR_HPP

#include <algorithm>
#include <cstddef>
#include <iostream>
#include <ostream>
#include <utility>
#include <algorithm>

auto constexpr INIT_CAPACITY {100}; //< Capacidad inicial del vector

Expand Down Expand Up @@ -114,6 +116,10 @@ class wrapperVector
*/
TData& operator[](size_t index)
{
if (index >= m_size)
{
std::cout << "Indice fuera de limites" << std::endl;
}
return m_data[index];
}

Expand All @@ -122,6 +128,10 @@ class wrapperVector
*/
const TData& at(size_t index) const
{
if (index >= m_size)
{
std::cout << "Indice fuera de limites" << std::endl;
}
return m_data[index];
}

Expand Down
Loading
Loading