#include <stdio.

h>
#include <stdlib.h>
/*******************************************************
********************************************************
************** INICIO FUNO QUESTO Q1 ************
********************************************************
*******************************************************/
TLista* i_p (TLista *l){
TLista* p = l;
TLista* resultado;
resultado = inicializa();
while(p){
if((p->info%2) == 1)
resultado = insere_fim(resultado, p->info);
p = p->prox;
}
Lista* p = l;
while(p){
if((p->info%2) == 0)
resultado = insere_fim(resultado, p->info);
p = p->prox;
}
return resultado;
}
/*******************************************************
********************************************************
************** TERMINO FUNO QUESTO Q1 **********
********************************************************
*******************************************************/
/*------------------------------------------------------------------------------*/
/*******************************************************
********************************************************
************** INICIO FUNO QUESTO Q2 ************
********************************************************
*******************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
typedef struct lista{
int mat;
char nome[81];
float cr;
struct lista *prox;
} TLista;
*/
//retorna 0 se forem iguais e 1 se forem diferentes

int igual (TLista *l1, TLista *l2){

TLista *p, *q;
p = l1;
q = l2;
while((p)&&(q)){
if ((p->mat == q->mat)&&(p->cr == q->cr) && (!strcmp(p->nome, q>nome)))
{
p = p->prox;
q = q->prox;
}
else
return 0;
}
if((!p)&&(!q)){
return 1;
}
if((!p)){
return 0;
}
if((!q)){
return 0;
}
}

/*******************************************************
********************************************************
************** TERMINO FUNO QUESTO Q2 **********
********************************************************
*******************************************************/

/*------------------------------------------------------------------------------*/

/*******************************************************
********************************************************
************** INICIO FUNO QUESTO Q3 ************
********************************************************
*******************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

struct lista{
int info;
struct lista *prox;
}TLista;
void junta_listas (TLista* l1, TLista* l2){
TLista *q, *p, *ant;
p = l1;
q = l2;
//se a lista l1 for vazia
//if (!p)
//{
while(q)
{
p = insere_fim (p, q->info);
q = q->prox;
}
//}

/*******************************************************
********************************************************
************* TERMINO FUNO QUESTO Q3 ***********
********************************************************
*******************************************************/

/*------------------------------------------------------------------------------*/
/*******************************************************
********************************************************
************** INICIO FUNO QUESTO Q4 ************
********************************************************
*******************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/*
typedef struct lista{
int mat;
char nome[81];

float cr;
struct lista *prox;
} Tlista;
*/
/*
typedef struct pilha TPilha;
TPilha * inicializa (void);
void push (TPilha *p, TFila *f, int m, char * nome, float c);
TNO* pop (TPilha *p);
void libera (TPilha *p);
int vazia (TPilha *p);
*/
/*
typedef struct fila TFila;
TFila* inicializa (void);
TFila* insere (TFila *f, int m, char * nome, float c);
TNO* retira (TFila *f);
void libera (TFila *f);
int vazia (TFila *f);
*/
typedef struct no{
int mat;
char nome[81];
float cr;
}TNO;

//retorna 1 se so invertidas e 0, caso contrrio

int Contrario (TLista *l1, TLista *l2)
{
TLista *p = l1, q = l2;
TPilha *pilha;
TFila *fila;
TNO *t1, *t2;
pilha = inicializa_pilha();
fila = inicializa_fila();
while(p)
{
pilha = push(pilha, p->mat, p->nome, p->cr);
p = p->prox;
}
while(q)
{
fila = insere(fila, q->mat, q->nome, q->cr);
q = q->prox;
}
while ((!vazia_fila(fila)) && (!vazia_pilha(pilha)))
{
t1 = retira_fila(fila);
t2 = pop(pilha);

if ((t1->mat == t2->mat)&&(t1->cr == t2->cr) && (!strcmp(t1->nom

e, t2->nome)))
{
printf("Por enquanto est passano\n");
}
else
{
free(t1);
free(t2);
libera_fila(fila);
libera_pilha(pilha);
return 0;
}
}
if ((vazia_fila(fila)) && (vazia_pilha(pilha)))
{
free(t1);
free(t2);
libera_fila(fila);
libera_pilha(pilha);
return 0;
}
else
{
free(t1);
free(t2);
libera_fila(fila);
libera_pilha(pilha);
return 1;
}
}

/*******************************************************
********************************************************
************ TERMINO FUNO QUESTO Q4 ************
********************************************************
*******************************************************/
/*------------------------------------------------------------------------------*/
/*******************************************************
********************************************************
************* INICIO FUNO QUESTO Q5 *************
********************************************************
*******************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

/*
typedef struct pilha TPilha;
TPilha * inicializa (void);
void push (TPilha *p, int elem);
int pop (TPilha *p);
void libera (TPilha *p);
int vazia (TPilha *p);
*/
TPilha* copia (TPilha* p)
{
int elemento;
TPilha *aux, result;
aux = inicializa();
result = inicializa();
while(!vazia(p))
{
push(aux, pop(p));
}
while(!vazia(p))
{
elemento = pop(aux);
push(p, elemento);
push(inicializa, elemento);
}
libera(aux);
return result;
}

