/*

* TRABALHO DE PROLOG

* Equipe : Wellson Sérgio, Lemuel.

*/

package trabalho_prolog;

/**

* Sequência da lista

* 1 - Tipo de Dados --- list(), cab() , cau()

* 2 - wlist( Lista l) - escreve a lista

* 3 - Fazer o compr(L) que retorna o comprimento da lista

*/

class Lista

{ // construindo a lista

public int cab; // o elemento da cabeça tem que ser um inteiro.

public Lista cau; // o elemento da cauda é uma outra lista.

public Lista( int nCab, Lista nCau) //(construtor) -reponsavel por criar a lista.

cab = nCab;

cau = nCau;
 }

public class Trabalho_Prolog {

/**

* @param args the command line arguments

*/

public static void main(String[] args)

Lista L1 = lista(1,lista(2,lista(3,null)));

Lista L2 = lista(5, lista(6,lista(7, null)));

sop("Há Lista L1 é = ");

wLista(L1);

sop("A lista L1 sem o elemento 2 é: ");

wLista(remove(2,L1));

nl();

sop("O mergeSort da lista L1 é: ");

wLista(mergeSort(L1));

nl();

sopln("O Comprimento de L1 é = "+compr(L1));

sopln("O último elemento da lista é = "+ultimo(L1));

sopln("Há Lista possui elementos duplicados? "+dupl(L1));

sopln("O reverso ,sem o acumulador, da lista é: ");wLista(rev(L1));

sop("Há Lista L2 é = ");

wLista(L2);
sopln("O append das listas é: ");wLista(append(L1,L2));

sopln("O reverso[rev1] ,com acumulador, da lista L1 é: ");wLista(rev1(L1));

sopln("O elemento da lista L1 de valor máximo é: "+maxL(L1));

sopln("O maxL1 da lista L1 é: "+maxL1(L1));

sop("A soma dos elementos da lista L1 é : "+soma(L1));

nl();

sop("O elemento 2 é membro da lista L1 ? "+member(2,L1));

nl();

sop("O compr1 de L1 é : "+compr1(L1));

nl();

sop("O select 2 de L1 é: ");wLista(select(2,L1));

nl();

sop("A lista L1 possui elementos contíguos ? "+contiguos(L1));

nl();

sop("A lista L1 sem o último elemento é: ");wLista(remU(L1));

nl();

sop("A lista L1 é palindrome ? "+palindrome(L1));

nl();

sop("A lista L1 e L2 são iguais ? "+iguais(L1,L2));

nl();

sop("A lista L1 está ordenada ? "+isOrd(L1));

nl();

sop("Inserindo 4 na lista L1: ");wLista(insOrd(4,L1));

nl();

sop("O 3 elemento da lista L1 é: "+enesimo(3,L1));

nl();
 sop("Palindrome1 da lista L1 é: "+palindrome1(L1));

nl();

sop("O trocaPU de L1 é: ");wLista(trocaPU(L1));

nl();

//Gera uma lista

static Lista lista(int cab, Lista cau)

Lista local = new Lista(cab,cau);

return local;

//Escreve a Lista

static void wLista( Lista l )

if (l != null)

System.out.print(cab(l)+" ");

wLista(cau(l));

else System.out.println();

/*static Lista remove(int x,Lista l)

if (l == null)
 return null;

Lista l1 = null;

if (cab(l) == x)

l1 = lista(cab(cau(l)),cau(cau(l)));

}*/

// Exercício 3 - Concatena duas listas em uma.

static Lista append(Lista a, Lista b) {

if (a == null) {

return b;

} else {

return lista(cab(a), append(cau(a), b));

static int cab(Lista lista)

return lista.cab;

// Exercício 11 - trocaPU, troca o primeiro com o ultimo elemento.

static Lista trocaPU(Lista l)

if (l == null)

return null;

if (compr(l) == 1)
 return l;

Lista l1 = lista(ultimo(l),null);

Lista l2 = lista(cab(l),null);

Lista saida = append(l1,remU(cau(l)));

saida = append(saida,l2);

return saida;

// Retorna a cauda da lista.

static Lista cau(Lista lista)

if (lista == null)

return null;

return lista.cau;

// Exercício 2 - Soma todos os elementos elementos da lista retornando um unico

valor.

static int soma( Lista lista)

if (lista== null)

return 0;

else

return (1+soma(cau(lista)));

}
 // Exercício 18 - Verifica se uma lista é palindrome ou não.

static boolean palindrome(Lista l)

if (l == null)

return true;

if (cau(l) == null)

return true;

if (cab(l) == ultimo(l))

return palindrome(cau(remU(l)));

return false;

// Exercício 6 - Seleciona e retira um elemento da lista.

static Lista select( int x,Lista l)

if (l == null)

return null;

if(cab(l) == x)

return cau(l);

return lista(cab(l),select(x,cau(l)));

// Exercício 8 - Verifica se tem 2 elementos iguais e seguidos um do outro em uma

lista

static boolean contiguos(Lista l)

{

if (l == null)

return false;

if(cau(l) == null)

return false;

if(cab(l) == cab(cau(l)))

return true;

return contiguos(cau(l));

// Exercício 9

static int ultimo(Lista lista)

if (compr(lista) == 1) // se o comprimento da lista é 1, retorna a cabeça da lista

return cab(lista);

else return ultimo (cau(lista)); // senão, executa o último para a cauda

static Lista remU(Lista l)

if(cau(l) == null)

return select(cab(l),l);

return lista(cab(l),remU(cau(l)));

static boolean member(int x, Lista lista)

{

if(lista == null) // termina a execução do método

return false;

else if (cab(lista) == x)

return true;

else return (member(x,cau(lista))); // enquanto não é o final, executa

// o member de x com a cauda da lista (que é uma lista também)

static int compr(Lista lista)

if(lista == null) // quando a cauda da lista for 'null', execução termina

return 0;

else

return(1+compr(cau(lista))); // do contrário, soma 1 e executa o método

// na cauda da lista

static boolean iguais(Lista l1,Lista l2)

if ((l1 == null) && (l2 == null))

return true;

if ((l1 == null) || (l2 == null))

return false;

if (cab(l1) == cab(l2))
 return iguais(cau(l1),cau(l2));

return false;

static int compr1(Lista l)

return compr1Acc(l,0);

static int compr1Acc( Lista l, int acc)

if ( l == null)

return acc;

else return compr1Acc(cau(l),acc+1);

static boolean palindrome1( Lista l)

if (l == null)

return true;

if (cau(l) == null)

return true;

if (iguais(l,rev(l)) == true)

return true;

return false;

}
static void sop(String s) // posibilita escrever direto no main

// sop("Texto");

System.out.print(s);

static void sopln(String s) // escrever com pulo de linha

System.out.println(s);

static void nl() // apenas pula de linha

System.out.println("");

// reverse, maior, menor, remU, Duplicados, Contiguos, remDuplicados

static boolean dupl(Lista lista)

if (lista == null) // executa enquanto não chega no final da lista

return false;

else if (member(cab(lista),cau(lista)))

return true;

else return dupl(cau(lista));

}

static Lista remDupl(Lista l)

if (member(cab(l),cau(l)) == true)

l = lista(cab(cau(l)),cau(cau(l)));

return remDupl(cau(l));

// Exercício 13

public static Lista remove(int X, Lista Z){

if(Z == null) return Z;

if(X == cab(Z)) return remove(X,cau(Z));

else return lista(cab(Z),remove(X,cau(Z)));

// Utilizando Acumuladores!!!

// Exercício 14

static Lista rev( Lista l )

if (l == null)

return null;

else return append( rev(cau(l)), lista(cab(l),null));

}

// Exercício 15

static Lista rev1( Lista lista )

return rev1Acc(lista, null);

static Lista rev1Acc( Lista lista, Lista acc )

if (lista == null)

return acc;

else return rev1Acc( cau(lista),lista(cab(lista),acc));

// Exercício 4 - Sem utilizar o acumulador

static int maxL( Lista lista )

if (cau(lista) == null)

return cab(lista);

else {

if (maxL(cau(lista)) > cab(lista))

return maxL(cau(lista));

else return cab(lista);

 }

// Exercício 16 - Usando Acumulador

static int maxL1(Lista lista)

return maxL1( cau(lista), cab(lista) );

static int maxL1( Lista lista, int m )

if (lista == null)

return m;

if (cab(lista) > m)

return maxL1(cau(lista), cab(lista));

else return maxL1(cau(lista),m);

static int enesimo(int x,Lista l)

if (l == null)

return 0;

if (x == 0)

return 0;
 if (x == 1)

return cab(l);

if (x >= 1)

return enesimo((x-1), cau(l));

return 0;

static boolean isOrd(Lista l)

if (l == null)

return true;

if (cau(l) == null)

return true;

if (cab(l) <= cab(cau(l)))

return isOrd(cau(l));

return false;

static Lista insOrd(int x,Lista l)

if (l == null)

return lista(x,null);

if (x < cab(l))

lista(x,l);

return lista(cab(l),insOrd(x,cau(l)));

}
// Exercício 24 - particiona, separa uma lista A em duas listas B e C.

public static void particiona(Lista Z, Lista[] A){

if(Z == null){A[0] = null; A[1] = null;}

else if(cau(Z) == null){

A[0] = Z; A[1] = null;

}else{

particiona(cau(cau(Z)),A);

A[0] = lista(cab(Z),A[0]);

A[1] = lista(cab(cau(Z)),A[1]);

// Exercício 25 - O merge concatena duas listas diferentes.

static Lista merge(Lista a,Lista b)

if (a==null){

return b;

else if (b==null){

return a;

else if (cab(a) > cab(b)){

return lista(cab(a),merge(cau(a),b));}

else return lista(cab(b),merge(a,cau(b)));

}
 // Exercício 26 - O mergeSort ordena uma lista em ordem decrescente.

public static Lista mergeSort(Lista Z){

if(Z == null) return null;

if(cau(Z) == null) return Z;

else{Lista[] A = new Lista[2];

particiona(Z,A);

return merge(mergeSort(A[0]), mergeSort(A[1]));