Ayuda con un intrucciones

[chasterboy]

hola estoy asiento un programa pero no entiendo bien lo que me están tratando de decir estas son las instrucciones
1. Defina una estructura de datos que contenga el identificador de un proceso cualquiera,
que debe ser un número entero cualquiera y la prioridad del mismo, entero de 1 a 10
donde 1 representa la prioridad más alta y 10 la más baja.
2. Defina una cola priorizada implementada como un arreglo de las estructuras definidas
en el punto anterior de un tamaño máximo razonable (entre 10 y 20).
3. Implemente la función insert que introduzca en la cola una estructura de proceso de
acuerdo a su prioridad.
4. Implemente la función removeFirst que saque de la cola la primera estructura que es la
de más alta prioridad.
5. Implemente la función display para desplegar el contenido de la cola. Esta función no es
esencial para la ejecución del programa pero será muy útil durante el desarrollo.
6. Implemente la función create que inserte en la cola un número cualquiera de
estructuras de procesos para poder contar con una cola de procesos no vacía.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <stdbool.h>
#include <stdlib.h>
#include <windows.h>
#include <time.h>
// Definición de funciones
void insert(int item); // insert en base a prioridad
int removeFirst(); // remove el primer elemento de la cola
int removePrio(int prio); // remove el primer elemento de la cola de cierta prioridad
void display(); // desplegar la cola
int peek(); // peek el primer elemento de la cola
void create(); // crea una cola priorizada con algunos elementos.

// Definición de variables globales
#define max 20 // capacidad de la cola
int queArray[max]; // cola priorizada implementada como arreglo
int front; // inicio de la cola
int rear; // fin de la cola

struct proceso{
    int datos;
    int prioridad;


}proceso;
int main() {
    setlocale(LC_ALL, ""); // para caracteres del Español
       create();
  int prioridad[] = {1,2,3,4,5,6,7,8,9,10};
    for(int i=0;i<10;i++){
        insert(prioridad[i]);

    }
    create();
    removeFirst();

            display();


    return 0;
}
// remover el elemento al inicio de la cola
int removeFirst() {
    if(front == -1 & rear == 0) {
        printf("Cola vacía, no se puede remover\n");
        return -1;
    } else {
        return queArray[front--];
    }

}
// remove el primer elemento de la cola de cierta prioridad

// insert en base a prioridad
void insert(int item) {
    if(front == max-1) {
        printf("Cola llena, no se puede insertar\n");
        return;
    }
    if(front == -1) {
        queArray[++front] = item;
    } else {
        if(item <= queArray[front]) {
            queArray[++front] = item;
        } else {
            int j, k;
            for(j = front; j >= rear; j--) {
                if(item >= queArray[j]) {
                    queArray[j + 1] = queArray[j];
                    k = j;
                }
            }
            queArray[k] = item;
            front++;
        }
    }
}

// peek el primer elemento de la cola

/* Despliega la cola */
void display() {
    if(front == -1 & rear == 0) {
        printf("Cola vacía\n");
    } else {
        printf("[");
        for(int i = front; i > rear; i--) {
            printf("%d, ", queArray[i]);
        }
        printf("%d]\n", queArray[rear]);
    }
}

void create() {
    front = -1;
    rear = 0;
    insert(1);
}

[K-YreX]

Lo que te piden es que crees tu propia estructura de cola con prioridad (priority_queue). Puedes ver cómo funciona aquí: http://www.cplusplus.com/reference/queue/priority_queue/
En el fondo es esto. Es una cola en la que los elementos se almacenan siguiendo un orden de prioridad. Es una cola en la que las inserciones se hacen según la prioridad que tienen asignadas y las expulsiones se hacen por uno de los extremos de la cola.

Puedes entenderlo como un vector/array en el que los elementos están ordenados según su prioridad. array[0] = {elemento de menor prioridad} y array[size-1] = {elemento de mayor prioridad}. Te pongo un ejemplo:

Código [Seleccionar] Expandir


Nomenglatura usada: objeto(prioridad)
Segun tu caso: numero menor = mas prioridad
priority_queue = { }
insert(A(5)) -> priority_queue = { A(5) }
insert(B(8)) -> priority_queue = { B(8), A(5) }
insert(C(1)) -> priority_queue = { B(8), A(5), C(1) }
insert(D(4)) -> priority_queue = { B(8), A(5), D(4), C(1) }
sacarTop() -> priority_queue = { A(8), B(5), D(4) }

