Instituto Federal de Educao Cincias e Tecnologia

Campus Formiga
Bacharelado em Cincia da Computao

Atividade: 3 Trabalho Prtico

Disciplina: Algoritmos e Estruturas de Dados I Professor: Mrio Luiz Rodrigues Oliveira

Fabrcio Daniel Freitas Matrcula: 002752 Valquria Soares Silva Matrcula: 002785 Formiga, 23 de Setembro de 2013.

Sumrio: Sumrio...............................................................................................................................2 Introduo...........................................................................................................................3 Implementao....................................................................................................................7 Descrio ! 9 Estudo da Complexidade! 13 Concluso! 15 Bibliograa! 16

1 -Introduo
! ! ! Este trabalho consiste em utilizar os conceitos de listas para a soluo de um problema, utilizando prioridades. Fala sobre lista, TAD, alocao de memria e entre outros assuntos. ! - Ambientes de desenvolvimento do cdigo fonte: Xcode, e codblocks. ! - Compilador utilizado: gcc version 4.7.1 (GCC). ! - Linguagem utilizada: Linguagem C. ! - Ambiente de desenvolvimento da documentao: LibreOfce Writter. ! - Na anlise da ordem de complexidade dos algoritmos ser analisado o pior caso, de acordo com a denio assinttica de Big O. ! A Lista Encadeada diz que, cada n (ou clula) deve conter um item da lista e um campo extra para um apontador para o n seguinte. ! A alocao dinmica de memria a tcnica utilizada: as posies de memria so alocadas (desalocadas) quando so necessrias (desnecessrias). ! ! Como visto, C faz a gerncia de memria atravs das declaraes malloc e free. ! ! Existem outras implementaes: simplesmente ou duplamente encadeadas e listas encadeadas circulares; com ou sem ns sentinela. ! ! As desvantagens na utilizao desse tipo de lista so: ! ! - Acesso indireto aos elementos ! ! - Tempo varivel para acessar os elementos (depende da posio do elemento) ! ! - Gasto de memria maior pela necessidade de um novo campo para o ponteiro ! E possui tambm as vantagens : ! ! - A insero e remoo de elementos podem ser feitas sem deslocar os itens seguintes da lista ! ! - No h necessidade de previso do nmero de elementos da lista; o espao necessrio alocado em tempo de execuo ! ! - Facilita o gerenciamento de vrias listas (fuso, diviso,...) ! ! A Lista Simplesmente Encadeada deve existir sempre uma indicao do primeiro n, a partir dele a lista percorrida. Ento, seria necessrio um cuidado especial no tratamento do primeiro n da lista, tem que ser feito testes em algoritmos de insero e remoo para vericar se este ponteiro ou no igual a NULL, uma pequena variao na estrutura, com a adio de um n chamado n-cabea, evita alguns testes com o 1 n e melhora o desempenho das operaes na lista. O n-cabea no contm informaes relacionadas aos dados da lista e nunca removido.

Figura 1 Lista Encadeada com n cabea. ! As listas duplamente encadeadas so estruturas de dados semelhantes s listas simplesmente encadeadas pois a alocao da memria feita durante a execuo.No entanto, em comparao com as listas simplesmente encadeadas a conexo entre os elementos feita atravs de dois ponteiros (um que aponta para o elemento anterior, e o outro, para o seguinte). O ponteiro anterior ao primeiro elemento deve apontar para NULL (o incio da lista). O ponteiro seguinte ao ltimo elemento deve apontar para NULL (o m da lista). Para acessar um elemento, a lista pode ser percorrida pelos dois lados: ! *Comeando do alto, o ponteiro "seguinte" permite o deslocamento para o elemento seguinte. ! *Comeando do nal, o ponteiro "anterior" permite o deslocamento para o elemento anterior. ! Em suma, o movimento feito em ambas as direes, do primeiro para o ltimo elemento e/ou do ltimo para o primeiro.

2 - Implementao
! Numa lista encadeada, para cada novo elemento inserido na estrutura, alocamos um espao de memria para armazen-lo. Desta forma, o espao total de memria gasto pela estrutura proporcional ao nmero de elementos nela armazenado. No entanto, no podemos garantir que os elementos armazenados na lista ocuparo um espao de memria contguo, portanto no temos acesso direto aos elementos da lista. Para que seja possvel percorrer todos os elementos da lista, devemos explicitamente guardar o encadeamento dos elementos, o que feito armazenando-se, junto com a informao de cada elemento, um ponteiro para o prximo elemento da lista. Cabea de Lista 1.Necessitamos: ! ! oUm ponteiro para o primeiro elemento da lista. ! ! oUm inteiro para indicar quantos elementos a lista possue. Pseudo-cdigo: ! tipo Lista { ! Elemento *dados; ! inteiro tamanho; ! }; Elemento de Lista 1.Necessitamos: ! oUm ponteiro para o prximo elemento da lista. ! oUm campo do tipo da informao que vamos armazenar. Pseudo-cdigo: ! tipo Elemento { ! Elemento *prximo; ! tipo-que-eu-vou-usar-nesta-aplicao info; ! };

! Um TAD dene um novo tipo de dado e o conjunto de operaes para manipular dados desse tipo, e um TAD facilita a manuteno e a reutilizao de cdigo. ! A Interface de um TAD dene o nome do tipo, e os nomes das funes exportadas, ou seja, os nomes das funes devem ser prexadas pelo nome do tipo, evitando conitos quando tipos distintos so usados em conjunto. ! Implementao de um TAD, o arquivo implementado deve incluir o arquivo de interface do TAD, que permite utilizar as denies da interface, que so necessrias na implementao e garante que as funes implementadas correspondem as funes da interface. E deve incluir as variveis globais e funes auxiliares, que devem ser declaradas como estticas, e visveis apenas dentro do arquivo de implementao.

3 Descrio

Lista dinmica encadeada com cabea: ! Lista dinmica um tipo de lista que dene a cada passo um espao de memria para seu elemento. ! Lista Dinmica Encadeada (ou Lista Dinmica simplismente ligada) um Tipo de Lista onde cada elemento aponta para o seu sucessor na lista . Usa-se um ponteiro especial para o primeiro elemento da lista (cabea da lista) e uma indicao de nal de lista.

! Como visto na gura acima, tem um ponteiro especial para o primeiro elemento da lista, e cada elemento tem um ponteiro que aponta para um elemento da lista, sendo o ultimo elemento apontando para NULL, ou seja apontando para algo inexistente. ! A estrutura da lista conforme observado, possui um dado, e um ponteiro que aponte para seu prximo elemento. ! O dado a informao que eu quero armazenar dentro da lista e sendo o prox, o elemento que vem depois de mim na lista. Consideraes: (I)Cada elemento da lista tratado como um ponteiro que alocado dinamicamente , a medida que os dados so inseridos.

