0
I have to create, in C, a program that receives a train of N wagons and rearranges these wagons in ascending order from 1 to N; To rearrange, K waiting rails are used (value informed by the user); These waiting rails, are stacks. That’s why I need to create a battery array.
I will post below what I have already done. The program is stopping when I try to access this array of cells.
I am using a TAD. So it follows in order my MAIN, then the FUNCTIONS and then the HEADERS used
********* MAIN *********
main () {
int n, num_trilhos, max, id, i, rep, aux;
int j = 0;
int k = 1;
pilha **plh;
lista *saida;
fila *entrada;
printf ("\n");
printf ("**** SIMULADOR DO PROCESSO DE REARRANJO DE VAGOES ****\n");
printf ("\nEntre com a quantidade de vagoes: ");
scanf ("%d", &n);
printf ("\nEntre com a quantidade inicial de trilhos de espera: ");
scanf ("%d", &num_trilhos);
if (n != 0)
{
entrada = cria_fila ();
saida = cria_lista ();
plh = (pilha**)malloc(num_trilhos*sizeof(pilha*));
for (i = 0; i < num_trilhos; i++)
{
plh[i] = cria_pilha ();
}
for (i = 0; i < n; i++)
{
id = rand () % n;
/* rep = checa_repetido(entrada, id);
/*
if (rep == 0)
{*/
insere_fila (entrada, id);
/*}
else
id = rand() % n;
*/
}
imprime_fila (entrada);
while (entrada->ini != NULL)
{
/* if (entrada->ini->id == 1)
{
insere_lista (saida, id);
retira_vagao (entrada);
continue;
}
*/
for (j = 0; j < num_trilhos; j++)
{
if (plh[j]->topo->id > entrada->ini->id && !pilha_cheia (plh[j])) // Se o valor do elemento no topo da pilha e maior que o valor ser inserido, insere.
{
printf ("ok");
push (plh[j], entrada->ini->id);
retira_vagao (entrada);
break;
}
else if (plh[j]->topo->id == NULL)
{
push (plh[j], entrada->ini->id);
retira_vagao (entrada);
break;
}
else
plh[num_trilhos + k] = cria_pilha (); // Caso tenha encerrado a quantidade de pilhas, cria mais uma
num_trilhos++;
push (plh[j + k], entrada->ini->id);
retira_vagao (entrada);
break;
}
}
printf ("\n");
free (saida);
libera_pilha (plh);
libera_fila (entrada);
}
else
printf ("Entrar com numero de vagoes valido");
return 0;
}
********** FUNÇÕES ***********
#include <stdio.h>
#include <stdlib.h>
#include "headers.h"
#define TamMax 3
fila *cria_fila ()
{
fila *novo = (fila *) malloc (sizeof (fila));
novo->ini = novo->fim = NULL;
return novo;
}
pilha *cria_pilha ()
{
pilha *novo = (pilha *) malloc (sizeof (pilha));
novo->topo = NULL;
return novo;
}
vagao *cria_vagao (int id)
{
vagao *novo = (vagao *) malloc (sizeof (vagao));
novo->prox = NULL;
novo->id = id;
return novo;
}
lista *cria_lista (void)
{
return NULL;
}
lista *insere_lista (lista * l, int id)
{
lista *novo = (lista *) malloc (sizeof (lista));
novo->info = id;
novo->prox = l;
return novo;
}
void insere_fila (fila * f, int id)
{
vagao *novo = cria_vagao (id);
if (f->fim == NULL)
{
f->ini = f->fim = novo;
}
else
{
f->fim->prox = novo;
f->fim = novo;
}
}
void libera_fila (fila * f)
{
vagao *aux;
while (f->ini != NULL)
{
aux = f->ini;
f->ini = f->ini->prox;
free (aux);
}
free (f);
}
void push (pilha * p, int id)
{
vagao *novo = cria_vagao (id);
if (p->topo == NULL)
{
p->topo = novo;
}
else
{
novo->prox = p->topo;
p->topo = novo;
}
}
void pop (pilha * p)
{
vagao *aux;
if (p->topo == NULL)
{
return;
}
else
{
aux = p->topo;
p->topo = p->topo->prox;
free (aux);
return;
}
}
void libera_pilha (pilha * p)
{
vagao *aux;
if (p == NULL)
return;
while (p->topo != NULL)
{
aux = p->topo;
p->topo = p->topo->prox;
free (aux);
}
free (p);
}
void retira_vagao (fila * f)
{
vagao *aux;
aux = f->ini;
f->ini = f->ini->prox;
free (aux);
}
void imprime_fila (fila * f)
{
while (f->ini->prox != NULL)
{
printf ("%d\t", f->ini->id);
f->ini = f->ini->prox;
}
}
int checa_repetido (fila * f, int id)
{
while (id != NULL)
{
if (f->ini->id == id)
{
return 1;
break;
}
else
f->ini = f->ini->prox;
}
return 0;
}
void pilha_cheia(pilha* plh)
{
if (plh->topo == TamMax)
{
printf("Pilha cheia\n");
}
}
*************** HEADERS ***************
#include <stdio.h>
#include <stdlib.h>
typedef struct Vagao vagao;
typedef struct Pilha pilha;
typedef struct Fila fila;
typedef struct Lista lista;
struct Vagao
{
int id;
vagao *prox;
};
struct Pilha
{
vagao *topo;
};
struct Fila
{
vagao *ini, *fim;
};
struct Lista
{
int info;
struct lista *prox;
};
lista *cria_lista();
fila *cria_fila();
pilha *cria_pilha();
vagao *cria_vagao(int id);
int checa_repetido (fila *f, int id);
void insere_fila(fila *f, int id);
void libera_fila(fila *f);
void push(pilha *p, int id);
void pop(pilha *p);
void libera_pilha(pilha *p);
void retira_vagao(fila *f);
void imprime_fila(fila *f);
program popping memory when I try to access the array of batteries
Is it a must for the vector to be dynamic? It cannot be a list?
– Leonardo Minari
@Leonardominari may be a list, as long as I can increase her size if necessary. Because if I use all the previously informed rails, I need to expand the amount. How would I do that? Thank you!
– Felipe Balbino