Entonces lo que te piden es crear usando un array, una estructura que funcione así.
Las operaciones típicas que debe soportar son:

• insert(cola, elemento) -> inserta el elemento en la posición correcta
  
• removeFirst(cola) -> elimina el objeto con mas prioridad
  
• Te recomiendo hacer un top() -> muestra el elemento con mas prioridad. Ya que es recomendable que una función sólo lo muestre y el otro sólo lo elimine (removeFirst). Creo que eso es lo que vas a implementar tú en la función <peek()>.
  Y las funciones adicionales que te piden que son:
  
• display(cola) -> muestra toda la cola.
  
• create(cola) -> inicializa la cola con valores. Yo lo haría de forma random. O sea <create(cola, num_elementos)> y que meta <num_elementos> elementos en la cola creados de forma aleatoria.
  
  Ahora vamos al programa en si.
  En lugar de crearlo de forma global todo, te recomiendo hacerlo dentro del <main> tanto el array como la instancia <proceso> del <struct> <proceso> (mejor cambia el nombre: proceso_x (instancia) Proceso(struct) para evitar confusión).
  
  Te pongo un ejemplo de uso de cómo lo haría yo para que veas a lo que me refiero. Te pondré las partes necesarias de las funciones y del <main> pero las implementaciones de las funciones te las dejaré a ti.
  
  Código (c) [Seleccionar] Expandir
  
struct Proceso{
    int prioridad; // define la prioridad de un proceso
    int datos; // define los datos de ese proceso. Esto no tiene importancia
};

struct ColaPrioridad{
    Proceso cola_interna[SIZE]; // un array de Procesos que es nuestra cola con prioridad
    int size; // determina la cantidad de elementos que tiene la cola_interna.
};

// inserta <num_elementos> elementos en la cola (mi_cola.size = num_elementos)
// puede ser void o ser bool y retornar true si num_elementos <= SIZE y se han guardado bien o false si num_elementos > SIZE
void/bool create(ColaPrioridad mi_cola, int num_elementos);

// insertar un elemento en la cola en su posicion correspondiente segun su prioridad
// puede ser void o bool y retornar true si no se ha superado el limite de elementos (mi_cola.size < SIZE) o false en caso contrario
void/bool insert(ColaPrioridad mi_cola, Proceso nuevo_proceso);

// elimina el elemento con mayor prioridad
// puede ser void o bool y retornar true si la cola no esta vacia y se ha eliminado bien o false en caso contrario
void/bool removeFirst(ColaPrioridad);

// retorna el elemento de mayor prioridad de la cola sin eliminarlo de esta
Proceso top(ColaPrioridad);

// muestra la cola completa
void display(ColaPrioridad);

int main(){
    ColaPrioridad mi_cola;
    create(mi_cola, 5); // insertamos 5 procesos aleatorios en la cola
    display(mi_cola); // vemos el contenido
    Proceso proceso_nuevo1, proceso_nuevo2; // creamos dos procesos nuevos
    // damos valores a prioridad y datos de proceso_nuevo1 y proceso_nuevo2
   
    // insertamos los nuevos procesos despues de haberles dado valores en la cola
    insert(mi_cola, proceso_nuevo1);
    insert(mi_cola, proceso_nuevo2);
    display(mi_cola); // vemos el contenido
   
    removeFirst(mi_cola); // eliminamos el Proceso con mayor prioridad (es decir, con el atributo prioridad menor)
    display(mi_cola); // vemos el contenido
}
  
  En un principio puede parecer que tienes que introducir los elementos en el array de más prioridad a menos para eliminar el "primer elemento" que es el de mayor prioridad. Sin embargo, si los ordenas de menos a más prioridad, el elemento con más prioridad es <cola_interna[size-1]> y cuando tengas que eliminar el elemento de mayor prioridad (la función <removePrio()> sobra, solo se usa <removeFirst()>) solo tienes que hacer <size-->. Así ahora el último elemento ya es el anterior y cuando introduzcas un elemento nuevo sobrescribes el que se supone que habías borrado con desplazamientos.
  
  Si tienes alguna duda para implementar alguna de las funciones o sobre algo de lo que te he comentado, recuerda, de ser necesario, poner tus avances para poder ayudarte mejor. Suerte