Solución de Odd Even Linked List

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

Solución de Odd Even Linked List

Comentarios

REYNALDO FABIAN NORIEGA ZAMBRANO

Estudiante

Mi aporte, solo la funcion, en C++:

void reorder_list(Node *&head){
	Node *head_odd;
	Node *head_even;
	Node *tail_odd;
	Node *tail_even;

	if(!head) return;
	if(!head->next) return;
	head_odd = head;
	head_even = head->next;
	tail_odd = head_odd;
	tail_even = head_even;

	while(tail_odd->next && tail_even->next){
		tail_odd->next = tail_even->next;
		tail_even->next = tail_odd->next->next;
		tail_odd = tail_odd->next;
		tail_even = tail_even->next;
	}
	tail_odd->next = head_even;
	head = head_odd;
}

Nicolas Lopez

Estudiante

Lo vi 4 veces al video, no lo entendi. Tuve que recurrir a GeekForGeek para poder entender lo que quiso explicar.

Kengya Moncada

Estudiante

export function oddEvenList(cabeza) {
  // Escribe tu código aquí 👇
  let impar = cabeza;
  let par = cabeza.siguiente;
  let primerpar = par;

  if (cabeza == null && cabeza.siguiente == null) {
    return cabeza
  }


  while (par !== null && par.siguiente !== null) {
    impar.siguiente = par.siguiente;
    impar = impar.siguiente;
    par.siguiente = impar.siguiente;
    par = par.siguiente;
  }


  impar.siguiente = primerpar;

  return cabeza;
}

Yojan Antonio Pardo Zabala

Estudiante

Esta es mi solución en java:

creo un método para hacer merge de una lista con otra.

        public void merge(final MyLinkedList<K,V> rightList){
            rightList.getHead().setPrev(this.tail);
            this.tail.setNext(rightList.head);
            this.tail = rightList.getTail();
        }

Creo 2 listas auxiliares para guardar los valores de los nodos pares e impares.

MyLinkedList<Integer, Integer> test = new MyLinkedList<>();

        test.addNode(new Node<>(1,1));
        test.addNode(new Node<>(2,2));
        test.addNode(new Node<>(3,3));
        test.addNode(new Node<>(4,4));
        test.addNode(new Node<>(5,5));
        test.addNode(new Node<>(6,6));

        MyLinkedList<Integer, Integer> evenNodes = new MyLinkedList<>();
        MyLinkedList<Integer, Integer> oddNodes = new MyLinkedList<>();

creo la logica para llenar las listas con nodos pares e impares y mezclar las listas.

int nodeCounter = 1;
        Node<Integer, Integer> nodeIterator = test.getHead();

        while (Objects.nonNull(nodeIterator)){
            if(nodeCounter % 2 == 0){
                oddNodes.addNode(nodeIterator);
            } else {
                evenNodes.addNode(nodeIterator);
            }
            nodeCounter ++;
            nodeIterator = nodeIterator.getNext();
        }

        evenNodes.merge(oddNodes);

        System.out.println("sorted nodes:");

        evenNodes.forEach(System.out::println);

Implementé el método forEach para iterar facimente a través de mi lista.

Nicolas Alpargatero

Estudiante

Antes del merge de las listas:

Después del merge:

Código:

La lógica se complica bastante, para mí, me toco con copilot.

Pruebas:

Para las pruebas toca cargar el Nodo y después con next unirlos.

Wrandow Ramirez

Estudiante

Muy Buena Explicacion Gracias

void reorder_list(Node *&head){
	Node *head_odd;
	Node *head_even;
	Node *tail_odd;
	Node *tail_even;

	if(!head) return;
	if(!head->next) return;
	head_odd = head;
	head_even = head->next;
	tail_odd = head_odd;
	tail_even = head_even;

	while(tail_odd->next && tail_even->next){
		tail_odd->next = tail_even->next;
		tail_even->next = tail_odd->next->next;
		tail_odd = tail_odd->next;
		tail_even = tail_even->next;
	}
	tail_odd->next = head_even;
	head = head_odd;
}

export function oddEvenList(cabeza) {
  // Escribe tu código aquí 👇
  let impar = cabeza;
  let par = cabeza.siguiente;
  let primerpar = par;

  if (cabeza == null && cabeza.siguiente == null) {
    return cabeza
  }


  while (par !== null && par.siguiente !== null) {
    impar.siguiente = par.siguiente;
    impar = impar.siguiente;
    par.siguiente = impar.siguiente;
    par = par.siguiente;
  }


  impar.siguiente = primerpar;

  return cabeza;
}

        public void merge(final MyLinkedList<K,V> rightList){
            rightList.getHead().setPrev(this.tail);
            this.tail.setNext(rightList.head);
            this.tail = rightList.getTail();
        }

MyLinkedList<Integer, Integer> test = new MyLinkedList<>();

        test.addNode(new Node<>(1,1));
        test.addNode(new Node<>(2,2));
        test.addNode(new Node<>(3,3));
        test.addNode(new Node<>(4,4));
        test.addNode(new Node<>(5,5));
        test.addNode(new Node<>(6,6));

        MyLinkedList<Integer, Integer> evenNodes = new MyLinkedList<>();
        MyLinkedList<Integer, Integer> oddNodes = new MyLinkedList<>();

int nodeCounter = 1;
        Node<Integer, Integer> nodeIterator = test.getHead();

        while (Objects.nonNull(nodeIterator)){
            if(nodeCounter % 2 == 0){
                oddNodes.addNode(nodeIterator);
            } else {
                evenNodes.addNode(nodeIterator);
            }
            nodeCounter ++;
            nodeIterator = nodeIterator.getNext();
        }

        evenNodes.merge(oddNodes);

        System.out.println("sorted nodes:");

        evenNodes.forEach(System.out::println);

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