II.Para guardar o primeiro elemento, em uma lista com cabea, utilizamos um ponteiro para ponteiro, pois um ponteiro para ponteiro pode guardar o endereo de um ponteiro.

! ! Na gura acima, eu tenho trs elementos na lista, quando aloquei o 33, reservei o espao de memria para o dado 33, quando aloquei o 23, aloquei o espao de memria para ele e seu respectivo ponteiro, assim, sucessivamente. ! Caso eu quisesse alocar outro nmero depois do 16, eu teria que alocar um outro espao de memria para ele, e em seguida, fazer com que ele apontasse para NULL. ! ! O primeiro elemento, possui um ponteiro especial, que aponta para o primeiro elemento, o que chamamos de ponteiro para ponteiro, dessa forma eu consigo mudar o incio da lista, ou seja, eu posso mudar o contedo inicial da lista com cabea, que tambm um ponteiro. Com o ponteiro para ponteiro, posso muda o contedo do primeiro elemento da lista. Vantagens em relao a uma lista sequencial esttica: I.Melhor utilizao dos recursos de memria, pois denido o que se quer de memria a cada passo. II.No precisa fazer operao de movimentao dos elementos nas operaes de remoo e insero. ! Na gura abaixo um exemplo de insero na lista dinmica encadeada, fazendo alteraes apenas nos ponteiros.

Desvantagens em relao a lista sequencial esttica: I.Acesso indireto aos elementos; II.Necessidade de percorrer a lista para acessar determinado elemento.

! Na lista sequencial esttica poderamos acessar o elemento diretamente pelo ndice, porm, na lista sequencial dinmica, deve-se percorrer toda lista, conforme a gura acima. Aplicao: I.Quando no houver necessidade de garantir um espao mnimo para a execuo do aplicativo, ou seja eu no souber quanto de memria eu irei utilizar. II.Insero/remoo em lista ordenada so operaes mais frequntes, ou seja quando houver muitos deslocamentos em uma lista. Implementao: I.No ListaDinEncCab.h foi denido: Os prottipos das funes; O tipo de dado armazenado na lista; O ponteiro "Lista", pois como iremos trabalhar com lista com cabea, este ser o ponteiro para ponteiro para modicar seu primeiro elemento. ! II.No ListaDinEncCab.c foi denido: O tipo de dados "Lista"; Implementado suas funes, denidas no arquivo.h. Insero em uma lista simplesmente encadeada com cabea: I.Existem 3 tipos de insero em uma lista: ! ! -Incio; ! ! -Meio; ! ! -Fim; Segue-se o exemplo na prxima gura:

! Tambm existe o conceito de insero em lista vazia, onde a insero feita, em uma lista que est vazia.

! Como na gura acima, quando criamos uma lista, ela est vazia e a cabea aponta para NULL. ! Para inserir o novo n, ele aponta a ser para o prximo NULL e a cabea aponta para o novo n. ! Esse o cdigo bsico para todas as inseres.

Funo que insere no incio da lista, esta estando vazia ou no.

Figura exemplicando insero no nal de uma lista Inserindo um elemento de forma ordenada ou um elemento qualquer: ! A insero em uma lista ordenada, pode ser no incio no meio ou no nal da mesma, sendo assim, deve-se tratar os 3 casos de uma s vez.

! ! Na gura acima podemos ver no campo Busca onde inserir, temos os elementos Cabea que aponta para o atual, sendo que depois isso se inverte, o elemento cabea passa a ser o atual e o atual passa a ser o anterior, ate que se chegue ao nal da lista, ou encontre o ponto onde deve ser feito a insero. ! Uma dessas opes ser verdadeira em algum momento, ou chego no nal da lista, ou encontro o ponto de insero. ! No segundo caso, Inserir no incio, estou inserindo um elemento antes do primeiro elemento, um exemplo de lista ordenada. ! Se no for inserido no incio, se for falso, eu estarei inserindo no meio da lista ou no nal dela. ! Nesse caso, eu terei o n anterior, que inserir depois de ant, e este apontando para NULL, e o anterior aponta para o atual, sendo que o ant pode ser o ltimo n inserir depois de ant. Remoo em uma lista encadeada com cabea: ! ! Existem 3 tipos bsicos de remoo, seguindo-se a mesma linha de raciocnio da insero: ! -Incio; ! -Meio: Este tipo de remoo geralmente utilizada, quando se quer remover um determinado elemento. ! -Fim;

Remoo no incio:

De acordo com a gura acima, deve-se desalocar a memria da primeira clula, e informar para onde a cabea aponta para o novo incio da lista.

Remoo no meio:

! ! No exemplo acima, o 33 apontava para o 12, depois de se remover o 12, o elemento anterior vai apontar para o prximo.

Remoo no m:

! Observa-se que deve se percorrer toda a lista, at chegar no ltimo elemento dela, ento remove-se o ltimo elemento, e o elemento anterior, passa a apontar para o NULL, e o anterior ao ltimo, passa a ser o ltimo elemento da lista. Consideraes: I.Os 3 tipos de remoo trabalham juntos. A remoo sempre remove um elemento especco da lista, o qual pode estar no incio, no meio ou no nal da lista, porem, deve-se atentar tambm aos seguintes cuidados: II.No se pode remover um elemento de uma lista vazia; III.Removendo o ltimo n, a lista ca vazia.

! No exemplo acima, no tem como, ou seja, no existe a possibilidade de remover um elemento que no existe, que esteja apontando para NULL. ! E se uma lista possui um nico n e eu remover este n a lista ir se tornar vazia.

Exemplo de remoo no incio da lista:

! Na gura acima foi representado o primeiro elemento da lista sendo este elemento o elemento n. A cabea da lista passa apontar para o elemento seguinte ao elemento no, e em seguida liberado o n. ! Tambm pode-se observar, que no caso de uma lista com um nico elemento, ao remover esse elemento, a cabea da lista passa apontar para vazio, indicando que a lista se torna vazia. Exemplo de remoo no nal da lista: ! Este tipo de remoo bem parecido com a remoo de nicio da lista, sendo a principal diferena que se deve percorrer primeiramente toda a lista.

