Estrutura de Dados em C

Tentem entender o código… Depois é só sair usando!
Essa versão pode conter más práticas de programação rs.. se quiserem a mais nova é só me contatar!!


Fila

/*
Fila para inteiros/char em C

by William Antônio Siqueira
Informática com Ênfase em Banco de Dados
FATEC SJC 2009

Long Live To C Language
*/

#ifndef ___STDIO_H_
#include
#endif
#ifndef FIM
#define FIM -1
#endif
#ifndef _FILA
#define _FILA fila
#endif

typedef struct _fila{
int *dados, s,t,tamanho;
} fila;

/*
Recebe um ponteiro para o tipo Fila e o tamanho dessa fila.
Retorna NULL caso haja erro na alocação da Fila
*/
int novaFila(fila *pFila,int tamanho){
pFila->tamanho = tamanho;
pFila->s=0;pFila->t=0;
return (pFila->dados = malloc(tamanho * sizeof(int)));
}

/*
“Desinfileira” um elemento
*/
int dequeue(fila *pFila){
if(pFila->s==pFila->t){
return -1;
}
else
return pFila->dados[pFila->s++];
}

/*
Enfileira um elemento
*/
int queue(fila *pFila, int elemento){
if(pFila->t == pFila->tamanho){
return;
}
return pFila->dados[pFila->t++] = elemento;
}

/*
Faz a fila retornar para o inicio, mas perde todos os dados salvos
*/
void zeraFila(fila *pFila){
pFila->s=0;pFila->t=0;
}

/*
Imprime a fila sem mexer nos elementos da mesma
*/
void imprimirFila(fila *pFila){
int i;
for(i=pFila->s;it;i++) printf(“%d “,pFila->dados[i]);
printf(“\n”);
}

/*
Compara se duas Filas são iguais, sem mexer no conteúdo das mesmas
*/
int comparaFila(fila *pFila1, fila *pFila2){
int i, j;
for(i=pFila1->s, j=pFila2->s;
it && jt;
i++, j++){
if(pFila1->dados[i] != pFila2->dados[j])
return 0;
}
return pFila1->t == i
&&
pFila2->t == j;
}


Pilha


/*
Pilha para inteiros/char em C

by William Antônio Siqueira
Informática com Ênfase em Banco de Dados
FATEC SJC 2009

Long Live To C Language
*/

#ifndef ___STDIO_H_
#include
#endif

#ifndef _PILHA
#define _PILHA pilha
#endif

//Constante que indica o fim da Pilha (Stack UnderFlow)
#ifndef FIM
#define FIM -1
#endif

typedef struct _pilha{
int *dados, tamanho, pos;
}pilha;

/*
Recebe um ponteiro para pilha, inicializa as variáveis e aloca memória
Retorna NULL caso haja erro na alocação
*/
int novaPilha(pilha *pPilha, int tamanho){
pPilha->pos = 0;
pPilha->tamanho = tamanho;
return (pPilha->dados = malloc(tamanho * sizeof(int)));
}

/*
Remove um elementos da Pilha
*/
int pop(pilha *pPilha){
if(!pPilha->pos)
return FIM;
else
return pPilha->dados[--pPilha->pos];
}

/*
Empurra um elemento da Pilha
*/
void push(pilha *pPilha, int elemento){
if(pPilha->pos == pPilha->tamanho)
printf("Pilha cheia!\n");
else
pPilha->dados[pPilha->pos++] = elemento;
}

/*
Esvazia todos os elementos da Pilha, imprimindo o resultado
*/
void esvaziaPilha(pilha *pPilha){
int x;
while(x = pop(pPilha)) printf("%d ", x);
printf("\n");
}

/*
Imprime a pilha sem mexer nos elementos que já foram colocados
*/
void imprimirPilha(pilha *pPilha){
int i;
for(i=pPilha->pos-1;i>-1;i--)
printf("%d ", pPilha->dados[i]);
printf("\n");
}



Caso o link esteja quebrado, só me contatar.

Futuramente eu modificarei aqui com uma teoria sobre essas estruturas.

Deixe uma resposta

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: