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

Programando Odd Even Linked List con C++

Comentarios

Irving Juárez

student•

Aqui esta una implementación en JavaScript: Odd Even LinkedList en JavaScript

Nicolas Alpargatero

student•

Comparto código de la profe en python:

Pruebas:

No vi Bug.

Juan Pablo Reina Gutierrez

student•

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"

Francisco Roberto Gomez

student•

Queria consultar entiendo que revisamos el elemento Par y su siguiente en el ciclo while. Yo podria haber utilizado la siguiente sentecia:

While(impar!=nullptr && par!=nullptr){...}

Dentro del mismo while cambio el puntero impar al siguiente de par. Lo intente de esa forma y no me funciona (con listas con una cantidad de elementos pares). Se que no funciona pero no entiendo el porque?

Miguel Angel Reyes Moreno

student•

Porque piensa en esto: par -> impar -> par -> impar

bajo esta secuencia, lo que tienes que revisar es que par y además el siguiente valor al par; no sean nulos

si te encuentras en el último nodo e intentas cambiar su referencia a el siguiente... pues este no existe, por eso te da error.

John Eduard Meneses González

student•

My solution!!

Luis Felipe Tavera Orozco

student•

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.

Pedro Alvarado Garcia

student•

Lo de que es par o impar se refiere a las posiciones, no a los valores de los nodos.

Miguel Angel Reyes Moreno

student•

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;  }
&#x20; ListNode\* impar = cabeza;  ListNode\* par = cabeza->siguiente;  ListNode\* cabezaPar = par;
&#x20; while (par != nullptr && par->siguiente != nullptr) {    impar->siguiente = par->siguiente;    impar = impar->siguiente;    par->siguiente = impar->siguiente;    par = par->siguiente;  }
&#x20; impar->siguiente = cabezaPar;
&#x20; return cabeza;
}

Santiago Amaya

student•

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

Santiago Amaya

student•

hola

Francisco Roberto Gomez

student•

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);
}

Juan Pablo Reina Gutierrez

student•

Esta es mi solución en C++:

Pro Code

student•

Hola team@platzi.com, no se puede acceder al archivo de google drive.

Nicolas Alpargatero

student•

es el mismo que esta arriba https://static.platzi.com/media/public/uploads/7_05f6da52-b364-49a8-8faf-e84a02a6dfeb.cpp

Pro Code

student•

gracias por el dato Nicolas Alpargatero

Pro Code

student•

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;
    }

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;  }
&#x20; ListNode\* impar = cabeza;  ListNode\* par = cabeza->siguiente;  ListNode\* cabezaPar = par;
&#x20; while (par != nullptr && par->siguiente != nullptr) {    impar->siguiente = par->siguiente;    impar = impar->siguiente;    par->siguiente = impar->siguiente;    par = par->siguiente;  }
&#x20; impar->siguiente = cabezaPar;
&#x20; return cabeza;
}

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

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);
}

    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;
    }

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