! Na gura acima, vemos um cdigo que s seria nalizado quando o determinado elemento estiver apontando para NULL, que o ultimo elemento da lista. ! Tambm podemos observar se o no o nico elemento da lista, e ele removido, a cabea aponta para NULL indicando que esta uma lista vazia.

Exemplo de remoo de um elemento qualquer:

! Na gura acima exemplicando a remoo de um elemento qualquer. ! ! Primeiramente deve se Buscar qual remover; ! ! Depois de procurar, se o elemento a ser removido for no incio, basta mudar o incio da lista, ou seja o incio passa a apontar para o prximo. ! Se no for o primeiro, o anterior que apontava para o prximo a ele, vai passar a apontar para o no que aponta para o prximo. ! Se for removido o ultimo elemento, o anterior vai passar a apontar para NULL, ou seja, o ltimo elemento da lista, em seguida liberando o n da memria. ! Se for removido um elemento intermedirio, o elemento anterior, vai passar a apontar para onde o no anterior apontava, em seguida deve-se liberar o n.

Consulta/imprimir elementos de uma lista dinmica simplesmente encadeada: ! Quando temos uma lista, e queremos retornar determinado(s) elemento(s) desta lista, sendo que basicamente duas maneira de consultar um elemento de uma lista: - Pela posio; - Pelo contedo. ! ! Ambos depende de busca (percorrer os elementos) at encontrar o desejado.

! Na gura acima, exemplica-se a busca por posio e contedo. ! Na busca por posio eu queria o terceiro elemento da lista, nesse caso deve-se percorrer a lista at achar o elemento que se quer, nesse caso retorna o valor 16. ! J na busca por contedo, eu quero o elemento de valor 33, nesse caso a cabea j esta apontando logo para ele.

Lista dinmica duplamente encadeada com cabea:

! um tipo especial da lista encadeada, ou seja, um tipo de Lista onde cada elemento aponta para o seu sucessor e antecessor na lista. ! Ela usa um ponteiro especial para o primeiro elemento da lista (cabea) e uma indicao de nal de lista, nos dois sentidos.

! ! Como na gura acima, podemos observar os dois ponteiros, em cada n sendo um apontando para o sucessor e outro apontando para o antecessor do n na lista. ! Todo elemento da lista tem que ter o prximo elemento, o anterior, e o dado. ! Cada elemento tratado como um ponteiro que alocado dinamicamente, a medida que os dados so inseridos. ! Para guardar o primeiro elemento, utilizamos um ponteiro para ponteiro, podendo guardar um endereo de ponteiro, facilitando mudar quem est no nicio da lista, apenas mudando o contedo de ponteiro para ponteiro Vantagens: ! -Melhor utilizao dos recursos de memria; ! -No precisa movimentar os elementos nas operaes de insero e remoo.

Na gura anterior, para inserir o valor 12, basta modicar os ponteiros nos quais apontam os valores. Desvantagens: ! -Acesso indireto aos elementos; ! -Necessidade de percorrer a lista para acessar um elemento.

! Na gura acima exemplica o acesso ao elemento 16, sempre partindo do incio da lista, tendo que passar por 33, 23 s depois chegar ao 16, sem a possibilidade de acesso direto, percorrendo a lista. Utilizao da lista duplamente encadeada: ! -Quando no houver necessidade de garantir um espao mnimo de execuo do aplicativo; ! -Inserir/remover em uma lista ordenada so as operaes mais frequentes; ! -E tiver a necessidade de acessar informao de um elemento antecessor, neste caso, no sendo possvel na lista simplesmente encadeada. Criando a lista:

Na gura acima, podemos ver que o contedo *li, aponta para o incio e no tem nenhum n dentro da lista, sendo este em si o primeiro e nico n na lista.

Vericar se a lista est vaziaLista vazia: Podemos ter uma lista vazia ou no, como por exemplo, ao criar uma lista, esta estar vazia, s deixando de ser vazia ao ser inserido elementos.

Na gura acima exemplica o contedo de uma lista apontando para NULL. Retornar o tamanho de uma lista duplamente encadeada:

! (I).Na gura acima o *li representa a cabea da lista, sendo que o contedo de li, o primeiro elemento, sendo que foi declarada a varivel cont e o n recebe o primeiro elemento. ! (II). Na segunda parte o valor contou mais um (cont++), e entrei para o prximo elemento. ! (III). Na terceira parte, cheguei a um prximo elemento e contei mais um (cont++), o cont passou a valer 2, e foi ao prximo elemento. ! (IV). No nal chegou ao NULL, indicando o m da quantidade de elementos da lista.

Insero na lista duplamente encadeada: ! Existem 3 tipos de insero na lista duplamente encadeada: ! ! -Inicio; ! ! -No meio; - Ou no nal.

Na gura acima podemos ver o valor 12 sendo inserido inicialmente no inicio, no segundo exemplo, sendo inserido no meio, e no ultimo exemplo no nal.

I.Inserindo em uma lista vazia: ! Tambm existe o caso onde a insero feita em uma lista que est vazia. ! A insero parecida com a da Lista Dinmica Encadeada. Deve-se apenas considerar que agora temos dois ponteiros para atualizar: o anterior e o prximo.

! No exemplo acima, vemos uma lista que anteriormente a cabea apontava para NULL, porm agora ela aponta para um novo elemento, o 33, ou seja, o novo n recebe os dados, os ponteiro prximos e anteriores recebem NULL, e por m *li permanece no incio da lista, pois esse ponteiro a cabea da lista. II.Inserindo em uma lista vazia: !

! Na gura acima podemos observar que na parte superior, temos uma lista, e na segunda parte a implementao na qual foram copiados os dados e em seguida o prximo aponta para os dados *Li, o prximo do *LI aponta para onde estava apontando anteriormente que era o inicio da lista *Li, e o anterior aponta-se para NULL. ! Em seguida foi vericado se a lista estava vazia, caso negativo, *LI apontava para o anterior que apontava para o n, em seguida mudando o primeiro elemento da lista.

III.Inserindo no nal de uma lista:

 A gura anterior representa a insero de um elemento no nal de uma lista duplamente encadeada com cabea. Primeiramente tem-se uma lista, considerando que a lista no esta vazia, em seguida, buscando onde inserir, ento uso o while, para procurar at onde est o elemento null, usando o aux para ajudar achar o elemento nulo. Aps achar os elementos, faz-se a insero copiando os dados, fazendo com que o prximo recebe nulo, o auxiliar aponta para a prxima que recebe o n, e o n anterior, aponta para aux.

