Aqui esta una implementación en JavaScript: Odd Even LinkedList en JavaScript
Introducción
¿Ya tomaste el Curso Avanzado de Algoritmos: Patrones de Arrays y Strings?
Lista Enlazada
Estructura de datos: Lista Enlazada
Programando listas enlazadas con Java
Cómo Invertir una Lista Enlazada
Odd Even Linked List: análisis del problema
Solución de Odd Even Linked List
Playground: Odd Even Liked List
Programando Odd Even Linked List con C++
Linked List Cycle: análisis del problema
Solución de Linked List Cycle
Playground: Linked List Cycle
Programando Linked List Cycle con Python
Palindrome Linked List: análisis del problema
Solución de Palindrome Linked List
Playground: Palindrome Linked List
Programando Palindrome Linked List con Java
Reorder List: análisis del problema
Solución de Reorder List
Programando Reorder List con JavaScript
Playground: Reorder List Without Repeated Values
Reto: LRU Caché
Ejercicios recomendados de Lista Enlazada
Ejercicios resueltos de Lista Enlazada
Pilas y colas
Estructura de datos: Pilas y Colas
Paréntesis Válido: análisis del problema
Solución de Paréntesis Válido
Playground: Paréntesis Válido
Programando Paréntesis Válido con C++
Ejercicios recomendados de Pilas
Colas de prioridad
Estructura de datos: Colas de Prioridad
K Closest Points to Origin: análisis del problema
Solución de K Closest Points to Origin
Playground: K Closest Points to Origin
Programando K Closest Points to Origin con Python
Reorganize String: análisis del problema
Solución de Reorganize String
Playground: Reorganize String
Programando Reorganize String con Python
Ejercicios recomendados de Colas de prioridad
Ejercicios resueltos de Colas de prioridad
Próximos pasos
Toma el Curso Avanzado de Algoritmos: Grafos y Árboles
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Programando Odd Even Linked List con C++
8/41Recursos
Aportes 11
Preguntas 1
Ordenar por:
La profe tiene un error en la línea 15 porque colocó un punto en lugar de la fecha en la parte de “par**.**siguiente != nullptr”
El código debería estar escrito así:
```
struct ListNode { int valor; ListNode \*siguiente; ListNode() : valor(0), siguiente(nullptr) {} ListNode(int x) : valor(x), siguiente(nullptr) {} ListNode(int x, ListNode \*siguiente) : valor(x), siguiente(siguiente) {}};
ListNode\* oddEvenList(ListNode\* cabeza) { if (cabeza == nullptr || cabeza->siguiente == nullptr) { return cabeza; }
ListNode\* impar = cabeza; ListNode\* par = cabeza->siguiente; ListNode\* cabezaPar = par;
while (par != nullptr && par->siguiente != nullptr) { impar->siguiente = par->siguiente; impar = impar->siguiente; par->siguiente = impar->siguiente; par = par->siguiente; }
impar->siguiente = cabezaPar;
return cabeza;
}
```
No me gusta la idea de asumir, dado este ejemplo, que el primero es impar y el segundo es par, para un caso en que la lista empiece por ej: 2,2,3,5 tanto el nodo par como impar ambas serían pares.
```python
def oddeven(self):
counter = 0
current = self.head
even_head = None
even_tail = None
odd_head = None
odd_tail = None
while current is not None:
counter += 1
if counter % 2 == 0: # Check if the index is even
if even_head is None:
even_head = current
even_tail = current
else:
even_tail.next = current
even_tail = even_tail.next
else:
if odd_head is None:
odd_head = current
odd_tail = current
else:
odd_tail.next = current
odd_tail = odd_tail.next
current = current.next
# Connect the even and odd lists
if even_head is not None:
even_tail.next = None
if odd_head is not None:
odd_tail.next = even_head
return odd_head
```
hola
oddeven en C++
template<class T> void Lista<T>::oddLista() {
//Defino los punteros fijos cabezas de linea
Nodo<T>*inicio_impar= nullptr;
Nodo<T>*inicio_par= nullptr;
//punteros de movimiento
Nodo<T> *general= nullptr;
Nodo<T> *par= nullptr;
Nodo<T> *impar= nullptr;
inicio_impar=inicio;
impar=inicio_impar;
inicio_par=inicio_impar->getSiguiente();
par=inicio_par;
while (par!= nullptr && par->getSiguiente() != nullptr){
impar->setSiguiente(par->getSiguiente());
impar=par->getSiguiente();
par->setSiguiente(impar->getSiguiente());
par=impar->getSiguiente();
}
impar->setSiguiente(inicio_par);
}
Esta es mi solución en C++:
Comparto código de la profe en python:
Pruebas:
No vi Bug.
Hola [email protected], no se puede acceder al archivo de google drive.
Lo hice distinto, es la misma lógica que utilicé para solucionar en el Playground con js, ahora con Java y el método toString para ver cómo queda, este código va en la clase ListaEnlaza realizada en la sección 3:
public void oddEvenLinkedList(Nodo cabeza) {
if (cabeza == null || (cabeza == this.cola)) { // Si la lista es nula o tiene sólo 1 Nodo
return;
}
Nodo anterior = cabeza;
Nodo actual = cabeza.siguiente;
Nodo colaOriginal = this.cola;
Nodo aux;
while (actual.siguiente != null) {
aux = actual.siguiente;
anterior.siguiente = actual.siguiente;
this.cola.siguiente = actual;
actual.siguiente = null;
this.cola = actual;
if (this.cola.equals(colaOriginal)) { // si la lista enlazada es de longitud par
/*
* Rompe el ciclo justo después de colocar como cola el Nodo colaOriginal
*/
break;
}
anterior = aux;
actual = aux.siguiente;
if (anterior.equals(colaOriginal)) { // si la lista enlazada es longitud impar
/*
* Rompe el ciclo cuando llegamos al Nodo colaOriginal
*/
break;
}
}
}
@Override
public String toString() {
String respuesta = "";
if (cabeza == null) { //Si la lista es vacía
respuesta = "ListaEnlazada{}";
} else if (cabeza != null && cabeza == cola) { // Si la lista tiene solo 1 nodo
respuesta = "ListaEnlazada{cabeza:" + cabeza.valor + ", cola: " + cola.valor + "}";
} else {
Nodo actual = cabeza;
while(actual.siguiente != null) {
respuesta += "actual: " + actual.valor + " -> ";
actual = actual.siguiente;
}
respuesta += "actual: " + actual.valor;
}
return respuesta;
}
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?