int main(int argc, char **argv)
{
no *n;
lista *l;
lista *l2;
int i;
l = criaLista();
l2 = criaLista();
for(i = 1 ; i < 5 ; i++){
n = criaNo(i);
insereFim(l,n);
}
for(i = 1 ; i < 5 ; i++){
n = criaNo(i);
insereIni(l2,n);
}
printf("\n ***inserindo no fim e imprimindo*** \n");
imprimeLista(l);
printf("\n ***inserindo no inicio e imprimindo*** \n");
imprimeLista(l2);
liberaLista(l);/* libernado as listas*/
liberaLista(l2); /* libernado as listas*/
return 0;
}
// main com operacoes uteis para testar funcionamento das rotinas implementadas
int main(void) {
Lista* l1 = criaLista(), * l2 = criaLista(), * x;
char* str = (char*) calloc(20, sizeof(char));
int resultado;
insereLetra(l1, 's'); // insere sempre no inicio da lista
insereLetra(l1, 'a');
insereLetra(l2, 'c');
insereLetra(l2, 'u');
insereLetra(l2, 'l');
//concatena
x = strconcat(l2, l1);
// converte para string
listconvertstr(x, str);
//imprime string
printf("Normal: %s\n", str);
//inverte lista
x=strconvertlist(str);
x = strinvert(x);
//converte para string
listconvertstr(x, str);
//imprime string
printf("Invertida: %s\n", str);
//compara x com sua inversa
resultado=strcomp(x,strinvert(x));
//imprime resultado
if(resultado==0) printf(" -> Iguais\n");
else printf(" -> Diferentes\n");
getchar();
getchar();
return 0;
}
t_grafo* criaGrafo(){
t_grafo* graph = (t_grafo*)malloc(sizeof(t_grafo));
graph->vertices = criaLista();
graph->origens = criaLista();
graph->arestas = NULL;
return graph;
}
int main(){
No* L1,*L2,*L3;
L1=criaLista();
L2=criaLista();
L3=criaLista();
L1=insereOrdenado(L1,2,2);
L1=insereOrdenado(L1,1,1);
L1=insereOrdenado(L1,3,3);
L2=insereOrdenado(L2,1,1);
L2=insereOrdenado(L2,1,2);
L2=insereOrdenado(L2,1,3);
imprimeLista(L1);
printf("\n");
imprimeLista(L2);
L3=somaPolinomio(L1,L2,L3);
printf("\n");
imprimeLista(L3);
return 0;
}
/*
* Função principal.
*/
int main(void){
/*
* Primeiramente é criado um ponteiro para o tipo Lista.
* que recebe o valor de retorno de crialista(), que é,
* no caso NULL. Logo, uma lista vazia é criada.
*/
Lista *ls = criaLista();
/*
* Depois chamo a função insereLista() quantas vezes for
* necessária, tendo como parâmetros: a lista criada e o
* valor que se quer colocar na informação. Ela retorna
* o novo valor da lista que é atualizada na variável ls.
* Sem isso o valor se perde na função e a lista não atualiza.
*/
ls = insereLista(ls, 9);
ls = insereLista(ls, 8);
ls = insereLista(ls, 7);
ls = insereLista(ls, 6);
ls = insereLista(ls, 5);
ls = insereLista(ls, 4);
ls = insereLista(ls, 3);
ls = insereLista(ls, 2);
ls = insereLista(ls, 1);
ls = insereLista(ls, 0);
/*
* Chamada da função mostraLista() que tem como parametro a
* lista que se quer mostrar.
*/
mostraLista(ls);
return 0;
}
int main(){
lista *li;
li = criaLista();
int i;
int quantCarros,quantRemocao;
int opcao;
while(1){
system("cls");
setlocale(LC_ALL,"Portuguese");
printf("[1] Adicionar carro\n[2] Excluir carro\n[3] Mostrar carros\n[4] Mostrar tamanho da lista\n[5] Sair\nEscolha a opção: ");
fflush(stdin);
scanf("%d",&opcao);
if(opcao == 1){
printf("Desejas adicionar quantos carros? ");
fflush(stdin);
scanf("%d",&quantCarros);
carros car[quantCarros];
for(i=0; i<quantCarros; i++){
fflush(stdin);
printf("Digite a marca: ");fflush(stdin);
gets(car[i].marca);
printf("Digite o ano: ");fflush(stdin);
scanf("%d",&car[i].ano);
printf("Digite a cor: ");fflush(stdin);
gets(car[i].cor);
printf("Digite o preco: ");fflush(stdin);
scanf("%f",&car[i].preco);
inserirLista(li,car[i]);
}
}else if(opcao == 2){
system("cls");
printf("Deseja remover quantos? ");
scanf("%d",&quantRemocao);
if(removeInicio(li,quantRemocao) == 1){
printf("Removido com Sucesso!\n");
}else{
printf("Erro ao Remover!");
}
system("pause");
}else if(opcao == 3){
imprimirLista(li);
}else if(opcao == 4){
system("cls");
if(tamanhoLista(li) == 0){
printf("Lista está vazia!\n");
}else{
printf("Tamanho da lista: %d\n",tamanhoLista(li));
}
system("pause");
}else if(opcao == 5){
return 0;
}else{
printf("Opção inválida!\n");
}
}
liberarLista(li);
return 0;
}
void escolhe(node* Lista, int resposta)
{
switch(resposta)
{
case 0:
esvaziaLista(Lista);
break;
case 1:
exibeLista(Lista);
break;
case 2:
novoComeco(Lista);
break;
case 3:
novoFinal(Lista);
break;
case 4:
removePrimeiro(Lista);
break;
case 5:
removeUltimo(Lista);
break;
case 6:
novaPosicao(Lista);
break;
case 7:
removePosicao(Lista);
break;
case 8:
criaLista(Lista);
break;
default:
puts("\nOpção inválida! Verifique novamente as opções apresentadas.");
}
}
No* subtraiPolinomio(No *P1, No *P2) {
No *aux = P2;
No* P2negativa = criaLista();
No* P3 = criaLista();
while(aux != NULL) {//loop que multiplica o polinômio P2 por -1
P2negativa = insereOrdenado(P2negativa, (aux->coef * (-1)), aux->exp);
aux = aux->prox;
}
//analálogo ao soma polinômio
P3 = concatenaLista(P1, P2negativa);
simplificaPolinomio(P3);
destroiLista(P2negativa);
return P3;
}
// Main do Programa
int main(void) {
Lista* inicio = criaLista();
int opcao, controle;
do {
printf(" -> Para inserir nova palavra, digite 1\n -> Para remover palavra, digite 2\n -> Para fazer consulta, digite 3\n");
scanf("%d", &opcao);
switch (opcao) {
case 1:
inserePalavra(inicio);
break;
case 2:
removePalavra(inicio);
break;
case 3:
consultaPalavra(inicio);
break;
default:
printf(" ** Opcao invalida!\n\n");
}
printf("\n -> Digite 1 para continuar e 0 para sair: ");
scanf("%d", &controle);
printf("\n");
} while (controle == 1);
return 0;
}
void adicionaItem(THash tabela, char * chave, void * dados){
int i;
//se NULL criaLista
i=funcao_hash(tabela, chave);
if(tab->tabela[i]==NULL) criaLista();
tabela -> tabela[i] =dados;
}
// Converte uma string para uma lista de caracteres
Lista* strconvertlist(char* str) {
int i = 0;
Lista* inicio = criaLista();
for (i = tamanho_str(str) - 1; i >= 0; i--) { //do fim para o inicio, pois cada insercao na lista ocorre pelo inicio
insereLetra(inicio, str[i]);
}
return inicio;
}
void copia(Lista *l_Origem, Lista *l_Copia){
Nodo *atual = (*l_Origem);
criaLista(l_Copia);
while(atual != NULL){
insereFim(l_copia, atual->info);
atual = atual->prox;
}
}
void buscaLargura(Grafo g, int partida)
{
int i, v, a, w;
Fila fila = criaFila();
Lista listaBrancos = criaLista();
Lista listaPretos = criaLista();
Lista listaVisitados = criaLista();
for(i = GVprimeiroVertice(g); i != 0; i = GVproximoVertice(g, i))
{
insereNaLista(listaBrancos, i);
}
printf("Todas os vértices estão brancos.\n");
printf("Nenhuma aresta foi visitada.\n");
v = partida;
printf("O vertice %d está cinza.\n", v);
insereFila(fila, v);
retiraLista(listaBrancos, pegaPosLista(listaBrancos, v));
while(!vaziaFila(fila))
{
v = retiraFila(fila);
printf("Vertice %d ativado.\n", v);
for(a = GAprimaSaida(g,v); a != 0; a = GAproxSaida(g,v,a))
{
insereNaLista(listaVisitados, a);
printf("A aresta %d foi visitada.\n", a);
w = GVvizinho(g,a,v);
if(existeNaLista(listaBrancos, w))
{
insereFila(fila, w);
printf("O vertice %d está cinza.\n", w);
retiraLista(listaBrancos, pegaPosLista(listaBrancos, w));
}
}
insereNaLista(listaPretos, v);
printf("O vertice %d está preto.\n", v);
printf("Vertice %d desativado.\n", v);
}
destroiLista(listaBrancos);
destroiLista(listaPretos);
destroiFila(fila);
}
// Retorna a o ponteiro para o inicio da lista inversa a recebida
Lista* strinvert(Lista* l1) {
int i;
Lista* l2 = criaLista(), *percorre = l1->prox;
for (i = 1; i <= tamanho(l1); i++) {
insereLetra(l2, percorre->info);
percorre = percorre->prox;
}
return l2;
}
No* somaPolinomio(No *P1, No *P2) {
No *P3 = criaLista();
//a "soma" é feita ao simplificar o polinômio proveniente da concatenação de P1 e P2
P3 = concatenaLista(P1, P2);
simplificaPolinomio(P3);
return P3;
}
int main(int argc, char **argv)
{
no *n;
lista *l;
lista *l2;
lista *l3;
int i,k;
l = criaLista();
l2 = criaLista();
l3 = criaLista();
for(i = 1 ; i < 5 ; i++){
n = criaNo(i);
insereFim(l,n);
}
for(i = 2 ; i < 6 ; i++){
n = criaNo(i);
insereFim(l2,n);
}
printf("\n **lista ** \n");
imprimeLista(l);
printf("\n **lista 2** \n");
imprimeLista(l2);
printf("\n **uniao ** \n");
uniao(l,l2,l3);
imprimeLista(l3);
liberaLista(l3);
l3 = criaLista();
printf("\n **intersecao ** \n");
intersecao(l,l2,l3);
imprimeLista(l3);
k = pertence(l,l2);
printf("\n \n 0 - NAO \n 1 - SIM \n");
printf("pertence: %d \n",k);
liberaLista(l);
liberaLista(l2);
liberaLista(l3);
return 0;
}
/*******************************************************************************
Função utilizada para atualizar o ponteiro que indica qual foi a última
notícia que foi criada
*******************************************************************************/
void AtualizaListaDeOrdemDeChegada(Noticia nova) {
if (PR == NULL) {
PR = criaLista(PR);
PR = nova;
}
else {
nova->PP = PR;
PR = nova;
}
}
// Retorna um ponteiro para o inicio da lista resultante da concatenacao das listas recebidas
Lista* strconcat(Lista* l1, Lista* l2) {
int i, j;
Lista *l3 = criaLista(), *l4 = criaLista(), *percorre = l1->prox;
for (i = 1; i <= tamanho(l1); i++) {
insereLetra(l3, percorre->info);
percorre = percorre->prox;
}
percorre = l2->prox;
for (j = 1; j <= tamanho(l2); j++) {
insereLetra(l3, percorre->info);
percorre = percorre->prox;
}
percorre = l3->prox;
//para corrigir a ordem de insercao na lista
for (i = 1; i <= tamanho(l3); i++) {
insereLetra(l4, percorre->info);
percorre = percorre->prox;
}
return l4;
}
int achaKEsimo(lista *l, int k){
int cont;
no *n;
lista *l2;
l2 = criaLista();
ordenaListaDescrescente(l,l2);
if(k > l2->tam){
return 0;
}else{
for(cont = 1, n = l2 -> ini; cont < k; n = n->prox, cont++);
return n -> conteudo;
}
}
No* derivaPolinomio(No *P1) {
No *aux = P1;
No *P2 = criaLista();
//loop que realiza a multiplicação do coeficiente de P1
//por seu expoente e subtrai 1 de seu expoente
//para todos os seus elementos
while(aux!=NULL) {
P2=insereOrdenado(P2, (aux->coef * aux->exp), (aux->exp - 1));
aux=aux->prox;
}
return P2;
}
int main(int argc, char *argv[])
{
struct tLdde *lista = criaLista();
int escolha, qtde, remChave;
struct tItem *itRem;
char resp;
do
{
escolha = menu();
switch(escolha)
{
case 1: inserir(lista, criaItem());
break;
case 2: system("cls");
printf("Informe o valor da chave a ser removida: ");
scanf("%d", &remChave);
itRem = remover(lista, remChave);
if(itRem != NULL)
{
printf("\nItem chave [%d] localizado. Deseja realmente exclui-lo. [S]im [N]ao: ", remChave);
do
{
resp = getche();
}while(toupper(resp) != 'S' && toupper(resp) != 'N');
if(toupper(resp) == 'S')
{
free(itRem);
printf("\nItem chave [%d] removido com sucesso...\n", remChave);
}
else
{
inserir(lista, itRem);
printf("\nRemocao do item chave [%d] abortada...\n", remChave);
}
system("pause");
}
else
{
printf("O item chave [%d] nao estah na lista...\n", remChave);
system("pause");
}
break;
case 3: qtde = mostrar(lista->primeiro);
printf("\nA lista possui %d itens...\n", qtde);
system("pause");
}
}while(escolha != 4);
printf("Saindo...\n");
system("pause");
}
No* dividePolinomio(No *P1, No *P2) {
simplificaPolinomio(P2);
//não pode haver divisão por zero, então devemos checar
//se P2 é nulo após feita a simplificação
if(P2 != NULL) {
No *P3 = criaLista();
//incompleta
return P3;
}
else {
return NULL;
}
}
// retorna uma "substring" obtida a partir de uma lista de caracteres
// caso seja impossivel criar a "substring" desejada, retorna NULL
Lista* substr(Lista* inicio, int i1, int i2) {
int i;
Lista* inicio_substr = criaLista(), * percorre = inicio->prox;
int tam1 = tamanho(inicio);
if (i1 + i2 <= tam1) {
for (i = 1; i <= i2; i++) {
insereLetra(inicio_substr, percorre->info);
percorre = percorre->prox;
}
return inicio_substr;
} else {
printf("Impossivel criar substring desse tamanho");
return NULL;
}
}
/* fazer uma cópia da lista*/
void copiaLista(lista *l1, lista *l2){
no *aux;
no *pega;
int i;
liberaLista(l1);
l1 = criaLista();
aux = l2 -> ini;
i = 0;
while(i < (l2 -> tam)){
pega = criaNo(aux -> conteudo);
insereFim(l1,pega);
aux = aux -> prox;
i++;
}
}
No* integraPolinomio(No *P1) {
No *aux = P1;
No *P2 = criaLista();
//loop que realiza a divisão do coeficiente de P1
//por seu expoente somado com 1 e soma 1 ao seu expoente
//para todos os seus elementos
while(aux!=NULL){
P2=insereOrdenado(P2, (aux->coef / (aux->exp + 1)), (aux->exp + 1));
aux=aux->prox;
}
//Faltando: inserir constante de integração
return P2;
}
No* concatenaLista(No *L1, No *L2) {
No *aux1 = L1;
No *aux2 = L2;
No *L3 = criaLista();
while(aux1 != NULL) {
L3 = insereOrdenado(L3, aux1->coef, aux1->exp);
aux1 = aux1->prox;
}
while(aux2 != NULL) {
L3 = insereOrdenado(L3, aux2->coef, aux2->exp);
aux2 = aux2->prox;
}
return L3;
}
int main(){
int i;
lista l;
no n;
criaLista(&l);
for(i = 0; i < 10; i++){
criaNo(&n,i);
insereFim(&l,n); /* inserindo no Fim*/
}
printf("\n *** removendo a 2 pos***\n");
removePos(&l,2);
imprimeLista(&l);
liberaLista(&l);
return 0;
}
int main (void) {
Lista* lista;
lista = criaLista(12);
int contador = 0;
for(contador = 0; contador <= 50; contador++) {
lista = insereElementoLista(lista, contador);
}
imprimirLista(lista);
lista = booblesort(lista, qntElementos(lista));
printf("\n");
imprimirLista(lista);
return 0;
}
int main(){
int n_nos;
No* p1, *p2;
p1 = NULL;
p2 = NULL;
printf("Entre com o tamanho da lista: ");
scanf("%d", &n_nos);
criaLista(n_nos, p1);
divide(n_nos, p1, p2);
imprime(p1);
imprime(p2);
system("pause");
return 0;
}
int main(){
int i;
lista l;
no n;
criaLista(&l);
for(i = 0; i < 10; i++){
criaNo(&n,i);
insereFim(&l,n);
}
criaNo(&n,5);
insereNCopias(&l,n,2,4);
printf("\n**INSERE NCOPIAS\n");
imprimeLista(&l);
liberaLista(&l);
return 0;
}