4 - Estudo da complexidade
Anlise de Algoritmos a rea da computao que visa determinar a complexidade (custo) de um algoritmo, o que torna possvel: Comparar algoritmos Determinar se um algoritmo timo. Custo de um algoritmo: Tempo (nmero de passos) Espao (memria) A complexidade de um algoritmo medida segundo um modelo matemtico que supe que este vai trabalhar sobre uma entrada (massa de dados) de tamanho N. A complexidade pode ser qualicada quanto ao seu comportamento como: .Polinomial : A medida que N aumenta o fator que estiver sendo analisado (tempo ou espao) aumenta linearmente. Exponencial A medida que N aumenta o fator que estiver sendo analisado (tempo ou espao) aumenta exponencialmente. Algoritmo com complexidade exponencial, no executvel para valores de N muito grandes.

A notao O utilizada para expressar comparativamente o crescimento assinttico (velocidade com que tende a innito) de duas funes. Por denio, f = O(g) se existe uma constante c > 0 e um valor n0 tal que n > n0 c * g(n), ou seja, g atua como limite superior para valores assintticos da funo f. Complexidade exponencial, tpicos de algoritmos que fazem busca exaustiva (fora bruta) para resolver um problema, no so teis do ponto de vista prtico.

f(n)

A funo que verica se uma lista vazia, possui 1 comparao. Ento, obtemos a funo de complexidade para a funo: O(n) = 1 . A ordem de complexidade da funo O (f(n)), ou seja, O(1). A funo que insere lista no inicio, possui 4 comparaes e 4 comandos. Obtemos a complexidade para a funo, O(n) = 8. Ento a ordem de complexidade da funo O (f(n)), ou seja, O(1).

 A funo que insere lista no nal, possui 6 comparaes e 8 comandos. Obtemos a complexidade para a funo, 0(n)=14. Ento a ordem de complexidade da funo O (f(n)), ou seja, O(1). A funo Insere Lista Ordenada, possui 10 comparaes e 11 comandos. Obtemos a complexidade para a funo, igual a funo anterior. Ento a ordem de complexidade da funo O (f(n)), ou seja, O(1). A funo remove lista do inicio, possui no pior caso 3 comparaes e 2 comandos. Obtemos ento, a funo de complexidade para a funo: O(n) = 5. Resolvendo obtemos: f(n) = 5, ento a ordem de complexidade da funo O (f(n)), ou seja, O(1). A funo remove lista do nal, possui 6 comparaes e 5 comandos. Obtemos a complexidade para a funo, O(n)=11, ou seja, O(f(n)) = O(1). A funo Remove_Lista, possui 8 comparaes e 4 comandos, ou seja, O(f(n)) = O(f(12)) = 0(1). A funo remove_listaq, possui no pior caso 5 comparaes e 4 comandos. Obtemos ento, a funo de complexidade para a funo: 0(n) = 9. Resolvendo obtemos, 0(f(n)) = 0(f(9)) = 0(1). A funao imprimirLista, possui 4 comparaes e 3 comandos, ou seja f(n) = 7. Ento 0(1). A funao consulta_lista_mat, possui no pior caso 3 comparaes e 4 comandos. Obtemos ento, a funo de complexidade para a funo: O(n) = 9. Resolvendo obtemos: f(n) = 9, ento a ordem de complexidade da funo O (f(n)), ou seja, O(1). A funo lista_vazia, possui no pior caso 2 comparaes e 3 comandos. Obtemos ento, a funo de complexidade para a funo: O(n) = 5. Resolvendo obtemos: f(n) = 5, ento a ordem de complexidade da funo O (f(n)), ou seja, O(1). A funo tamanho_lista, possui no pior caso 3 comparaes e 4 comandos. Obtemos ento, a funo de complexidade para a funo: O(n) = 7. Resolvendo obtemos: f(n) = 7, ento a ordem de complexidade da funo O (f(n)), ou seja, O(1). A funo que simula o programa, f(n) = n, pois o Max(O(n), O(n), O(n), O(n), ... O(n) ), ento a ordem de complexidade O (f(n)), ou seja, O(n).

5 - Concluso
Este trabalho possibilitou um aprofundamento maior sobre a linguagem C, tambm na reviso e xao de conceitos sobre listas, ponteiros e alocao de memria. Ajudou no aprendizado de listas implementadas por encadeamento simples e por encadeamento duplo, fazendo-se o uso de apontadores, TAD e estruturao em C. As diculdades encontradas foram pouco tempo para implementao de tal atividade, devido ao nmero de trabalhos e provas de outras disciplinas, bem como a necessidade de uso de apontadores, sendo que tal utilizao ainda no esta bem xa, mas apesar de ter adquirido conhecimento entre vrios tipos de las, infelizmente o programa no foi concludo com sucesso. As duvidas foram resolvidas com o auxilio da bibliograa citada e com a ajuda de alguns professores.

6 Bibliograa
[1] N. Ziviani. Projeto de Algoritmos: com implementaes em Pascal e C. Cengage Learning (Thomson / Pioneira), So Paulo, 2nd edition, 2004. [2] David Menotti. CIC102 - Algoritmos e Estruturas de Dados 1, Outubro 2009. [3] http://www.univasf.edu.br/~marcelo.linder/arquivos_ed1/aulas/aula15.pdf [4]A. Backes. Linguagem C completa e descomplicada, ELSEVIER.

7 Cdigo Fonte
Main.c:
// // main.c // Lista Dinmica encadeada com Cabeca // // Created by Fabrcio Daniel Freitas on 19/09/13. // Copyright (c) 2013 Fabrcio Daniel Freitas 0002752 - Valquria Soares 0002785. All rights reserved. // #include <stdio.h> #include "ListaDinEncCab.h" #include <stdlib.h> int main() { Lista *li; /*Declarei meu ponteiro do tipo Lista, ou seja, o elemento* Lista declarado no meu arquivo.h, j um ponteiro, ou seja, o *li do tipo Lista, um ponteiro para ponteiro. \ da struct elemento. Cada um dos ns da minha lista, ser um nico ponteiro, exceto o inicio da lista que um ponteiro para ponteiro, por que o ponteiro para ponteiro, consegue guardar nele um endereo de um ponteiro, ou seja, esse sera a cabea da lista.*/ lista *Li;//ponteiro para ponteiro void menu();//menu de opoes return 0; }

