- Como borrador, el análisis de si el
curren_nodees par, haga el cambio con elnext, pero también que el nuevo current ya no sea2sino4y para el5si elpreviouses par, que sería2entonces cámbielo.
Es un borrador de 25m 🙆♂️
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,
Odd Even Linked List: análisis del problema
5/41Recursos
Aportes 4
Preguntas 0
Ordenar por:
Hecho en TypeScript (la primera parte la conseguí en leetcode):
```
class ListNode { val: number; next: ListNode | null; constructor(val?: number, next?: ListNode | null) { *this*.val = val === undefined ? 0 : val; *this*.next = next === undefined ? null : next; }}
function oddEvenList(head: ListNode | null): ListNode | null { if (!head) { return null; }
let odd = head let even = head.next let evenHead = even
while (even !== null && even.next !== null) { odd.next = odd.next!.next; odd = odd.next!;
even.next = even.next.next; even = even.next; }
odd.next = evenHead
return head;}
const listNode: ListNode = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5)))));/\* input \[1,2,3,4,5] o-e-o-e-o output \[1,3,5,2,4] o-o-o-e-e\*/
const listNode2: ListNode = new ListNode(2, new ListNode(1, new ListNode(3, new ListNode(5, new ListNode(6, new ListNode(4, new ListNode(7)))))));/\* input \[2,1,3,5,6,4,7] o-e-o-e-o-e-o output \[2,3,6,7,1,5,4] o-o-o-o-e-e-e\*/
console.log(oddEvenList(listNode));console.log(oddEvenList(listNode2));
```
En ruby xD
```js
class LinkedList
attr_accessor :head, :tail
def initialize
@head = nil
@tail = nil
end
def append(node)
return if node.nil?
if @head.nil?
@head = node
@tail = node
else
@tail.next = node
@tail = node
end
end
def to_a
result = []
current = @head
while current
result << current.value
current = current.next
end
result
end
end
class Node
attr_accessor :value, :next
def initialize(value)
@value = value
@next = nil
end
end
def next_node_of_next_node(node)
return if node.next.nil?
node.next.next
end
def disconnect_node(node)
return if node.nil?
Node.new(node.value)
end
def alternate_linked_list(node)
alternated = LinkedList.new
new_node = node
while new_node
alternated.append(disconnect_node(new_node))
new_node = next_node_of_next_node(new_node)
end
alternated
end
def odd_even_linked_list(linked_list)
response_linked_list = alternate_linked_list(linked_list.head)
response_linked_list.tail.next = alternate_linked_list(linked_list.head.next).head
response_linked_list
end
```class LinkedList attr\_accessor :head, :tail
def initialize @head = nil @tail = nil end
def append(node) return if node.nil?
if @head.nil? @head = node @tail = node else @tail.next = node @tail = node end end
def to\_a result = \[] current = @head while current result << current.value current = current.next end
result endend
class Node attr\_accessor :value, :next
def initialize(value) @value = value @next = nil endend
def next\_node\_of\_next\_node(node) return if node.next.nil?
node.next.nextend
def disconnect\_node(node) return if node.nil?
Node.new(node.value)end
def alternate\_linked\_list(node) alternated = LinkedList.new new\_node = node
while new\_node alternated.append(disconnect\_node(new\_node)) new\_node = next\_node\_of\_next\_node(new\_node) end
alternatedend
def odd\_even\_linked\_list(linked\_list) response\_linked\_list = alternate\_linked\_list(linked\_list.head) response\_linked\_list.tail.next = alternate\_linked\_list(linked\_list.head.next).head
response\_linked\_listend
Esta es mi solución en Java:
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?