/*******************************************************
********************************************************
************ TERMINO FUNO QUESTO Q5 ************
********************************************************
*******************************************************/
/*------------------------------------------------------------------------------*/
/*******************************************************
********************************************************
************* INICIO FUNO QUESTO Q6 *************
********************************************************
*******************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

/*
typedef struct fila TFila;
TFila* inicializa (void);
TFila* insere (TFila *f, int elem);
int retira (TFila *f);
void libera (TFila *f);
int vazia (TFila *f);
*/
void separa_filas(TFila* f, TFila* pares, TFila* impares)
{
TFila *aux;
aux = inicializa();
int x;
while (!vazia(f))
{
x = retira(f);
aux = insere(aux, x);
}
while (!vazia(aux))
{
x = retira(aux);
f = insere(f, x);
if ((x%2) == 1)
{
impares = insere(impares, x);
}
else
{
pares = insere(pares, x);
}
}
libera(aux);
}

/*******************************************************
********************************************************
************ TERMINO FUNO QUESTO Q6 ************
********************************************************
*******************************************************/
/*------------------------------------------------------------------------------*/
/*******************************************************
********************************************************
************ INICIO FUNO QUESTO Q7 ************
********************************************************
*******************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/*
typedef struct fila TFila;
TFila* inicializa (void);
TFila* insere (TFila *f, int elem);
int retira (TFila *f);
void libera (TFila *f);
int vazia (TFila *f);
*/
TFila* copia (TFila* p)
{
int x;
TFila *aux, *copy;
while(!vazia(p))
{
x = retira(p);
aux = insere (aux, x);
}
while(!vazia(aux))
{
x = retira(aux);
p = insere (p, x);
copy = insere (copy, x);
}
libera(aux);
return copy;
}

/*******************************************************
********************************************************
************ TERMINO FUNO QUESTO Q7 ************
********************************************************
*******************************************************/
/*------------------------------------------------------------------------------*/
/*******************************************************
********************************************************
************ INICIO FUNO QUESTO Q8 ************
********************************************************
*******************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

/*
typedef struct pilha TPilha;
TPilha * inicializa (void);
void push (TPilha *p, int elem);
int pop (TPilha *p);
void libera (TPilha *p);
int vazia (TPilha *p);
*/
void separa_pilhas(TPilha* f, TPilha* pares, TPilha* impares)
{
int x;
TPilha *aux;// *aux1, *aux2;
aux = inicializa();
//aux1 = inicializa();
//aux2 = inicializa();
while(!vazia(f))
{
x = pop(f);
push(aux, x);
}
/*
while(!vazia(impares))
{
x = pop(impares);
push(aux1, x);
}
while(!vazia(pares))
{
x = pop(pares);
push(aux2, x);
}
*/
while(!vazia(aux))
{
x = pop(aux);
push(p, x);
if ((x%2)==1)
{
push(impares, x);
}
else
push(pares, x);
}
libera(aux);
//libera(aux1);
//libera(aux2);
}

/*******************************************************
********************************************************
************ TERMINO FUNO QUESTO Q8 ************
********************************************************
*******************************************************/
/*------------------------------------------------------------------------------*/
/*******************************************************
********************************************************
************ INICIO FUNO QUESTO Q9 ************
********************************************************
*******************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/*
int busca (TLista * l, int elem) // 1 se encontrar e 0 se no encontrar
TLista * inicializa (void)
TLista* insere (TLista* l, int elem) // inserir no inicio da lista
*/
TLista* rr (TLista* l)
{
TLista *aux, p;
p = l;
int x, bool;
aux = inicializa();
while(p)
{
x = p->info;
bool = busca(aux, x);
if(!bool)
{
aux = insere(aux, bool);
}
p = p->prox;
}
libera(l);
l = inicializa();
while(aux)
{
l = insere(l, aux->elem);
}
libera(aux);
return l;

/*******************************************************
********************************************************
************ TERMINO FUNO QUESTO Q9 ************
********************************************************
*******************************************************/
/*------------------------------------------------------------------------------*/
/*******************************************************
********************************************************
************ INICIO FUNO QUESTO Q10 ************
********************************************************
*******************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/*
struct lista{
int info;
struct lista *prox;
};
*/
/*
typedef struct pilha TPilha;
TPilha * inicializa (void);
void push (TPilha *p, int elem);
int pop (TPilha *p);
void libera (TPilha *p);
int vazia (TPilha *p);
*/
TPilha * l2p (TLista *l)
{
TPilha *aux, *result;
aux = inicializa();
result = inicializa();
TLista *p = l;
int x;
while(p)
{
push(aux, p->info);
p = p->prox;
}
while(!vazia(aux))
{

x = pop(aux);
push(result, x);
}
libera(aux);
return result;
}

/*******************************************************
********************************************************
************ TERMINO FUNO QUESTO Q10 ************
********************************************************
*******************************************************/