Odd Even Linked List: análisis del problema

Cursos Empresas Blog Live Conf Precios

Contenido del curso

Introducción

1
¿Ya tomaste el Curso Avanzado de Algoritmos: Patrones de Arrays y Strings?
00:52 min

Lista Enlazada

Pilas y colas

Colas de prioridad

Próximos pasos

41
Toma el Curso Avanzado de Algoritmos: Grafos y Árboles
00:33 min

Tomar examen

Odd Even Linked List: análisis del problema

Comentarios

Nicolas Alpargatero

Estudiante

Como borrador, el análisis de si el curren_node es par, haga el cambio con el next, pero también que el nuevo current ya no sea 2 sino 4 y para el 5 si el previous es par, que sería 2 entonces cámbielo. Es un borrador de 25m 🙆‍♂️

Miguel Angel Reyes Moreno

Estudiante

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;  }
&#x20; let odd = head  let even = head.next  let evenHead = even
&#x20; while (even !== null && even.next !== null) {    odd.next = odd.next!.next;    odd = odd.next!;
&#x20;   even.next = even.next.next;    even = even.next;  }
&#x20; odd.next = evenHead
&#x20; 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));

Miguel Prada

Estudiante

En ruby xD

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
&#x20; def initialize    @head = nil    @tail = nil  end
&#x20; def append(node)    return if node.nil?
&#x20;   if @head.nil?      @head = node      @tail = node    else      @tail.next = node      @tail = node    end  end
&#x20; def to\_a    result = \[]    current = @head    while current      result << current.value      current = current.next    end
&#x20;   result  endend
class Node  attr\_accessor :value, :next
&#x20; def initialize(value)    @value = value    @next = nil  endend
def next\_node\_of\_next\_node(node)  return if node.next.nil?
&#x20; node.next.nextend
def disconnect\_node(node)  return if node.nil?
&#x20; Node.new(node.value)end
def alternate\_linked\_list(node)  alternated = LinkedList.new  new\_node = node
&#x20; while new\_node    alternated.append(disconnect\_node(new\_node))    new\_node = next\_node\_of\_next\_node(new\_node)  end
&#x20; 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
&#x20; response\_linked\_listend

Juan Pablo Reina Gutierrez

Estudiante

Esta es mi solución en Java:

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;  }
&#x20; let odd = head  let even = head.next  let evenHead = even
&#x20; while (even !== null && even.next !== null) {    odd.next = odd.next!.next;    odd = odd.next!;
&#x20;   even.next = even.next.next;    even = even.next;  }
&#x20; odd.next = evenHead
&#x20; 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));

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
&#x20; def initialize    @head = nil    @tail = nil  end
&#x20; def append(node)    return if node.nil?
&#x20;   if @head.nil?      @head = node      @tail = node    else      @tail.next = node      @tail = node    end  end
&#x20; def to\_a    result = \[]    current = @head    while current      result << current.value      current = current.next    end
&#x20;   result  endend
class Node  attr\_accessor :value, :next
&#x20; def initialize(value)    @value = value    @next = nil  endend
def next\_node\_of\_next\_node(node)  return if node.next.nil?
&#x20; node.next.nextend
def disconnect\_node(node)  return if node.nil?
&#x20; Node.new(node.value)end
def alternate\_linked\_list(node)  alternated = LinkedList.new  new\_node = node
&#x20; while new\_node    alternated.append(disconnect\_node(new\_node))    new\_node = next\_node\_of\_next\_node(new\_node)  end
&#x20; 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
&#x20; response\_linked\_listend

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 Prácticos con Listas Enlazadas y Historial de Navegador

Operaciones con Listas Enlazadas: Suma, Intercambio y Navegador

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++

Comparación de Cadenas con Backspaces

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

Colas de Prioridad: Ejercicios Prácticos y Soluciones

Colas de Prioridad y Gestión de Eventos

Próximos pasos

Toma el Curso Avanzado de Algoritmos: Grafos y Árboles