ListaDinEncCab.c:
// // ListaDinEncCab.c // Lista Dinmica encadeada com Cabeca // // Created by Fabrcio Daniel Freitas on 20/09/13. // Copyright (c) 2013 Fabrcio Daniel Freitas 0002752 - Valquria Soares 0002785. All rights reserved. // /*ListaDinEncCab.c: Definir - O tipo de dados "Lista"; - implemetar suas funes */ #include <stdio.h> #include <stdlib.h> //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------struct elemento{ struct caracter dados; //uma variavel dados do tipo estrutura de dados quaisqer struct elemento *prox; // um ponteiro que aponta para a proxima estrutura }; typedef struct elemento Elem; //facilita na operao //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------Lista* cria_lista(){ //Funo para criar a lista. Lista* li = (Lista*) malloc(sizeof(Lista)); //Malloc para guardar o primeiro n da lista, ou seja a caba da lista if (li != NULL) { //Se deu certo a criao do n cabea *li = NULL; //Preencheu o contedo com NULL, ou seja apontando para nada } return li; //Da retorna a lista vazia. } //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------int insere_lista_inicio(Lista* li, struct caracter al){ if (li == NULL) return 0; //Primeiro verificar se a lista vida, ou seja se ela existe, se no existir retorna 0, caso a lista exista Elem* no = (Elem*) malloc (sizeof(Elem));//Eu crio o elemento Elem* no, fao o malloc e o sizeof elemento

if (no == NULL) return 0; //Se o n retornar nulo, quer dizer que no conseguir alocar memria para esse novo n, porm caso eu consiga alocar espao de memria no -> dados = al; //Os dados al sero copiados como parmetro para dentro do n no -> prox (*li);//Vou informar que o prximo item a prpria lista, isso resolvendo todos os casos se a lista for vazia ou no *li = no; //A cabea da lista, passa apontar para um novo n que foi inserido return 1; //retorna 1, indicando que foi inserido o item no inicio da lista } //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------int insere_lista_final (Lista* li, struct caracter al){ if (li == NULL) return 0; //Primeiro verificar se a lista vlida, ou seja se ela existe, se no existir retorna 0, caso a lista exista Elem* no (Elem*) malloc (sizeof(Elem)); //Eu crio o elemento Elem* no, fao o malloc e o sizeof elemento novo n, porm caso eu consiga alocar espao de memria if (no == NULL) return 0; //Se o n retornar nulo, que dizer que no consegui alocar memria para esse novo n, porm caso eu consiga alocar espao de memria no-> dados = al; //Os dados al sero copiados como parmentro para dentro de n no -> prox = NULL;//Como ser inserido no final da lista, eu devo dizer que o prximo elemento aps esse n, o NULL, pois no final da lista eu s tenho o NULL if ((*li) == NULL) { //Se eu estiver inserindo em uma lista vazia, neste caso, eu digo que o inicio da lista *li = no;// o novo n }else{ //seno, eu percorro toda a lista Elem *aux = *li; //crio um ponteiro auxiliar, dizendo que ele tem o valor do nicio da lista, pois no se deve percorrer a lista com a prpria cabea e sim com um auxiliar while (aux -> prox != NULL) {// enquanto o prximo elemento for diferente do ultimo valor, ou seja NULL aux = aux -> prox;//O auxiliar vai receber o n seguinte a ele } //at achar o ltimo n aux -> prox = no; //Achou o ultimo n, ele vai receber o elemento a ser inserido } return 1; //retorna 1 indicando que a insero no final foi feita corretamente } //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------int insere_lista_ordenada(Lista* li, struct caracter al){

if (li == NULL) return 0;//Verifico se a lista valida, e crio um elemento Elem *no = (Elem*) malloc(sizeof(Elem));//Aloco memria para o elemento criado if (no == NULL) return 0;//Verifico se foi alocado o elemento no -> dados = al;//verifico se a lista vazia, copio os dados para dentro dele if (lista_vazia(li)) { //insere no inicio da lista no -> prox (*li); //Se a lista for vazia, o n aponta para o prximo que recebe o li return 1;//retorna 1 finalizando a funo dizendo que deu certo } else{//procura onde inserir o elemento caso a lista no seja vazia Elem *ant, *atual = *li;//crio dois ponteiros auxiliares o atual apontando para a cabea da lista e um anterior while(atual != NULL && atual -> dados.dado_caracter != 'q'){// enquanto o atual for diferente de nulo, e enquanto o elemento estiver entre atual e outro ant = atual; //anterior passa valer o atual e atual = atual -> prox;//o atual passa a valer o prximo elemento } if (atual == *li){//se o elemento atual for no incio da lista no -> prox = (*li);//se for, quer dizer que ele no andou em nenhum lugar, e deve ser inserido no incio da lista, o n prox, aponta para o nicio da lista *li = no; //nicio da lista aponta para o prximo n }else{ no -> prox = ant -> prox; //N prox, aponta para onde o n anterior estava apontando ant->prox = no; //o anterior aponta para o n, sendo que este antes, apontava para NULL } } return 1; } //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------int remove_lista_inicio(Lista* li){ //funo para remover no inicio if (li == NULL) //verifico se a lista existe return 0;//caso a lista no exista, retorna falso, ou seja 0 if ((*li) == NULL) //verifica se a lista vazia, se o conteudo inicial da lista NULL return 0; //retorna falso Elem *no = *li; //Se for uma lista vlida, ou seja passou pelos testes acima, inicia criando uma auxiliar com o nome *no, que recebe o valor da cabea da lista *li = no->prox; free(no); return 1;

} //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------int remove_lista_final(Lista* li){ if (li == NULL) //verifico se a lista existe return 0;//caso a lista no exista, retorna falso, ou seja 0 if ((*li) == NULL) //verifica se a lista vazia, se o conteudo inicial da lista NULL return 0; //retorna falso Elem *ant, *no = *li; //percorrer a lista at o final dela, crio duas auxiliares, ant e no while (no -> prox != NULL){ //enquanto o no que aponta para o proximo for diferente de vazio ant = no;//o anterior recebe o no no = no->prox; //no recebe o elemento seguinte a ele } if (no == (*li))// depois de percorrer ve se o n igual o inicio da lista , caso afirmativo remover primeiro elemento? ou seja a lista tem somente 1 elemento *li = no->prox; //entao o inicio da lista aponta para o proximo, se ele for o unico elemento da lista ele vai apontar para nulo else //caso no seja o primeiro da lista, ant->prox = no->prox; //o anterior vai apontar para onde aponta o no free(no);//libera o no return 1;//retorna 1 indicando que tudo ocorreu certo } //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------int remove_lista(Lista* li, char carac){ //remove um elemento qualquer da lista if (li == NULL) //verifico se minha lista valida return 0;//se no for valida retorna falso (0) Elem *ant, *no = li; //crio duas auxiliares, sendo que n recebe a copia da cabea li while (no != NULL && no -> dados.dado_caracter){ //percorro toda a lista procurando o elemento encontrado ant = no; //anterior passa a ser o n no = no-> prox;//n passa a ser o elemento seguinte a ele }//a lista s vai parar quando chegar no final da lista ou quando encontrar o elemento pedido if (no == NULL) //testa para ver se a cabea igual a null, se for, ou tinha um vazio desde o comeo ou percorri toda a lista e no encontrei o elemento return 0; // retorna no encontrado ou lista vazia if(no == *li) //se passou a condio anterior, tem que se achar on o elemento esta que pode ser no inicio da lista, se for remover o primeiro elemento *li = no->prox; //basta mudar a cabea da lista else//se for um elemento intermediario ou final

