add U5
This commit is contained in:
KleberSouza
parent
c5981b2b7a
commit
3932d43f9b
|
|
@ -0,0 +1,32 @@
|
|||
#ifndef CELULA_H
|
||||
#define CELULA_H
|
||||
//=============================================================================
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
//=============================================================================
|
||||
typedef struct Celula{
|
||||
int elemento;
|
||||
struct Celula *prox;
|
||||
}Celula;
|
||||
//=============================================================================
|
||||
Celula* new_celula(int elemento){
|
||||
Celula *temp = (Celula*)malloc(sizeof(Celula));
|
||||
temp->elemento = elemento;
|
||||
temp->prox = NULL;
|
||||
return temp;
|
||||
}
|
||||
//=============================================================================
|
||||
typedef struct CelulaDupla{
|
||||
int elemento;
|
||||
struct CelulaDupla *prox, *ant;
|
||||
}CelulaDupla;
|
||||
//=============================================================================
|
||||
CelulaDupla* new_celula_dupla(int elemento){
|
||||
CelulaDupla *temp = (CelulaDupla*)malloc(sizeof(CelulaDupla));
|
||||
temp->elemento = elemento;
|
||||
temp->ant = NULL;
|
||||
temp->prox = NULL;
|
||||
return temp;
|
||||
}
|
||||
//=============================================================================
|
||||
#endif
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
#ifndef FILA_H
|
||||
#define FILA_H
|
||||
//=============================================================================
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <limits.h>
|
||||
#include "celula.h"
|
||||
//=============================================================================
|
||||
typedef struct Fila{
|
||||
struct Celula *primeiro, *ultimo;
|
||||
int size;
|
||||
} Fila;
|
||||
//=============================================================================
|
||||
Fila new_fila(){
|
||||
Fila temp;
|
||||
temp.primeiro = temp.ultimo = new_celula(-1);
|
||||
temp.size = 0;
|
||||
return temp;
|
||||
}
|
||||
//=============================================================================
|
||||
int size_fila(Fila *f){
|
||||
return f->size;
|
||||
}
|
||||
//=============================================================================
|
||||
void enqueue_fila(Fila *f, int elemento){
|
||||
f->ultimo->prox = new_celula(elemento);
|
||||
f->ultimo = f->ultimo->prox;
|
||||
f->size++;
|
||||
}
|
||||
//=============================================================================
|
||||
int dequeue_fila(Fila *f){
|
||||
|
||||
if (f->primeiro == f->ultimo){
|
||||
printf("\nA fila esta vazia!\n");
|
||||
return INT_MIN;
|
||||
}
|
||||
|
||||
Celula *temp = f->primeiro;
|
||||
f->primeiro = f->primeiro->prox;
|
||||
f->size--;
|
||||
free(temp);
|
||||
return f->primeiro->elemento;
|
||||
}
|
||||
//=============================================================================
|
||||
void print_fila(Fila *f){
|
||||
Celula *i;
|
||||
printf("[");
|
||||
for (i = f->primeiro->prox; i != NULL; i = i->prox)
|
||||
{
|
||||
printf("%d, ", i->elemento);
|
||||
}
|
||||
printf("] \n");
|
||||
}
|
||||
//=============================================================================
|
||||
void delete_fila(Fila *f){
|
||||
while(f->size > 0)
|
||||
dequeue_fila(f);
|
||||
free(f->primeiro);
|
||||
}
|
||||
//=============================================================================
|
||||
#endif
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include "fila.h"
|
||||
//=============================================================================
|
||||
int main() {
|
||||
|
||||
Fila f;
|
||||
int i, x1, x2, x3;
|
||||
printf("==== FILA FLEXIVEL ====\n");
|
||||
|
||||
f = new_fila();
|
||||
|
||||
for(i=0; i < 10; i++)
|
||||
enqueue_fila(&f, i);
|
||||
|
||||
printf("Apos inserrir os dados: \n");
|
||||
print_fila(&f);
|
||||
|
||||
x1 = dequeue_fila(&f);
|
||||
x2 = dequeue_fila(&f);
|
||||
x3 = dequeue_fila(&f);
|
||||
|
||||
printf("Apos as remocoes (%d, %d, %d) \n", x1, x2, x3);
|
||||
print_fila(&f);
|
||||
|
||||
delete_fila(&f);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,123 @@
|
|||
#ifndef LISTA_H
|
||||
#define LISTA_H
|
||||
//=============================================================================
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <limits.h>
|
||||
#include "celula.h"
|
||||
//=============================================================================
|
||||
typedef struct Lista{
|
||||
struct Celula *primeiro, *ultimo;
|
||||
int size;
|
||||
} Lista;
|
||||
//=============================================================================
|
||||
Lista new_lista(){
|
||||
Lista temp;
|
||||
temp.primeiro = temp.ultimo = new_celula(-1);
|
||||
temp.size = 0;
|
||||
return temp;
|
||||
}
|
||||
//=============================================================================
|
||||
int size_lista(Lista *l){
|
||||
return l->size;
|
||||
}
|
||||
//=============================================================================
|
||||
void insert_begin(Lista *l, int elemento){
|
||||
|
||||
Celula *temp = new_celula(-1);
|
||||
temp->prox = l->primeiro;
|
||||
|
||||
l->primeiro->elemento = elemento;
|
||||
l->primeiro = temp;
|
||||
l->size++;
|
||||
}
|
||||
//=============================================================================
|
||||
void insert_end(Lista *l, int elemento){
|
||||
l->ultimo->prox = new_celula(elemento);
|
||||
l->ultimo = l->ultimo->prox;
|
||||
l->size++;
|
||||
}
|
||||
//=============================================================================
|
||||
void insert_at(Lista *l, int elemento, int pos){
|
||||
|
||||
if(pos < 0 || pos > l->size)
|
||||
printf("Erro ao tentar inserir na posicao (%d/ tamanho = %d) invalida!", pos, l->size);
|
||||
else if (pos == 0)
|
||||
insert_begin(l, elemento);
|
||||
else if (pos == l->size)
|
||||
insert_end(l, elemento);
|
||||
else{
|
||||
|
||||
Celula *ant = l->primeiro;
|
||||
for(int i=0; i<pos;i++)
|
||||
ant = ant->prox;
|
||||
|
||||
Celula *temp = new_celula(elemento);
|
||||
temp->prox = ant->prox;
|
||||
ant->prox = temp;
|
||||
l->size++;
|
||||
}
|
||||
}
|
||||
//=============================================================================
|
||||
int remove_at(Lista *l, int pos){
|
||||
|
||||
if(l->primeiro == l->ultimo){
|
||||
printf("\nA lista esta vazia!\n");
|
||||
return INT_MIN;
|
||||
}else if(pos < 0 || pos > l->size-1)
|
||||
printf("Erro ao tentar remover item da posicao (%d/ tamanho = %d) invalida!", pos, l->size);
|
||||
else{
|
||||
|
||||
Celula *ant = l->primeiro;
|
||||
for(int i=0; i<pos;i++)
|
||||
ant = ant->prox;
|
||||
|
||||
Celula *temp = ant->prox;
|
||||
int elemento = temp->elemento;
|
||||
|
||||
ant->prox = temp->prox;
|
||||
free(temp);
|
||||
|
||||
if(pos == l->size-1)
|
||||
l->ultimo = ant;
|
||||
|
||||
l->size--;
|
||||
|
||||
return elemento;
|
||||
}
|
||||
}
|
||||
//=============================================================================
|
||||
int remove_begin(Lista *l){
|
||||
return remove_at(l, 0);
|
||||
}
|
||||
//=============================================================================
|
||||
int remove_end(Lista *l){
|
||||
return remove_at(l, l->size-1);
|
||||
}
|
||||
//=============================================================================
|
||||
bool pesquisar_lista(Lista *l, int elemento){
|
||||
Celula *i;
|
||||
for (i = l->primeiro->prox; i != NULL; i = i->prox)
|
||||
if(i->elemento == elemento)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
//=============================================================================
|
||||
void print_lista(Lista *l){
|
||||
Celula *i;
|
||||
printf("[");
|
||||
for (i = l->primeiro->prox; i != NULL; i = i->prox)
|
||||
{
|
||||
printf("%d, ", i->elemento);
|
||||
}
|
||||
printf("] \n");
|
||||
}
|
||||
//=============================================================================
|
||||
void delete_lista(Lista *l){
|
||||
while(l->size > 0)
|
||||
remove_at(l,0);
|
||||
free(l->primeiro);
|
||||
}
|
||||
//=============================================================================
|
||||
#endif
|
||||
|
|
@ -0,0 +1,152 @@
|
|||
#ifndef LISTADUPLA_H
|
||||
#define LISTADUPLA_H
|
||||
//=============================================================================
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <limits.h>
|
||||
#include "celula.h"
|
||||
//=============================================================================
|
||||
typedef struct ListaDupla{
|
||||
struct CelulaDupla *primeiro, *ultimo;
|
||||
int size;
|
||||
} ListaDupla;
|
||||
//=============================================================================
|
||||
ListaDupla new_lista_dupla(){
|
||||
ListaDupla temp;
|
||||
temp.primeiro = temp.ultimo = new_celula_dupla(-1);
|
||||
temp.size = 0;
|
||||
return temp;
|
||||
}
|
||||
//=============================================================================
|
||||
int size_lista_dupla(ListaDupla *l){
|
||||
return l->size;
|
||||
}
|
||||
//=============================================================================
|
||||
void insert_begin_dupla(ListaDupla *l, int elemento){
|
||||
|
||||
CelulaDupla *temp = new_celula_dupla(-1);
|
||||
temp->prox = l->primeiro;
|
||||
|
||||
l->primeiro->elemento = elemento;
|
||||
l->primeiro->ant = temp;
|
||||
l->primeiro = temp;
|
||||
l->size++;
|
||||
}
|
||||
//=============================================================================
|
||||
void insert_end_dupla(ListaDupla *l, int elemento){
|
||||
l->ultimo->prox = new_celula_dupla(elemento);
|
||||
l->ultimo->prox->ant = l->ultimo;
|
||||
l->ultimo = l->ultimo->prox;
|
||||
l->size++;
|
||||
}
|
||||
//=============================================================================
|
||||
void insert_at_dupla(ListaDupla *l, int elemento, int pos){
|
||||
|
||||
if(pos < 0 || pos > l->size)
|
||||
printf("Erro ao tentar inserir na posicao (%d/ tamanho = %d) invalida!", pos, l->size);
|
||||
else if (pos == 0)
|
||||
insert_begin_dupla(l, elemento);
|
||||
else if (pos == l->size)
|
||||
insert_end_dupla(l, elemento);
|
||||
else{
|
||||
|
||||
CelulaDupla *ant = l->primeiro;
|
||||
for(int i=0; i<pos;i++)
|
||||
ant = ant->prox;
|
||||
|
||||
CelulaDupla *temp = new_celula_dupla(elemento);
|
||||
temp->prox = ant->prox;
|
||||
temp->prox->ant = temp;
|
||||
temp->ant = ant;
|
||||
ant->prox = temp;
|
||||
l->size++;
|
||||
}
|
||||
}
|
||||
//=============================================================================
|
||||
int remove_end_dupla(ListaDupla *l){
|
||||
|
||||
if(l->primeiro == l->ultimo){
|
||||
printf("\nA lista esta vazia!\n");
|
||||
return INT_MIN;
|
||||
}
|
||||
|
||||
CelulaDupla *temp = l->ultimo;
|
||||
int elemento = temp->elemento;
|
||||
|
||||
l->ultimo = l->ultimo->ant;
|
||||
l->ultimo->prox = NULL;
|
||||
l->size--;
|
||||
|
||||
free(temp);
|
||||
|
||||
return elemento;
|
||||
}
|
||||
//=============================================================================
|
||||
int remove_at_dupla(ListaDupla *l, int pos){
|
||||
|
||||
if(l->primeiro == l->ultimo){
|
||||
printf("\nA lista esta vazia!\n");
|
||||
return INT_MIN;
|
||||
}else if(pos < 0 || pos > l->size-1)
|
||||
printf("Erro ao tentar remover item da posicao (%d/ tamanho = %d) invalida!", pos, l->size);
|
||||
else if(pos == l->size-1)
|
||||
remove_end_dupla(l);
|
||||
else{
|
||||
|
||||
CelulaDupla *ant = l->primeiro;
|
||||
for(int i=0; i<pos;i++)
|
||||
ant = ant->prox;
|
||||
|
||||
CelulaDupla *temp = ant->prox;
|
||||
int elemento = temp->elemento;
|
||||
|
||||
temp->prox->ant = ant;
|
||||
ant->prox = temp->prox;
|
||||
free(temp);
|
||||
|
||||
l->size--;
|
||||
|
||||
return elemento;
|
||||
}
|
||||
}
|
||||
//=============================================================================
|
||||
int remove_begin_dupla(ListaDupla *l){
|
||||
return remove_at_dupla(l, 0);
|
||||
}
|
||||
//=============================================================================
|
||||
bool pesquisar_lista_dupla(ListaDupla *l, int elemento){
|
||||
CelulaDupla *i;
|
||||
for (i = l->primeiro->prox; i != NULL; i = i->prox)
|
||||
if(i->elemento == elemento)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
//=============================================================================
|
||||
void print_lista_dupla(ListaDupla *l){
|
||||
CelulaDupla *i;
|
||||
printf("[");
|
||||
for (i = l->primeiro->prox; i != NULL; i = i->prox)
|
||||
{
|
||||
printf("%d, ", i->elemento);
|
||||
}
|
||||
printf("] \n");
|
||||
}
|
||||
//=============================================================================
|
||||
void print_lista_dupla_inverso(ListaDupla *l){
|
||||
CelulaDupla *i;
|
||||
printf("[");
|
||||
for (i = l->ultimo; i != l->primeiro; i = i->ant)
|
||||
{
|
||||
printf("%d, ", i->elemento);
|
||||
}
|
||||
printf("] \n");
|
||||
}
|
||||
//=============================================================================
|
||||
void delete_lista_dupla(ListaDupla *l){
|
||||
while(l->size > 0)
|
||||
remove_at_dupla(l,0);
|
||||
free(l->primeiro);
|
||||
}
|
||||
//=============================================================================
|
||||
#endif
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include "lista_dupla.h"
|
||||
//=============================================================================
|
||||
int main() {
|
||||
|
||||
ListaDupla l;
|
||||
int i, x1, x2, x3;
|
||||
printf("==== LISTA FLEXIVEL ====\n");
|
||||
|
||||
l = new_lista_dupla();
|
||||
|
||||
for(i=0; i < 5; i++)
|
||||
insert_end_dupla(&l, i);
|
||||
|
||||
printf("Apos inserir os dados: \n");
|
||||
print_lista_dupla(&l);
|
||||
print_lista_dupla_inverso(&l);
|
||||
|
||||
printf("Apos inserir no inicio: \n");
|
||||
insert_begin_dupla(&l, i++);
|
||||
print_lista_dupla(&l);
|
||||
print_lista_dupla_inverso(&l);
|
||||
|
||||
printf("Apos inserir no final: \n");
|
||||
insert_end_dupla(&l, i++);
|
||||
print_lista_dupla(&l);
|
||||
print_lista_dupla_inverso(&l);
|
||||
|
||||
printf("Apos inserir na posicao 4: \n");
|
||||
insert_at_dupla(&l, i++, 4);
|
||||
print_lista_dupla(&l);
|
||||
print_lista_dupla_inverso(&l);
|
||||
|
||||
printf("Apos remover no inicio: \n");
|
||||
x1 = remove_begin_dupla(&l);
|
||||
print_lista_dupla(&l);
|
||||
print_lista_dupla_inverso(&l);
|
||||
|
||||
printf("Apos remover no final: \n");
|
||||
x1 = remove_end_dupla(&l);
|
||||
print_lista_dupla(&l);
|
||||
print_lista_dupla_inverso(&l);
|
||||
|
||||
printf("Apos remover na posicao 2: \n");
|
||||
x1 = remove_at_dupla(&l, 2);
|
||||
print_lista_dupla(&l);
|
||||
print_lista_dupla_inverso(&l);
|
||||
|
||||
delete_lista_dupla(&l);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#include "lista.h"
|
||||
//=============================================================================
|
||||
int main() {
|
||||
|
||||
Lista l;
|
||||
int i, x1, x2, x3;
|
||||
printf("==== LISTA FLEXIVEL ====\n");
|
||||
|
||||
l = new_lista();
|
||||
|
||||
for(i=0; i < 5; i++)
|
||||
insert_end(&l, i);
|
||||
|
||||
printf("Apos inserir os dados: \n");
|
||||
print_lista(&l);
|
||||
|
||||
printf("Apos inserir no inicio: \n");
|
||||
insert_begin(&l, i++);
|
||||
print_lista(&l);
|
||||
|
||||
printf("Apos inserir no final: \n");
|
||||
insert_end(&l, i++);
|
||||
print_lista(&l);
|
||||
|
||||
printf("Apos inserir na posicao 4: \n");
|
||||
insert_at(&l, i++, 4);
|
||||
print_lista(&l);
|
||||
|
||||
printf("Apos remover no inicio: \n");
|
||||
x1 = remove_begin(&l);
|
||||
print_lista(&l);
|
||||
|
||||
printf("Apos remover no final: \n");
|
||||
x1 = remove_end(&l);
|
||||
print_lista(&l);
|
||||
|
||||
printf("Apos remover na posicao 2: \n");
|
||||
x1 = remove_at(&l, 2);
|
||||
print_lista(&l);
|
||||
|
||||
delete_lista(&l);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
#ifndef PILHA_H
|
||||
#define PILHA_H
|
||||
//=============================================================================
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <limits.h>
|
||||
#include "celula.h"
|
||||
//=============================================================================
|
||||
typedef struct Pilha{
|
||||
struct Celula *topo;
|
||||
int size;
|
||||
} Pilha;
|
||||
//=============================================================================
|
||||
Pilha new_pilha(){
|
||||
Pilha temp;
|
||||
temp.topo = NULL;
|
||||
temp.size = 0;
|
||||
return temp;
|
||||
}
|
||||
//=============================================================================
|
||||
int size_pilha(Pilha *p){
|
||||
return p->size;
|
||||
}
|
||||
//=============================================================================
|
||||
void push_pilha(Pilha *p, int elemento){
|
||||
Celula *temp = new_celula(elemento);
|
||||
temp->prox = p->topo;
|
||||
p->topo = temp;
|
||||
p->size++;
|
||||
}
|
||||
//=============================================================================
|
||||
int pop_pilha(Pilha *p){
|
||||
if (p->topo == NULL){
|
||||
printf("\nA pilha esta vazia!\n");
|
||||
return INT_MIN;
|
||||
}
|
||||
int elemento = p->topo->elemento;
|
||||
Celula *temp = p->topo;
|
||||
p->topo = p->topo->prox;
|
||||
p->size--;
|
||||
free(temp);
|
||||
return elemento;
|
||||
}
|
||||
//=============================================================================
|
||||
void print_pilha(Pilha *p){
|
||||
Celula *i;
|
||||
printf("[");
|
||||
for (i = p->topo; i != NULL; i = i->prox)
|
||||
{
|
||||
printf("%d, ", i->elemento);
|
||||
}
|
||||
printf("] \n");
|
||||
}
|
||||
//=============================================================================
|
||||
void delete_pilha(Pilha *p){
|
||||
while(p->size > 0)
|
||||
pop_pilha(p);
|
||||
}
|
||||
//=============================================================================
|
||||
#endif
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include "pilha.h"
|
||||
//=============================================================================
|
||||
int main() {
|
||||
|
||||
Pilha p;
|
||||
int i, x1, x2, x3;
|
||||
printf("==== PILHA FLEXIVEL ====\n");
|
||||
|
||||
p = new_pilha();
|
||||
|
||||
for(i=0; i < 10; i++)
|
||||
push_pilha(&p, i);
|
||||
|
||||
printf("Apos inserrir os dados: \n");
|
||||
print_pilha(&p);
|
||||
|
||||
x1 = pop_pilha(&p);
|
||||
x2 = pop_pilha(&p);
|
||||
x3 = pop_pilha(&p);
|
||||
|
||||
printf("Apos as remocoes (%d, %d, %d) \n", x1, x2, x3);
|
||||
print_pilha(&p);
|
||||
|
||||
delete_pilha(&p);
|
||||
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue