Consulta procesos

Bueno verás, un consejo, sobre la forma de escribir las estructura, para mi es muy enmarañado poner
typedef struct procesador{
         int pasos_desocuparse;
         int procesos_ejecutado;
         int pasos_terminar_proceso;
        struct procesador *sigt;
        struct procesador *sig;
         }PROCESADOR;   <- aqui, para que ponerle un nombre, si ya tiene uno.
es suficiente con
struct procesador{
         int pasos_desocuparse;
         int procesos_ejecutado;
         int pasos_terminar_proceso;
        struct procesador *sigt;
        struct procesador *sig;
         };  
y cuando declares procesadores
procesador   *procesador1
bueno es, para mi mas comodo.
los errores que botaba tu programa eran los siguientes
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
 typedef struct procesador{
         int pasos_desocuparse;
         int procesos_ejecutado;
         int pasos_terminar_proceso;
        struct procesador *sigt;
        struct procesador *sig;
         }PROCESADOR;
  typedef struct proceso{
          int N_proceso;
          int prioridad;
          int pasos;
          int culminado;
          int asignado;
          int procesador_termina;
         struct proceso *sig;
          } PROCESO;
  typedef struct colaproceso{
          int N_proceso;
         struct colaproceso *sig;
          } COLAPROCESO;
typedef PROCESADOR  *pprocesador;
typedef PROCESO     *pproceso;
typedef COLAPROCESO *pcolaproceso;
  PROCESO *proc;  <-  aqui tu pusiste pproceso *proc;
  PROCESO *ultimo;   <- y  aqui  pproceso *ultimo; 
// Y bueno, pproceso, como se ve 2 lineas más arriba, es un nombre de un puntero, no es un tipo de dato. Por eso como supongo que tu deseabas declarar a proc y ultimo como punteros a un proceso lo modifique.
     void crearprocesos(pproceso *new_procesador){
     int creados, contador;
     creados =  1 + rand() % 9;
      switch(creados){
       case 1:
        creados=1;
       break;
       case 2:
       break;
       case 3:
       break;
       case 4:
       break;
       case 5:
       break;
       case 6:
       break;
       case 7:
       break;
       case 8:
        creados=2;
       break;
       case 9:
        creados=3;   
       break;
       case 10:
        creados=0;
       break;
       default:
        printf("opcion invalida");
        }
      for (int i=1; i<creados; i++){
          if(ultimo==NULL){
            proc = new PROCESO; <-  aqui pusiste proc =new_procesador;
// Y esta mal por que proc es un proceso, y declarabas o deseabas guardar un espacio de memoria dirigido a un procesador, lo cual es como querer meter un carácter en una variable int. Ademas cuando haces new, no se pone new_ sino solamente new y el nombre del tipo de dato a guardar memoria
            ultimo=proc;
         } else{   <- aqui le faltaba esta llave de abertura para el else
            ultimo->sig = new proceso; <- aqui el mismo error de mas arriba
            ultimo=ultimo->sig;
            ultimo->prioridad= 1 + rand() % 2;
            ultimo->pasos=1 + rand() % 29;
            ultimo->culminado=0;
            ultimo->asignado=0;
            ultimo->N_proceso=contador;
            contador=contador+1;
            }
      }                  
     }   <- aqui borré una llave que sobraba
  /*
void  asignaprocesos(){
     procesos *temp;
     temp = proc;
     while (temp!=null){
       for(int priori = 3; priori<=1; priori--){
              if(priori =temp->prioriad && temp->asignado==0)
               }
               }  
              } */ <- Y he puesto como comentario esta parte por que aun no está terminada, y bueno como es obvio botará errores, tal vez.
Y el error que de hecho te va a botar, o bueno no se va a presentar como error, pero va a darte tal vez una advertencia si corres el código como esta, por que no tienes declarado un void main, sin eso el programa está pues, incompleto, y no puede ser compilado correctamente.
Esos son los errores encontrados hasta el momento. Hasta otra, y si tienes otros errores de ejecución, o de codificación no dudes en pasarme la voz, con mucho gusto te ayudaré.
Hasta pronto

Oye sabes que en el algoritmo que tu me pasaste había una variable creo si no entendí mal que se llamaba nuevo procesador y como era muy larga yo le coloque new_procesador, ¿con tu aclaración no se si tu estas haciendo referencia ahora al operador new?

claro a ese operador me referia. a pero igual estarías haciendo mal
por que new_procesador sería un puntero a la estructura procesador
pero proc y ultimo, son punteros que tu has declarado como PROCESO. entonces igual no puedes hacer esa igualdad. ademas new_procesador esta declarado asi
void crearprocesos(pproceso *new_procesador){  y pucha, decir que new_procesador es un proceso como que te va a confundir un poco despues. fijate en aclarar tus asignaciones y nombres, ten cuidado.
¿Tienes otra duda?

Por favor mira lo que te envíe a tu correo

Aquí está el código con su respectiva modificación, esta comentada cada modificación
si aun tienes dudas, solo avisame ;)
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <time.h>
#include <conio.h>
 struct procesador{
           // lo olvidaba, cada procesador debe tener una identificacion
           // para que cada proceso de la lista, en su campo
           // procesador_termina, se guarde el numero del procesador
           //que lo culminó.
           int N_procesador;
         int pasos_desocuparse;
         int procesos_ejecutado;
         int pasos_terminar_proceso;
        struct procesador *sigp;
        struct colaproceso *sigc;     // modificado de procesador a cola proceso
                                      // debido a que el procesador esta conectado con otros procesadores
                                      // y con la cola de procesos que desean ser atendidos
         };
  struct proceso{
          int N_proceso;
          int prioridad;
          int pasos;
          int culminado;
          int asignado;
          int procesador_termina;
         struct proceso *sig;
          };
  struct colaproceso{
          int N_proceso;
         struct colaproceso *sig;
          };
procesador *procesador1;
proceso *proceso1;
colaproceso *colaproceso1;
  proceso *proc;
  proceso *ultimoproc;
  //modificacion ultimo por ultimoproc
  /*Esta variable se va a usar en tu cola de procesos agregados
pero no en la cola de procesos a ejecutar en los procesadores
por lo que la variable ultimo que usas en tu función recorrido
debe ser otra muy distinta a esta
ya que en recorrido se habla de una variable ultimo, pero que apunta
al ultimo de la cola de los procesadores
y el tipo de dato usado ahí es de colaproceso.
  dicha variable ultimo, la he agregado en tu funcion.*/
  procesador *cab;
     void crearprocesos(){
     int creados, contador;
     creados =  1 + rand() % 9;
      switch(creados){
       case 1:
        creados=1;
       break;
       case 2:
       break;
       case 3:
       break;
       case 4:
       break;
       case 5:
       break;
       case 6:
       break;
       case 7:
       break;
       case 8:
        creados=2;
       break;
       case 9:
        creados=3;   
       break;
       case 10:
        creados=0;
       break;
       default:
        printf("opcion invalida");
        }
      for (int i=1; i<creados; i++){
          if(ultimoproc==NULL){
            proc =new proceso; // aca debes usar el operador new, debido a que
                                  //en realidad se compara la variable ultimoproc
                                  //si es nula, entonces en proc, tmbien será nulo
                                  //y tendrás que crear el espacio de memoria con
                                  //new proceso.
            ultimoproc=proc;  //aca se iguala. no olvides que proc es la cabecera de tu lista de procesos
         } else{
            ultimoproc->sig = new proceso; // de igual modo
            ultimoproc=ultimoproc->sig;
            ultimoproc->prioridad= 1 + rand() % 2;
            ultimoproc->pasos=1 + rand() % 30; // si los pasos son de a 30, entonces deberías hacer mod 30
            ultimoproc->culminado=0;
            ultimoproc->asignado=0;
            ultimoproc->N_proceso=contador;
            contador=contador+1;
            }
      }                  
}
 void asignaprocesos(proceso *temp){
     int cont;
     //temp = proc;
     while (temp!=NULL){
       for(int priori = 3; priori<=1; priori--)
              if(priori ==temp->prioridad && temp->asignado==0){
               }
               temp=temp->sig;
          }
              }
   void recorrido(){
     colaproceso *ultimo;  //declaración de la variable ultimo
        proceso *puntero;
        procesador *temp;  //no es necesario declararlo como parametro de esta funcion
        for (int i=1; i<=1000; i++)
         //crearprocesos();
         //asignaprocesos();
         temp= cab;
         while(temp!=NULL){
            if(temp->pasos_terminar_proceso==0)
             temp->procesos_ejecutado=temp->sigc->N_proceso;
             //antes : temp->sigc=temp->sigc->sigc; // modificado, debido a que temp->sigc apunta a
                                          //una estructura colaproceso, en sus campos
                                          //no existe sigc, sino sig
             /*
             Antes de la siguiente linea te doy un consejo, puedes crear un puntero
             Llamado eliminador, para poder liberar espacio de memoria y no
             Dejes ocupada memoria con datos que no vas a usar.
             Esto es por que en la siguiente ejecución:
                temp->sigc=temp->sigc->sig;
             Lo que se hace es saltarse del proceso al que se apunta con sigc
             Al siguiente proceso que es apuntado por el proceso apuntado por sigc
             Entonces esta haciendo por decirlo así, un puente, y el proceso al que
             Apuntabas, lo estas ignorando, pero puedes eliminarlo del siguiente modo.
             DECLARA AL INICIO DE LA FUNCIÓN RECORRIDO un puntero de tipo colaproceso
             Llamado eliminador.
             Antes de hacer el puente, apunta al espacio que deseas eliminar
             eliminador=temp->sigc
             ahora haces el puente
              temp->sigc=temp->sigc->sig;
              y ahora elimina el espacio que estas ignorando, que está siendo
              apuntado por eliminador
              delete(eliminador); con eso es suficiente.
             */
             temp->sigc=temp->sigc->sig;
             puntero=proc;
              while(puntero->N_proceso!=temp->procesos_ejecutado){
               puntero=puntero->sig;
              }  
               if(puntero->pasos<=10){
                temp->pasos_terminar_proceso=puntero->pasos;
                }
                else{
                     temp->pasos_terminar_proceso=10;
                     }                                           
        }
        temp->pasos_desocuparse=temp->pasos_desocuparse-1;
        temp->pasos_terminar_proceso=temp->pasos_terminar_proceso-1;
        puntero->pasos=puntero->pasos-1;
         if(temp->pasos_terminar_proceso==0 &&  puntero->pasos>0){
                     //antes ultimo->sig= nuevo colaproceso;
                     //modificacion  nuevo por new
                             ultimo->sig= new colaproceso;
                     ultimo=ultimo->sig;
                     ultimo->N_proceso=temp->procesos_ejecutado;
                     /*OBS   no te olvides que el puntero ultimo
                     debe recorrer la lista de la cola de procesos
                     del procesador apuntado con temp. para que puedas hacer
                     el agregado que haces en las 3 lineas de codigo anteriores*/
                                           }
     if (puntero->pasos==0){
      puntero->culminado=1;  
      puntero->procesador_termina=temp->N_procesador;
                              }
        temp=temp->sigp;                                 
}

¿new esta haciendo la función de malloc?