ant -> prox = no -> prox; // anterior que aponta para o proximo, vai receber o n que aponta para o prximo free (no); //liberar o espao de memoria do n return 1; //retornar 1 indicando que tudo ocorreu certo } //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------int remove_listaq(Lista* li, char carac){ //remove um elemento qualquer da lista if (li == NULL) //verifico se minha lista valida return 0;//se no for valida retorna falso (0) Elem *ant, *no = li; //crio duas auxiliares, sendo que n recebe a copia da cabea li while (no != NULL && no -> 'q'){ //percorro toda a lista procurando o elemento encontrado ant = no; //anterior passa a ser o n no = no-> prox;//n passa a ser o elemento seguinte a ele }//a lista s vai parar quando chegar no final da lista ou quando encontrar o elemento pedido if (no == NULL) //testa para ver se a cabea igual a null, se for, ou tinha um vazio desde o comeo ou percorri toda a lista e no encontrei o elemento return 0; // retorna no encontrado ou lista vazia if(no == *li) //se passou a condio anterior, tem que se achar on o elemento esta que pode ser no inicio da lista, se for remover o primeiro elemento *li = no->prox; //basta mudar a cabea da lista else//se for um elemento intermediario ou final ant -> prox = no -> prox; // anterior que aponta para o proximo, vai receber o n que aponta para o prximo free (no); //liberar o espao de memoria do n return 1; //retornar 1 indicando que tudo ocorreu certo } //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------int imprimirLista(Lista* li, struct caracter *al){ f (li == NULL || pos <= 0) //se a lista valida return 0; Elem *no = *li;//Ponteiro auxiliar apontado para inicio da lista while (no != NULL){//enquanto o no for diferente de NULL char algo = 'no'; //algum elemento printf("%c",algo); no = no->prox;//entao vou para o proximo elemento } return 1; //retorna 1 dizendo que deu certo a tarefa de busca na lista } //--------------------------------------//-------------------------------------//-------------------//-------

//--------------------------------------//-------------------------------------//-------------------//------int consulta_lista_mat(Lista* li, char carac, struct caracter *al){ if (li == NULL || pos <= 0) //se a lista valida return 0; Elem *no = *li;//Ponteiro auxiliar apontado para inicio da lista while (no != NULL && no->dados.dado_caracter != mat){//enquanto o no for diferente de NULL e tambem for diferente do procurado no = no->prox;//entao vou para o proximo elemento } if (no == NULL) //se a lista vazia ou percorri toda a lista e nao encotrei o dado return 0;// ja retorna o elemento 0 dizendo que nao tem como achar o elemento else{ *al = no -> dados;//seanao o conteudo do ponteiro recebera o valor dos dados em no return 1; //retorna 1 dizendo que deu certo a tarefa de busca na lista } } //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------int lista_vazia (Lista *li){ //Implementao da lista vazia if (li == NULL) //Se retornar NULL quer dizer que ela ta vazia return 1; //Ento verdadeiro retorna 1 if (*li == NULL)//Se a cabea da lista aponta direto para NULL return 1; //No tem contedo dentro da lista ou seja, ela est vazia return 0;//Se eu passei por todos esses if's e no retornou 1 ainda, ento retorna 0, indicando que a lista no est vazia. } //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------int tamanho_lista(Lista* li){ //Retorna o tamanho da lista em inteiro if (li == NULL) return 0; // Verifica se a lista vlida, caso no seja, retorna 0 ou falso int cont = 0; //Cria uma variavel contadora Elem* no = li; //Cria um n auxiliar que recebe o primeiro elemento da lista while (no != NULL) { //Enquanto o n for diferente de NULL vai apontar para o prximo cont ++; //Vai contar no = no-> prox; // E apontar para o prximo } // O n auxiliar criado, pois no se pode andar com a cabea da lista return cont; //Retornar o tamanho da lista em inteiro } //--------------------------------------//-------------------------------------//-------------------//-------

//--------------------------------------//-------------------------------------//-------------------//------void menu_simplismente_encadeada(){ int escolha; printf"Escolha uma das seguintes opes abaixo: \n" printf"1- Criar lista\n" printf"2- Inserir no inicio da lista\n" printf"3- Inserir no final da lista\n" //printf"4- Inserir um n com contedo item entre a posio apontada por q e a posicao seguinte\n" printf"5- Remover o elemento do inicio da lista\n" printf"6- Remover o elemento final da lista\n" printf"7- Remover o no com conteudo item\n" printf"8- Remover o no seguinte a um no apontado por q\n" printf"9- Imprimir a lista\n" printf"10- Verificar se um determinado item pertence a lista\n" printf"11- Verificar se a lista esta vazia\n" printf"12 - Retornar o tamanho da lista\n" scanf("%d",&escolha); //escolhe a funo switch (escolha){//Se ele escolher criar lista case 1: li = cria_lista (); //chamar a funo para criar a lista break; case 2: int x = insere_lista_inicio(li, dados); //retonra se deu certo ou no a insero printf("\n%d\n",x); break; case 3: int x = insere_lista_final (li, dados); //retorna se deu certo ou no a insero no final da lista printf("\n%d\n",x); break; /*case 4: int x = insere_lista_ordenada(li, dados); //Retorna se deu certo ou no a insero na lista break;*/ case 5: int x = remove_lista_inicio(li); //chama a funo de remover no inicio da lista printf("\n%d\n",x); break; case 6: int x = remove_lista_final(li); //chama a funcao para remover no final da lista printf("\n%d\n",x); break; case 7:

