Odd Even Linked List: análisis del problema

Curso de Algoritmos Avanzados: Estructuras de Datos Lineales

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

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

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:001:59

Odd Even Linked List: análisis del problema

Curso de Algoritmos Avanzados: Estructuras de Datos Lineales

Clase 5 de 34

Clase 5 / 34

Miguel Prada

Hace 3 años

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

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

Programando Odd Even Linked List con C++

Linked List Cycle: análisis del problema

Solución de Linked List Cycle

Programando Linked List Cycle con Python

Palindrome Linked List: análisis del problema

Solución de 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

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

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

Programando K Closest Points to Origin con Python

Reorganize String: análisis del problema

Solución de 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

Odd Even Linked List: análisis del problema