Copia
Published: 2024-04-20 01:53:57

```
void process::Prioridad() {
    // Hacer una copia de la cola original
    node* originalQueue = nullptr;
    node* tail = nullptr;
    node* p = head;
    while (p != nullptr) {
        node* newNode = new node(p->id(), p->tme(), p->prty());
        if (originalQueue == nullptr) {
            originalQueue = newNode;
            tail = newNode;
        } else {
            tail->next(newNode);
            tail = newNode;
        }
        p = p->next();
    }

    // Ordenar la copia por prioridad
    node* sortedCopy = nullptr;
    while (originalQueue != nullptr) {
        node* maxNode = originalQueue;
        node* prevMaxNode = nullptr;
        node* current = originalQueue->next();
        node* prev = originalQueue;
        while (current != nullptr) {
            if (current->prty() > maxNode->prty()) {
                maxNode = current;
                prevMaxNode = prev;
            }
            prev = current;
            current = current->next();
        }
        // Sacar el nodo máximo de la lista original
        if (prevMaxNode != nullptr) {
            prevMaxNode->next(maxNode->next());
        } else {
            originalQueue = maxNode->next();
        }
        // Insertar el nodo máximo al principio de la lista ordenada
        maxNode->next(sortedCopy);
        sortedCopy = maxNode;
    }

    // Procesar y mostrar la cola ordenada
    // Aquí deberías colocar el código de procesamiento y salida
    // Asegúrate de trabajar con la lista ordenada (sortedCopy)

    // Liberar la memoria ocupada por la copia de la cola original y la lista ordenada
    while (originalQueue != nullptr) {
        node* temp = originalQueue;
        originalQueue = originalQueue->next();
        delete temp;
    }
    while (sortedCopy != nullptr) {
        node* temp = sortedCopy;
        sortedCopy = sortedCopy->next();
        delete temp;
    }
}
```


Otra kpia

```
#include <iostream>
#include <iomanip>

using namespace std;

// Suponiendo que tienes una clase llamada 'node' que representa un nodo en la lista enlazada

void process::FIFO() {
    cout << "\n\tPlanificacion de procesos - Sistemas Operativos";
    cout << "\n\n\tFIFO (Primera Entrada, Primera Salida)\n" << endl;
    
    // Copiar la lista original a una nueva lista
    node *copy_head = nullptr;
    node *copy_tail = nullptr;
    node *p = head;
    while (p != nullptr) {
        // Crear un nuevo nodo con los mismos datos que el nodo original
        node *new_node = new node(p->id(), p->tme());
        
        // Agregar el nuevo nodo a la lista copiada
        if (copy_head == nullptr) {
            copy_head = new_node;
            copy_tail = new_node;
        } else {
            copy_tail->set_next(new_node);
            copy_tail = new_node;
        }
        
        p = p->next();
    }

    float tR = 0, tRT = 0;
    cout << "\n\tId //" << " Tiempo de ejecucion //" << " Tiempo de retorno //"<< " Procesos restantes (ID Tiempo)" << endl;
    p = copy_head;
    while (p != nullptr) {
        tR += p->tme();
        tRT += tR;
        cout << "\t"<< p->id() << "\t\t"<< p->tme()<< "\t\t"<< tR<< "\t\t";

        // Mostrar los procesos restantes en la lista copiada
        node *t = p->next();
        while(t != nullptr){
            cout << " | " << t->id() << " " << t->tme() << " | ";
            t = t->next();
        }
        cout << endl;

        p = p->next();
    }
    
    // Liberar la memoria asignada para la lista copiada
    p = copy_head;
    while (p != nullptr) {
        node *temp = p;
        p = p->next();
        delete temp;
    }

    cout << "\n\tTiempo promedio: "<< fixed << setprecision(2) << (float)tRT/n << endl;
}
```