int x = remove_lista(li, item); //chama a funcao que remove um elemento qualquer printf("\n%d\n",x); break; /*case 8: remove o q int x = remove_listaq(li, item); printf("\n%d\n",x); break;*/ case 9: int x = imprimirLista(li, &dados);//imprimir a lista printf("\n%d\n",x); break; case 10: int x = consulta_lista_mat(li, posicao, &dados);//consultar determinado dado na lista, sendo dado caracter o valor que quero saber se consta na lista printf("\n%d\n",x); break; case 11: int x = lista_vazia(Lista* li); //chama a funo lista vazia printf("\n%d\n",x); break; case 12: int x = tamanho_lista(li); //chama o tamanho da lista printf("\n%d\n",x); break; default: printf("\nOpcao invalida!\n"); break; } } //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//-------

void menu(){ //menu de opoes 1 int escolha; printf("Escolha 1 para Lista Simplismente encadeada ou 2 para duplamente encadeada: /n"); scanf("%d",&escolha); switch (escolha) { case 1: void menu_simplismente_encadeada();

break; case 2: void menu_duplamente_encadeada(); default: printf("\nOpo invlida!\n") break; } } //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------void menu_duplamente_encadeada(){ int escolha; printf"Escolha uma das seguintes opes abaixo: \n" printf"1- Criar lista\n" printf"2- Inserir um elemento no inicio da lista: \n printf"12- Saber se a lista est vazia\n"" switch (escolha) { case 1: Lista* cria_lista(); //cria lista duplamente encadeada break; case 2: int x = Insere_lista_inicio(Li, dados); //inserir inicio da lista, printf("/n%d/n",x); break; case 3: int x = Insere_lista_final(Li, dados);//inserir no final da lista duplamente encadeada printf("/n%d/n",x); break; /*case 4: int x = Insere_lista_ordenadaq(Li, dados);//inserir o q printf("/n%d/n",x); break; case 5: int x = Insere_lista_ordenadap(Li, dados);//inserir o p printf("/n%d/n",x); break;*/ case 12: int x= Lista_vazia(lista* Li); printf("\n%d\n",x); break;

case 13: int x = Tamanho_lista(Li); printf("\n%d",x); default: break; } } //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------struct Elemento{ //tipo de lista duplamente encadeada struct elemento *ant; //ponteiro para anterior struct aluno dados;//campo de dados struct elemento *prox;//ponteiro para o proximo }; typedef struct Elemento elem;//Redefinicao da struct elemento Lista* cria_lista(){ lista* Li = (lista*) malloc(sizeof(lista));//reserva espao de memria para o tipo lista e retornar o ponteiro Li if (Li != NULL) { //se no for vazio, se a alocacao deu certo *LI = NULL;//a cabea aponta para nulo, sendo que Li ponteiro para ponteiro } return Li; } int Lista_vazia(lista* Li){;//prottipo da lista duplamente encadeada, a Lista_vazia recebe como parametro lista e retorna um inteiro if (Li == NULL) //quer dizer que no tenho uma lista return 1;//ou seja se a lista vazia, entao verdadeiro if (*Li == NULL)//Se o conteudo (a cabea da lista) for igual a NULL no tenho nenhum elemento ainda cadastrado em minha lista return 1; //informando novamente que a lista esta vazia return 0;//se as duas condies acima so falsas, retorna 0, indicando que a lista no est vazia, sendo que a lista valida e no estava vazia } int Tamanho_lista(lista *Li){ //vai retornar um valor inteiro que recebe a lista como parmetro if (Li == NULL) //se a lista for nula, quer dizer que no tenho uma lista return 0;//vai retornar zero, pois no tem tamanho int cont = 0; //inicializao de um contador para retornar um tamanho elem* No = *Li; //variavel auxiliar para recever a cabea da lista

