void opcao(node *PRONTOS,node *EXECUTANDO, node *BLOQUEADO,node *FINALIZADOS,int op){
node *tmp;
switch(op){
case 0:
libera(PRONTOS);
break;
case 1:
libera(PRONTOS);
inicia(PRONTOS);
break;
case 2:
listaProcessos(PRONTOS,EXECUTANDO, BLOQUEADO, FINALIZADOS);
break;
case 3:
insere(PRONTOS);
break;
case 9: Escalonador_Simples(PRONTOS,EXECUTANDO, BLOQUEADO,FINALIZADOS);
break;
case 4:
tmp= retira(PRONTOS);
if(tmp != NULL){
printf("Retirado: %3d\n\n", tmp->num);
libera(tmp);
}
break;
default:
printf("Comando invalido\n\n");
}
}
/* ------------------------------ */
int main() {
int x, coef, exp, poliEscolhido, operando1, operando2;
Polinomio *p1 = NULL;
Polinomio *p2 = NULL;
Polinomio *resultado = NULL;
scanf("%d",&x);
int opcao = 1;
while(opcao != 0){
scanf("%d",&opcao);
switch(opcao){
case ADICIONAR_POLI:
scanf("%d %d %d", &poliEscolhido, &coef, &exp);
poliEscolhido == 1 ? adicionarPolinomio(&p1,coef,exp) : adicionarPolinomio(&p2,coef,exp);
//imprimir(p1);
break;
case REMOVER_POLI:
scanf("%d %d", &poliEscolhido, &exp);
poliEscolhido == 1 ? removerPolinomio(&p1,exp) : removerPolinomio(&p2,exp);
break;
case SOMAR_POLI:
if(resultado != NULL) libera(resultado);
resultado = somarPolinomios(p1,p2);
break;
case SUBTRAIR_POLI:
scanf("%d %d", &operando1, &operando2);
if(resultado != NULL) libera(resultado);
resultado = subtrairPolinomios(operando1 == 1 ? p1 : p2, operando2 == 2 ? p2 : p1);
break;
case MULTIPLICAR_POLI:
if(resultado != NULL) libera(resultado);
resultado = multiplicarPolinomios(p1,p2);
//imprimir(resultado);
break;
case CALCULAR_POLI:
scanf("%d",&poliEscolhido);
switch(poliEscolhido) {
case 1: printf("%d\n",calcularPolinomio(p1,x)); break;
case 2: printf("%d\n",calcularPolinomio(p2,x)); break;
case 3: printf("%d\n",calcularPolinomio(resultado,x)); break;
}
break;
}
}
return (0);
}
// Programa principal
int main(int argc, char *argv[])
{
void* objeto;
int valor1 = 156;
int valor2 = 188;
Hash* willy;
Pessoa* p_ricardo;
Pessoa* p_antonio;
Hash* deInteiros;
p_ricardo = inicializa_pessoa();
p_antonio = inicializa_pessoa();
p_ricardo = cria_pessoa(304050, 13640043);
p_antonio = cria_pessoa(306050, 13740012);
willy = inicializa(100, &compara_pessoas);
insere(willy, "RicardoChave", p_antonio);
insere(willy, "RicardoChave", p_ricardo);
objeto = busca(willy, "RicardoChave", p_antonio);
if(objeto == NULL) {
printf("Objeto nao encontrado!\n");
} else {
Pessoa* pessoa = (Pessoa*) objeto;
printf("RG com cast: %d\n", pessoa->rg);
printf("CPF com cast: %d\n", pessoa->cpf);
}
printf(" \n");
printf("Criando uma tabela hash agora de inteiros..\n");
printf(" \n");
deInteiros = inicializa(100, compara_inteiros);
insere(deInteiros, "Inteiro", (void*)(&valor1));
insere(deInteiros, "Inteiro", (void*)(&valor2));
objeto = busca(deInteiros, "Inteiro", (void*)(&valor1));
if( objeto == NULL ) {
printf("Objeto encontrado\n");
} else {
int* int_ = (int*)objeto;
printf("Inteiro: %d\n", *int_);
}
objeto = busca(deInteiros, "Inteiro", (void*)(&valor1));
if(objeto == NULL)
printf("Ele nao existe na tabela!");
libera(willy);
free(willy);
libera(deInteiros);
free(deInteiros);
return 0;
}
Arv* libera (Arv* a)
{
if (!vazia(a))
{
libera(a->esq); /* libera sae */
libera(a->dir); /* libera sad */
free(a); /* libera raiz */
}
return NULL;
}
void opcao(no *lista, int op){
no *tmp;
switch(op){
case 0:
libera(lista);
printf("Ate mais!\n");
break;
case 1:
libera(lista);
printf("a lista foi limpa!\n");
inicia(lista);
break;
case 2:
printlista(lista);
break;
case 3:
addinicio(lista);
break;
case 4:
addfim(lista);
break;
case 5:
colocaqualquer(lista);
break;
case 6:
tmp= removecomeco(lista);
break;
case 7:
tmp= removefim(lista);
break;
case 8:
tmp= excluialguem(lista);
break;
case 9:
printf("\nValor a ser procurado: ");
scanf("%d",&valor);
procuralista(lista,valor);
break;
default:
printf("Comando invalido\n\n");
}
}
int main(){
int num,num2, opcao,mod,div;
Lista l,l2,l3;
inicLista(&l);
inicLista(&l2);
inicLista(&l3);
printf("Entre com o primeiro numero: ");
scanf("%d", &num);
while(num > 0)
{
mod = num % 10000;
num = num / 10000;
//printf("Num: %d\n",num);
insereFim(&l, mod);
}
///exibe(&l);
printf("\nEntre com o segundo numero: ");
scanf("%d", &num2);
while(num2 > 0)
{
mod = num2 % 10000;
num2 = num2 / 10000;
//printf("Num2: %d\n",num2);
insereFim(&l2, mod);
}
soma(&l,&l2,&l3);
//exibe(&l2);
printf("\n");
printf("Lista 1: \n");
exibe(&l);
printf("\n\n");
printf("Lista 2: \n");
exibe(&l2);
printf("\n\n");
printf("Soma das duas Listas: \n");
exibe(&l3);
printf("\n\n");
libera(&l);
libera(&l2);
libera(&l3);
return 0;
}
int main(int argc, char *argv[]){
int l, c, linha, coluna;
float y;
Matriz* x;
scanf("%d", &linha);
scanf("%d", &coluna);
x = cria(linha, coluna);
l = linhas(x);
c = colunas(x);
printf("\n%d\n", l);
printf("\n%d\n", c);
//y = acessa(x, linha, coluna);
//printf("\n%f\n", y); //printa 0
libera(x); //libera cria que é x
//y = acessa(x, linha, coluna);
//printf("\n%f\n", y); //printa o endereço de y
atribui(x, linha, coluna, 10);
y = acessa(x, linha, coluna); //Neste y = acessa vai ser conferido se realmente o 10 foi atribuido à matriz
printf("\n%.2f\n", y); //printa o endereço de y depois de executar atribui. Tem que printar 10
return 0;
}
void Bspline::limpa_bspline () {
this->nos_bspline = 0;
this->cont_pontos = 0;
this->pontos = libera(this->pontos);
free(this->VT);
this->VT = NULL;
}
void opcao(node *LISTA, int op)
{
switch(op){
case 0:
libera(LISTA);
break;
case 1:
exibe(LISTA);
break;
case 2:
insereInicio(LISTA);
break;
case 3:
insereFim(LISTA);
break;
case 4:
inicia(LISTA);
break;
default:
printf("Comando invalido\n\n");
}
}
int main(int argc, char** argv) {
int op;
float v;
Pilha *p1, *p2;
p1 = cria();
p2 = cria();
printf("Digite valores da Pilha 1:\n");
do {
printf("Digite o valor: ");
scanf("%f",&v);
push (p1, v);
printf("\nDeseja inserir mais elementos: 1 - Sim, 0 - Nao ");
scanf("%d",&op);
}while(op == 1);
printf("Digite valores da Pilha 2:\n");
do {
printf("Digite o valor: ");
scanf("%f",&v);
push (p2, v);
printf("\nDeseja inserir mais elementos: 1 - Sim, 0 - Nao ");
scanf("%d",&op);
}while(op == 1);
concatena_pilhas(p1,p2);
libera(p2);
printf("Imprimir Pilha 1:\n\n");
imprime(p1);
return (EXIT_SUCCESS);
}
int main() {
int N; // numero de pessoas na fila
Lista l; // lista - usada para a fila dinamica
int i; // contador
int pessoa; // idade da pessoa que entrou na fila
int a; // quantidade de pessoas que foi atendida
int tam; // tamanho da fila
scanf("%d", &N);
while (N > 0) {
inicLista(&l);
// insere as pessoas na fila
for (i = 0; i < N; i++) {
scanf("%d", &pessoa);
insereLista(&l, pessoa);
}
// remove da fila as pessoas que ja foram atendidas
scanf("%d", &a);
for (i = 0; i < a; i++) {
int e;
removeInicio(&l, &e);
printf("%d ", e);
}
printf("\n");
scanf("%d", &N);
libera(&l);
}
return 0;
}
int main(){
double dt = 0.1;
double *time;
double t_start, t_end;
int time_steps, Nsamples;
Matrix *xSaved, *zSaved;
double z;
t_start = 0;
t_end = 10;
time_steps =(int)((double)(t_end - t_start)/dt + 0.5);
//arredonda para cima o resultado da divisão
time = (double *)aloca(time_steps*sizeof(double));
int i;
for(i = 0; i < time_steps; i++){
time[i] = i*dt;
}
Nsamples = time_steps;
xSaved = new_M(Nsamples, 3);
zSaved = new_M(Nsamples, 2);
for(i = 0; i < Nsamples; i++)
{
z = getVel();
Matrix *X = NULL;
X = intKalman(z);
xSaved->a[i][0] = time[i];
xSaved->a[i][1] = X->a[0][0];
xSaved->a[i][2] = X->a[1][0];
zSaved->a[i][0] = time[i];
zSaved->a[i][1] = z;
kill_M(&X);
}
const char fileX[] = "../data/X.dat";
const char fileZ[] = "../data/Z.dat";
MatrixPrint2File(xSaved, fileX);
MatrixPrint2File(zSaved, fileZ);
kill_M(&xSaved);
kill_M(&zSaved);
libera(time);
KalmanFilter_End();
EndProgram();
reportGood("O programa chegou ao fim!");
return(0);
}
void kill_M(Matrix **A){
/*apaga a matriz e o seu ponteiro
* */
int i;
if(*A)
{
for(i = 0; i < (*A)->rows; i++)
libera((*A)->a[i]);
libera((*A)->a);
libera(*A);
(*A) = NULL;
}
else
reportBad("kill_M recebeu matriz não alocada!");
}
/* Inicializacao do programa */
int main(){
Agenda *lista, *resp;
lista = NULL;
int tel_lido;
char parametro;
char nome_lido[TAM];
do{
parametro = getchar();
switch(parametro){
case('i'): /* Insere um novo contato na agenda */
getchar();
scanf("%d", &tel_lido);
getchar();
scanf("%[^\n]", nome_lido);
getchar();
insereOrdenado(tel_lido, nome_lido, &lista);
break;
case('r'): /* Faz a remocao de um contato da agenda */
getchar();
scanf("%[^\n]", nome_lido);
getchar();
resp = busca(nome_lido, lista);
if(resp == NULL)
printf("Nao foi possivel remover: Contato inexistente!\n\n");
else
printf("Contato: %-40s %d\nFoi removido com sucesso!\n\n", resp->nome, resp->tel);
removeNo(nome_lido, &lista);
break;
case('n'): /* Busca um nome na agenda */
getchar();
scanf("%[^\n]", nome_lido);
getchar();
resp = busca(nome_lido, lista);
if(resp == NULL)
printf("Contato nao encontrado!\n\n");
else
printf("%-40s %d\n\n", resp->nome, resp->tel);
break;
case('p'): /* Faz a impressao de todos os contatos em ordem alfabetica */
if(lista != NULL)
imprime(lista);
break;
}
} while(parametro != 'f');
libera(lista);
return 0;
}
void visitabfs(grafo *g){
int i,tempo;
Fila *f=cria(g->tam);
for(i=0;i<g->tam;i++){
if(g->cor[i]==branco) bfs(g,i,f);
}
libera(f);
}
void libera (ArvGen* a)
{
ArvGen* p = a->primeiro_filho;
while (p!=NULL) {
ArvGen* t = p->proximo_irmao;
libera(p);
p = t;
}
free(a);
}
int main()
{
setlocale(LC_ALL,"Portuguese");
tpilha *PILHA = (tpilha *) malloc(sizeof(tpilha));
if(!PILHA){
printf("\nSem memoria disponivel!\n");
exit(1);
}else{
inicia(PILHA);
int opt;
tpilha *aux;
do{
system("cls");
menu();
scanf("%d",&opt);
//opcao(PILHA,opt);
switch(opt){
case 0:
break;
case 1:
push(PILHA);
break;
case 2:
aux= pop(PILHA);
if(aux != NULL)
printf("Retirado: %3d\n\n", aux->num);
break;
case 3:
exibe(PILHA);
break;
case 4:
libera(PILHA);
inicia(PILHA);
printf("Pilha limpa!\n");
break;
}
getch();
}while(opt!=0);
free(PILHA);
return 0;
}
}
int main(){
int * a,*b,*c;
a=(int*)aloca(10);
*a=10;
b=(int*)aloca(11);
// printf("\n%d\n",b);
*b=45;
libera(a);
// printf("\nb %d\n",*b);
c=(int*)aloca(6);
*c=12;
libera(b);
libera(c);
int i=0;
/* for(i=0;i<tammem;i++){
printf("%d",memoria[i]);
}*/
return 0;
}
void separa_filas (Fila* f, Fila* f_pares, Fila* f_impares) {
int i=0;
int v;
No* pf; //percorer fila
pf = f->ini;
while(pf != NULL) { //inserir valores
v = pf->valor;
pf = pf->prox;
if(v % 2 == 0)
insere (f_pares, v);
else
insere (f_impares, v);
}
libera(f);
return;
}
int main()
{
Arv* a = cria('a',
cria('b',
inicializa(),
cria('d', inicializa(), inicializa())
),
cria('c',
cria('e', inicializa(), inicializa()),
cria('f', inicializa(), inicializa())
)
);
imprime(a);
libera(a);
return 0;
}
int main(void){
celula *lista;
celula cabeca;
celula *invertida;
lista = &cabeca;
cabeca.pc = NULL;
ins(1, lista);
ins(2, lista);
ins(3, lista);
ins(4, lista);
imp(lista);
libera(lista);
imp(lista);
}
int main()
{
Lista*lst = inicializada(); //Inicializa NULL
Lista*end1 = inicializada(); //Inicializa NULL
int valor_digitado, valor_retira,n;
lst=insere_ordenado(lst,18); //Insere em ordem os valores
imprime(lst); //imprime o valor
lst=insere_ordenado(lst,90);
imprime(lst);
lst=insere_ordenado(lst,47);
imprime(lst);
printf("Digite uma numero:");
scanf("%d",&n);
lst=insere_ordenado(lst, n);
imprime(lst);
printf("Entre com um numero para busca: \n");
scanf("%d",&valor_digitado);
end1 = busca(lst,valor_digitado); // Busca endereço do numero digitado
if(end1 != NULL)
printf("O valor se encontra no endereço %p.\n",end1);
else
printf("Numero nao encontrado.\n");
printf("Entre com o numero para retirar: ");
scanf("%d",&valor_retira);
retira(lst,valor_retira); // Retira o numero digitado
imprime(lst);
libera(lst); // libera a lista
lst=NULL; // igual lista à NULL
imprime(lst);
return 0;
}
void DestruirMatriz ( LIS_tppLista Tab ) {
LIS_tppLista Col;
PtoTopo* p;
while ( Tab != NULL) {
IrFinalLista( Tab );
Col = (LIS_tppLista) LIS_ObterValor( Tab );
while (Col != NULL) {
IrFinalLista( Col );
p = (PtoTopo*) LIS_ObterValor( Col );
libera( p );
LIS_ExcluirElemento( Col );
IrInicioLista( Col );
}
LIS_ExcluirElemento( Tab );
IrInicioLista( Tab );
}
free ( Tab );
}
int main() {
Hospital *h = (Hospital*)malloc(sizeof(Hospital));
h->total = N;
h->ocupadas = 0;
h->camas = (Cama*)malloc(h->total * sizeof(Cama));
int cama_id =0;
Cama * aux;
for(aux = h->camas + h->ocupadas; aux < h->camas + h->total; aux++)
{
aux->id_cama = cama_id++;
aux->status = 0;
}
int opcion = 0;
while(opcion != 3)
{
printf("Menu\n");
printf("1. Nuevo Paciente\n");
printf("2. Ver Hospital\n");
printf("3. Salir\n");
scanf("%d", &opcion);
if(opcion == 5)
{
printf("Programa terminado");
break;
}
opciones[opcion-1](h);
}
libera(h);
free(h);
}
int main(void){
int i;
struct aluno bixo;
Lista *li;
li = cria();
for (i = 0; i < N; i++){
scanf(" %d %s", &bixo.nusp, bixo.nome);
insere_final(li, bixo);
}
print(li);
scanf(" %d %s", &bixo.nusp, bixo.nome);
insere_inicio(li, bixo);
print(li);
scanf(" %d %s", &bixo.nusp, bixo.nome);
insere_meio(li, bixo, 2);
print(li);
remove_final(li);
print(li);
remove_meio(li, 1);
print(li);
remove_inicio(li);
print(li);
printf("%d\n", tamanho(li));
libera(li);
return 0;
}
int main()
{
Matrix **A, **B;
Matrix *X1, *X2, *X3, *X5, *X10;
char file[] = "./../data/tab1.dat";
A = (Matrix **)aloca(3 * sizeof(Matrix *));
B = (Matrix **)aloca(2 * sizeof(Matrix *));
X1 = PolynomialFitting(file, 17, 1);
X2 = PolynomialFitting(file, 17, 2);
X3 = PolynomialFitting(file, 17, 3);
X5 = PolynomialFitting(file, 17, 5);
X10 = PolynomialFitting(file, 17, 10);
//exemplo pg 230 : resultado ok!
A[0] = X1;
A[1] = X2;
A[2] = X3;
B[0] = X5;
B[1] = X10;
MakeGnuplotMultPlotScript("plot1-a.GNU", \
"./../data/tab1.dat", A, 3, "./../LaTeX/graph/quest1-a");
MakeGnuplotMultPlotScript("plot1-b.GNU", \
"./../data/tab1.dat", B, 2, "./../LaTeX/graph/quest1-b");
printf("O erro da aproximação com n = 1 é : %.6lf\n",\
FindFittingError(X1, file, 17));
printf("O erro da aproximação com n = 2 é : %.6lf\n",\
FindFittingError(X2, file, 17));
printf("O erro da aproximação com n = 3 é : %.6lf\n",\
FindFittingError(X3, file, 17));
printf("O erro da aproximação com n = 5 é : %.6lf\n",\
FindFittingError(X5, file, 17));
printf("O erro da aproximação com n = 10 é : %.6lf\n",\
FindFittingError(X10, file, 17));
print_coeff_table(X1, "tab-quest1-X1.tab");
print_coeff_table(X2, "tab-quest1-X2.tab");
print_coeff_table(X3, "tab-quest1-X3.tab");
print_coeff_table(X5, "tab-quest1-X5.tab");
print_coeff_table(X10, "tab-quest1-X10.tab");
kill_M(&X1);
kill_M(&X2);
kill_M(&X3);
kill_M(&X5);
kill_M(&X10);
libera(A);
libera(B);
EndProgram();
return(0);
}
LISTA *_CreaLista(LISTA *ris, const enum TIPO *t, int len)
#endif
{
int i;
LISTA *ris1;
bool nuova = false;
char err[64];
#ifdef MDEBUG
Allocazione *mem;
#endif
// se non esiste la creo
if (ris == NULL) {
nuova = true;
ris1 = mia_alloc(1, LISTA);
if (ris1 == NULL) {
snprintf(err, 64, "Not enough memory (CreaLISTA # %d, ris1)", __LINE__ - 2);
error(err);
}
ris1->dim = len;
ris1->mia_alloc = len; // inizialmente mia_alloc == len
ris1->dati = NULL;
ris1->tipi = NULL;
ris1->mem = NULL;
ris1->r = false;
}
// altrimenti punto all'esistente
else
ris1 = ris;
#ifdef MDEBUG
// se e` da R e` un errore, perche� non la posso alterare!
if (ris != NULL && ris->r)
error("Una lista proveniente da R non puo` essere alterata! (CreaLISTA)");
// se non l'ho trovata
if (ris1->mem == NULL) {
mem = mia_alloc(1, Allocazione);
if (mem == NULL) {
snprintf(err, 64, "Not enough memory (CreaLISTA # %d, ris1->mem)", __LINE__ - 2);
error(err);
}
fprintf(fp_mdbg_lst, "%d_lst - allocazione della lista '%s'[%d] (%p) dalla linea %s # %d\n", g_list_length(allocLst) + 1, nome, ris1->dim, ris1, nomefile, linea);
mem->indir = (size_t) ris1;
_CREAstr(mem->nome, nome);
_CREAstr(mem->file_da, nomefile);
_CREAstr(mem->file_a, "");
mem->linea_da = linea;
mem->linea_a = 0;
mem->max_dim1 = len;
mem->rialloc = 0;
mem->in_uso = 0;
_CREAstr(mem->file_prima, "");
mem->prima_linea = 0;
_CREAstr(mem->file_ultima, "");
mem->ultima_linea = 0;
allocLst = g_list_append(allocLst, mem);
mem->indx = g_list_length(allocLst);
_stampa_lista_lst("allocLst+: ", allocLst);
ris1->mem = g_list_last(allocLst);
}
else {
mem = (Allocazione *) ris1->mem->data;
if (mem->linea_da > 0 && mem->linea_a == 0) {
fprintf(fp_mdbg_lst, "%d_lst - la lista '%s' (linea %s # %d) esiste gia`: e` stata allocata alla linea %s # %d\n\n", mem->indx, nome, nomefile, linea, mem->file_da->str, mem->linea_da);
}
}
// se non e` abbastanza grande segnalo il fatto (la ridimensionero` effettivamente solo alla fine, nel codice comune)
if (ris1->mia_alloc < len) {
fprintf(fp_mdbg_lst, "*** la lista '%s' verra` riallocata passando da %d a %d (%d riallocazione/i, finora)\n\n", nome, ris1->mia_alloc, ris1->mia_alloc * 2 + len, mem->rialloc + 1);
mem->rialloc++;
}
#endif
CONTROLLA(len >= 0);
if (len > 0) {
// se non e` abbastanza grande la rialloco raddoppiando mia_alloc (puo` capitare solo se la sto riutilizzando)
if (ris1->mia_alloc < len) {
if (ris1->mia_alloc > 0) {
warning("La lista sara` riallocata e tutti gli elementi saranno cancellati!\n");
CancellaLISTA(ris1, true);
libera(ris1->dati);
libera(ris1->tipi);
ris1->dati = NULL;
ris1->tipi = NULL;
}
ris1->mia_alloc = ris1->mia_alloc * 2 + len;
ris1->dati = mia_alloc((ris1->mia_alloc), union Dati);
ris1->tipi = mia_alloc((ris1->mia_alloc), enum TIPO);
}
// se non esiste la alloco
else if (ris1->dati == NULL || ris1->tipi == NULL) {
ris1->dati = mia_alloc(len, union Dati);
ris1->tipi = mia_alloc(len, enum TIPO);
}
int main()
{
// Inteiros auxiliares
int i, j, x, y, inicial;
// Recebe o 'n' inicial
scanf("%d", &n);
// Recebe o 'm' inicial
scanf("%d", &m);
// Laço principal
while (n != 0 || m != 0)
{
max = 0;
// Reinicia o vetor de estado dos vértices e a lista de adjacencia
for (i = 0; i < n; i++)
{
estado[i] = INEXPLORADO;
adjacencia[i] = NULL;
}
// Recebe o valor de cada vertice
for (i = 0; i < n; i++)
{
scanf("%d", &valor[i]);
}
// Recebe as 'm' relações entre os vértices
for (i = 0; i < m; i++)
{
scanf("%d", &x);
scanf("%d", &y);
adjacencia[x] = insereElem(adjacencia[x], y);
}
// Encontra quais são os vértices que não são dependentes de nenhum outro
// A partir desses, chama a recursão para encontrar o maior caminho
if (n == 1)
{
max = valor[0];
}
else{
for (i = 0; i < n; i++)
{
if (estado[i] == INEXPLORADO)
{
inicial = 1;
for (j = 0; j < n; j++)
{
if (possuiElemento(adjacencia[j], i))
{
inicial = 0;
break;
}
}
if (inicial)
{
exploraVertice(adjacencia[i], i);
}
}
}
}
// Imprime o resultado
printf("%d\n", max);
for (i = 0; i < n; i++)
{
libera(adjacencia[i]);
}
// Recebe um novo 'n'
scanf("%d", &n);
// Recebe um novo 'm'
scanf("%d", &m);
}
return 0;
}
int main()
{
char text[999];
char ch;
int i=0,j=0,k=0;
inf_t inf[10]; inf_t org[10];
// leitura do arquivo
FILE *info_alunos;
info_alunos=fopen("infos.txt","r");
if(info_alunos == NULL)
printf("Erro, nao foi possivel abrir o arquivo\n");
else
{
while((ch=fgetc(info_alunos))!= EOF)
{
text[i]=ch;
i++;
}
}
text[i]='\0';
fclose(info_alunos);
i=k=0;
j=0;
for(i=0;i<strlen(text);)
{
if(text[i]!=',')
{
inf[j].nome[k]=text[i];
k++;
}
if(text[i]==',')
{
inf[j].nome[k]='\0';
inf[j].nota=text[i+1]-48;
j++;
k=0;
i++;i++;
}
i++;
}
j=9;
for(i=0;i<10;i++)//swap de indices..
{
strcpy(org[j].nome,inf[i].nome);
org[j].nota=inf[i].nota;
j--;
}
// fim leitura do arquivo
no_t *lista_nota;
aluno_t *lista_aluno;
lista_nota = (no_t*)malloc(sizeof(no_t));
lista_nota->prox=NULL;
lista_aluno = (aluno_t*)malloc(sizeof(aluno_t));
lista_aluno->prox=NULL;
aluno_t *gambiarra;
for(i=0;i<10;i++)
{
gambiarra = insertt(lista_aluno,org[i].nome);
insert(lista_nota,org[i].nota,gambiarra);
/*
if(i==5)//para remover um elemento da lista basta remover a nota.
{
retira(lista_nota);
//insert(lista_nota,org[i].nota,gambiarra);
}*/
}
//exibe(lista_nota,lista_aluno);
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// TESTE FINAL DO QUE O EXERCICIO PEDE. UMA LISTA DE NOTAS E UMA LISTA DE ALUNOS
// A LISTA DE NOTAS APONTA PRA RESPECTIVA LISTA DE ALUNO COM A NOTA.
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
//printf("\n");
no_t *tmp;
tmp = lista_nota->prox;
while(tmp != NULL)
{
printf("%s: %.2f",tmp->aluno->nome,tmp->nota);
tmp = tmp->prox;
printf("\n");
}
libera_aluno(lista_aluno);
libera(lista_nota);
return 0;
}
void libera_calc (Calc* c)
{
libera(c->p);
free(c);
}