while (No != NULL) { //vai percorrer a lista, contando quantos ns existem, enquanto o n no chegar no final, ou seja, for diferente de NULL cont ++;//eu conto mais 1 No = No -> prox;//e ando o prximo elemento } return cont;//quando chegar no final da lista eu retotno o tamanho } int Insere_lista_inicioLista(lista* Li, struct Caracter Al){//inserir elemento no inicio da lista duplamente encadeada, retorna 0 se deu erro ou 1 se deu certo if (Li == NULL)//primeiramente verifico se minha lista vlida return 0;//se for zero, eu no tenho uma lista elem* No = (elem*) malloc(sizeof(elem));// se eu tiver a lista, devo alocar espao para um novo no if (no == NULL)//se der erro na alocacao do elemento return 0;//retorna 0, caso no tenha nenhum erro e a lista vlida No->Dados = AL;//copio os dados para o nome que criei No->prox = (*Li);//digo que o prximo n vai apontar para o contedo Li No->ant = NULL;//o anterior passa a ser nulo //lista no vazia: apontar para o anterior if(*Li != NULL)//se o primeiro item da lsta for diferente de nulo (*Li)->ant = No;//entao eu no tinha uma lista vazia e o primeiro no da lista vai apontar para o anterior dele, para o No que foi inserido *Li = No;//no final faz-se a substituicao, que *li, vai receber o n return 1;//terminou tudo isso retorna 1 para indicar que deu tudo certo } int Insere_lista_final(lista* Li, struct Caracter Al){//recebe os parmetros if(Li == NULL)//verifico se a lista esta vazia return 0;//se tiver indico elem *No = (elem*) malloc(sizeof(elem));//aloco meu novo n if (No == NULL)//verifico se a alocacao funcionou return 0;//se nao funcionou retorno erro No->dados = Al;//copio os novos dados do novo no criado No->prox = NULL;//como foi inserido no final, foi alocado no final delel if ((*Li)==NULL) {//e a lista vazia devo tratar fazendo com que No->ant = NULL;//o anterior aponta para o nulo *Li = No;//e a cabea da lista passa a ser o elemento no }else{//caso a lista no estivesse vazia elem *aux = *Li;//tenho que chegar ate o final da lista criando um ponteiro auxiliar que recebe a cabea da lista while (aux->prox != NULL) {//enquanto ele aponta ao proximo for diferente de nulo, ou seja, no tiver chegado ao final da lista aux = aux-> prox;//sendo qe o auxiliar sempre recebe o proximo elemento

aux->prox = No;//ao chegar no final da fila aux->prox = No;//auxiliar vai apontar para o prximo elemento que sera o no No-> ant = aux;//o novo elemento vai apontar para o ultimo elemento } return 1;//retorna 1 indicando que deu certo a inserao } } int Insere_lista_ordenadaq(lista* Li, struct caracter Al){ //inserir lista duplamente encadeada if (li == NULL) return 0;//Verifico se a lista valida, e crio um elemento elem *No = (elem*) malloc(sizeof(elem));//Aloco memria para o elemento criado if (no == NULL) return 0;//Verifico se foi alocado o elemento No -> dados = Al;//verifico se a lista vazia, copio os dados para dentro dele if (lista_vazia(Li)) { //insere no inicio da lista No -> prox = NULL; //Se a lista for vazia, o prox vai apontar para null No->ant = NULL;// e tamber o anterior tera que estar apontando para null return 1;//retorna 1 finalizando a funo dizendo que deu certo } else{//procura onde inserir o elemento caso a lista no seja vazia elem *ant, *atual = *Li;//crio dois ponteiros auxiliares o atual apontando para a cabea da lista e um anterior while(atual != NULL && atual -> dados.dado_caracter != 'q'){// enquanto o atual for diferente de nulo, e enquanto o elemento estiver entre atual e outro, ant = atual; //anterior passa valer o atual e atual = atual -> prox;//o atual passa a valer o prximo elemento } if (atual == *Li){//se o elemento atual for no incio da lista no -> ant = NULL;//No apontando para anterior que aponta para nulo (*Li)->ant = No;//Ponteiro anterior aponta para no No->prox =(*Li);//proximo vai apontar para a lista *Li = No;//Lista passaa a valer no }else{//se nao for no inicio da lista entao a insercao no meio ou no final No -> prox = ant -> prox; //N prox, aponta para onde o n anterior estava apontando No->ant = ant;//no anterior, recebe o valor anterior do anterior ant->prox = No;//No ant passa apontar para o no anterior if (atual != NULL) //agora verificar se o atual for igual a nulo, eu estou no fim da lista atual->ant = No; //se for diferente, o atual recebe o anterior }

} return 1; } int Insere_lista_ordenadap(lista* Li, struct caracter Al){ //inserir lista duplamente encadeada if (li == NULL) return 0;//Verifico se a lista valida, e crio um elemento elem *No = (elem*) malloc(sizeof(elem));//Aloco memria para o elemento criado if (no == NULL) return 0;//Verifico se foi alocado o elemento No -> dados = Al;//verifico se a lista vazia, copio os dados para dentro dele if (lista_vazia(Li)) { //insere no inicio da lista No -> prox = NULL; //Se a lista for vazia, o prox vai apontar para null No->ant = NULL;// e tamber o anterior tera que estar apontando para null return 1;//retorna 1 finalizando a funo dizendo que deu certo } else{//procura onde inserir o elemento caso a lista no seja vazia elem *ant, *atual = *Li;//crio dois ponteiros auxiliares o atual apontando para a cabea da lista e um anterior while(atual != NULL && atual -> dados.dado_caracter != 'p'){// enquanto o atual for diferente de nulo, e enquanto o elemento estiver entre atual e outro, ant = atual; //anterior passa valer o atual e atual = atual -> prox;//o atual passa a valer o prximo elemento } if (atual == *Li){//se o elemento atual for no incio da lista no -> ant = NULL;//No apontando para anterior que aponta para nulo (*Li)->ant = No;//Ponteiro anterior aponta para no No->prox =(*Li);//proximo vai apontar para a lista *Li = No;//Lista passaa a valer no }else{//se nao for no inicio da lista entao a insercao no meio ou no final No -> prox = ant -> prox; //N prox, aponta para onde o n anterior estava apontando No->ant = ant;//no anterior, recebe o valor anterior do anterior ant->prox = No;//No ant passa apontar para o no anterior if (atual != NULL) //agora verificar se o atual for igual a nulo, eu estou no fim da lista atual->ant = No; //se for diferente, o atual recebe o anterior } } return 1; }

ListaDinEncCab.h:
// // ListaDinEncCab.h // Lista Dinmica encadeada com Cabeca // // Created by Fabrcio Daniel Freitas on 19/09/13. // Copyright (c) 2013 Fabrcio Daniel Freitas 0002752 - Valquria Soares 0002785. All rights reserved. // /* ListaDinEncCab.h: Definir - Os prottipos das funes; - O tipo de dado armazenado na lista; - O ponteiro "Lista". */ struct caracter{ //strutura para armazenar um dado qualquer, englobando int, char e float char dado_caracter[30]; }; typedef struct celula* Lista; //ponteiro definido no arquivo.c typedef struct elemento* lista;//ponteiro definido no arquivo c Lista* cria_lista(); //Funo para criar lista, retornando Lista* int insere_lista_inicio(Lista* li, struct caracter al);// vai conter os dados que ser inserido dentro da lista int insere_lista_final (Lista* li, struct caracter al);//vai conter os dados que sero inseridos no final da lista int insere_lista_ordenada(Lista* li, struct caracter al); //insere elemento na lista int remove_lista_inicio(Lista* li); //prottipo da funo de remover no inicio int remove_lista_final(Lista* li); //prottipo da funo para remover no final int remove_lista(Lista* li, char carac); //prottipo da funo para remover qualquer elemento da lista int remove_listaq(Lista* li, char carac); //remove qualquer elemento da lista no caso quereremos o relacionado a q int imprimirLista(Lista* li, struct caracter *al);// imprimi a lista int consulta_lista_mat(Lista* li, char carac, struct caracter *al); prototipo da funcao que encontra determinado dado na lista int lista_vazia (Lista *li); //Verificar se a lista est vazia //

int tamanho_lista(Lista* li); //Prottipo para retornar o tamanho da lista void menu(); //menu para escolher o arquivo void menu_simplismente_encadeada();//submenu de lista simplismente encadeadas void menu_duplamente_encadeada();//submenu da lista duplamente encadeada //--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------//--------------------------------------//-------------------------------------//-------------------//------struct aluno{//strutura para armazenar um dado qualquer, englobando int, char e float da duplamente encadeada char dado_caracter[30]; }; Lista* cria_lista();//Cria a lista duplamente encadeada int Lista_vazia(lista* Li);//prottipo da lista duplamente encadeada, a Lista_vazia recebe como parametro lista e retorna um inteiro int Tamanho_lista(lista *Li); //retorna o tamanho da lista duplamente encadeada int Insere_lista_inicioLista(lista* Li, struct caracter Al);//inserir elemento no inicio da lista duplamente encadeada, retorna 0 se deu erro ou 1 se deu certo int Insere_lista_final(lista* Li, struct caracter Al);//prottipo da funo de inserir no final da lista duplamente encadeada int Insere_lista_ordenadaq(lista* Li, struct caracter Al);//exercicio de q int Insere_lista_ordenadap(lista* Li, struct caracter Al);//exercicio de inserir o p