Estrutura de Dados

Estrutura de Dados
Snia Virginia Alves Frana
2007
Estrutura de Dados
ndice
1. Estrutura de Dados .............................................................................................................................. 4 2. Tipos de Estruturas de Dados .............................................................................................................. 5
2.1 Listas Lineares ..............................................................................................................................................5 2.2 Filas ................................................................................................................................................................6 2.3 Pilhas ..............................................................................................................................................................6 2.4 rvores...........................................................................................................................................................7
3. Implementao das Estruturas Estticas .......................................................................................... 12

3.1 Lista Esttica Desordenada........................................................................................................................12
3.1.1 Operaes Bsicas.................................................................................................................................................12 3.1.2 Algoritmo...............................................................................................................................................................15 3.1.3 Programa em C .....................................................................................................................................................17
3.2 Lista Esttica Ordenada.............................................................................................................................21

3.3 Fila Esttica .................................................................................................................................................32

3.4 Pilha Esttica...............................................................................................................................................38

4. Implementao das Estruturas Dinmicas ....................................................................................... 44

4.1 Alocao Dinmica......................................................................................................................................44 4.2 Lista Dinmica Desordenada .....................................................................................................................46
4.2.1 Operaes Bsicas.................................................................................................................................................47 4.2.2 Programa em C .....................................................................................................................................................49
4.3 Lista Dinmica Ordenada ..........................................................................................................................53

4.3.1 Operaes Bsicas.................................................................................................................................................53 4.3.2 Programa em C .....................................................................................................................................................56 2
Estrutura de Dados
4.4 Lista Duplamente Encadeada Ordenada..................................................................................................60

4.5 Fila Dinmica ..............................................................................................................................................66

4.6 Pilha Dinmica ............................................................................................................................................71

5. Ordenao e Pesquisa ........................................................................................................................ 76

5.1 Ordenao....................................................................................................................................................76
5.1.1 Mtodo da Ordenao por Troca ........................................................................................................................76 5.1.2 Mtodo da Ordenao por Seleo......................................................................................................................77 5.1.3 Mtodo da Ordenao por Insero....................................................................................................................79
5.2 Pesquisa........................................................................................................................................................80
Estrutura de Dados
1. Estrutura de Dados
Estruturas de dados e algoritmos so temas fundamentais da cincia da computao, sendo que so utilizados nas mais diversas reas e com os mais diferentes propsitos. Algoritmos manipulam dados. Quando estes dados esto organizados de forma coerente caracterizam uma estrutura de dados. So a organizao e os mtodos que manipulam determinada estrutura que lhe conferem singularidade. A escolha de uma estrutura de dados apropriada pode tornar um problema complicado em uma soluo trivial. O estudo das estruturas de dados est em constante desenvolvimento, apesar disso, existem estruturas clssicas que tm se mostrado padro de facto. As estruturas tm as suas caractersticas bsicas e tem finalidades diferentes. Podem ser implementadas usando vetores (esttica) ou ponteiros (dinmica) Conceito de Estrutura de Dados Para definir o que uma estrutura de dados devemos definir o que dado e tipo de dado. Podemos definir dado como um elemento sobre o qual sero efetuadas operaes e tipo de dado o conjunto de valores ao qual pertence um dado. Exemplos de tipos de dados so inteiro, real, lgico, etc. Uma primeira classificao para os tipos de dados : primitivos ou derivados. Os tipos de dados primitivos so aqueles que no podem ser decompostos, por exemplo: inteiro, real, lgico e caracter. Os tipos de dados derivados so aqueles definidos a partir dos tipos primitivos, por exemplo: vetores, matrizes, registros, etc. Os tipos de dados derivados podem ser homogneos ou heterogneos. Os tipos de dados homogneos agrupam dados primitivos do mesmo tipo, por exemplo: vetores, cadeias e matrizes. Os tipos de dados heterogneos agrupam dados primitivos de tipos diferentes, por exemplo: registros. Os tipos de dados tambm podem ser estticos ou dinmicos. Os tipos de dados estticos tm tamanho sempre finito, por exemplo: tipos primitivos, registros vetores e matrizes. Os tipos de dados dinmicos tm um tamanho que pode variar durante o seu tempo de vida, por exemplo: pilhas, filas, listas encadeadas e rvores. Visto isso, definimos estrutura de dados como um tipo derivado de dado concebido com o objetivo de ser manipulado de maneira sistemtica por algoritmos e, conseqentemente, por programas de computador.
4
Estrutura de Dados
2. Tipos de Estruturas de Dados

2.1 Listas Lineares
Uma das formas mais comumente usadas para se manter dados agrupados a lista. Afinal, quem nunca organizou uma lista de compras antes de ir ao mercado, ou ento uma lista dos amigos que participaro da festa? As listas tm-se mostrado um recurso bastante til e eficiente no dia-a-dia das pessoas. Em computao, no tem sido diferente: a lista uma das estruturas de dados mais empregadas no desenvolvimento de programas. Ao desenvolver uma implementao para listas lineares, o primeiro problema que surge : como podemos armazenar os elementos da lista, dentro do computador? Sabemos que antes de executar um programa, o computador precisa carregar seu cdigo executvel para a memria. Da rea de memria que reservada para o programa, uma parte usada para armazenar as instrues a serem executadas e a outra destinada ao armazenamento dos dados. Quem determina quanto de memria ser usado para as instrues o compilador. Alocar rea para armazenamento de dados entretanto, responsabilidade do programador. Uma lista linear pode ser implementada usando vetores ou ponteiros. Se for implementada usando vetores, deve estipular qual a quantidade de elementos que a lista pode armazenar. A memria para armazenamento dos dados alocada em tempo de compilao. Quando implementada usando ponteiros, a memria alocada conforme novos elementos so colocados na lista e desalocada quando elementos so retirados. Ou seja, vai alocando memria dinamicamente, em tempo de execuo. Tipos de Listas Lineares: 1. Lista esttica desordenada 2. Lista esttica ordenada 3. Lista dinmica desordenada 4. Lista dinmica ordenada 5. Lista dinmica duplamente encadeada Na lista desordenada os elementos so colocados na primeira posio vazia da lista (normalmente, no final). Na lista ordenada, escolhido um dado que ser o campo de ordenao da lista. Quando se
Estrutura de Dados
deseja inserir um novo elemento na lista, primeiro tem que ser verificado em que local ele dever ser colocado para que seja mantida a ordem da lista. Operaes bsicas das listas: inserir elemento, remover elemento, consultar elemento, alterar elemento, listagem dos elementos da lista.
2.2 Filas
Uma fila um tipo especial de lista linear em que as inseres so realizadas em um extremo, ficando as remoes restritas ao outro. O extremo onde os elementos so inseridos denominado final da fila, e aquele de onde so removidos denominado comeo da fila. Cada vez que uma operao de insero executada, um novo elemento colocado no final da fila. Na remoo, sempre retornado o elemento que aguarda h mais tempo na fila, ou seja, aquele posicionado no comeo. A ordem de sada corresponde diretamente ordem de entrada dos elementos na fila, de modo que os primeiros elementos que entram so sempre os primeiros a sair. Por este motivo, as filas so denominadas listas FIFO (First-In/First-Out) ou PEPS (Primeiro que Entra/Primeiro que Sai). Um exemplo bastante comum de filas verifica-se num balco de atendimento, onde pessoas formam uma fila para aguardar at serem atendidas. Naturalmente, devemos desconsiderar os casos de pessoas que furam a fila ou que desistem de aguardar! Diferentemente das filas no mundo real, o tipo abstrato de dados no suporta insero nem remoo no meio da lista. Um exemplo de utilizao em computao a implementao de uma fila de impresso. Se uma impressora compartilhada por vrias mquinas, deve-se adotar uma estratgia para determinar qual documento ser impresso primeiro. A estratgia mais simples tratar todas as requisies com a mesma prioridade e imprimir os documentos na ordem em que foram submetidos o primeiro submetido o primeiro a ser impresso.
2.3 Pilhas
Uma das estruturas de dados mais simples a pilha. Possivelmente por essa razo, a estrutura de dados mais utilizada em programao, sendo inclusive implementada diretamente pelo hardware da maioria das mquinas modernas. A idia fundamental da pilha que todo o acesso a seus elementos feito atravs do seu topo. Assim, quando um elemento novo introduzido na pilha, passa a ser o elemento do topo, e o nico elemento que pode ser removido da pilha o do topo. Isto faz com que os elementos da pilha sejam retirados na ordem inversa ordem em que foram introduzidos: o primeiro que sai o ltimo que entrou
6
Estrutura de Dados
(a sigla LIFO last in, first out usada para descrever esta estratgia ou UEPS em portugus - ltimo que Entra/Primeiro que Sai). Para entendermos o funcionamento de uma estrutura de pilha, podemos fazer uma analogia com uma pilha de pratos. Se quisermos adicionar um prato na pilha, o colocamos no topo. Para pegar um prato da pilha, retiramos o do topo. Assim, temos que retirar o prato do topo para ter acesso ao prximo prato. A estrutura de pilha funciona de maneira anloga. Cada novo elemento inserido no topo e s temos acesso ao elemento do topo da pilha. Existem trs operaes bsicas que devem ser implementadas numa estrutura de pilha: a operao para empilhar um novo elemento, inserindo-o no topo, a operao para desempilhar um elemento, removendo-o do topo e a operao para consultar qual elemento est no topo da pilha. comum nos referirmos a essas operaes pelos termos em ingls push (empilhar) e pop (desempilhar).
2.4 rvores
Nos tpicos anteriores examinamos as estruturas de dados que podem ser chamadas de unidimensionais ou lineares, como as listas. A importncia dessas estruturas inegvel, mas elas no so adequadas para representarmos dados que devem ser dispostos de maneira hierrquica. Por exemplo, os arquivos (documentos) que criamos num computador so armazenados dentro de uma estrutura hierrquica de diretrios (pastas). Existe um diretrio base dentro do qual podemos armazenar diversos subdiretrios e arquivos. Por sua vez, dentro dos sub-diretrios podemos armazenar outros sub-diretrios e arquivos, e assim por diante, recursivamente. Arvore so estruturas de dados adequadas para a representao de hierarquias. A forma mais natural para definirmos uma estrutura de rvore usando recursividade. Uma rvore composta por um conjunto de ns. Existe um n r, denominado raiz, que contm zero ou mais sub-rvores, cujas razes so ligadas diretamente a r. Esses ns razes das sub-rvores so ditos filhos do n pai, r. Ns com filhos so comumente chamados de ns internos e ns que no tm filhos so chamados de folhas, ou ns externos. Existem trs formas de representao grfica so: Representao por parnteses aninhados
( A (B) ( C (D (G) (H)) (E) (F (I)) ) )
Estrutura de Dados
Diagrama de incluso
Representao hierrquica
Motivao diversas aplicaes necessitam de estruturas mais complexas que as estruturas bsicas(listas, filas e pilhas); inmeros problemas podem ser modelados atravs de rvores rvores admitem tratamento computacional eficiente quando comparadas s estruturas mais genricas como os grafos (os quais, por sua vez so mais flexveis e complexos) Definio Uma rvore enraizada T, ou simplesmente uma rvore, um conjunto finito de elementos denominados ns ou vrtices tais que: T = 0 a rvore dita vazia ou existe um n especial r, chamado raiz de T; os restantes constituem um nico conjunto vazio ou so divididos em m (deve ser maior ou igual a 1) conjuntos distintos no vazios que so as subrvores de r, cada subrvore a qual , por sua vez, uma rvore. Subrvore Seja a rvore acima T = {A, B, ...}
Estrutura de Dados
A rvore T possui duas subrvores: Tb e Tc onde Tb = { B } e Tc = {C, D, ...} A subrvore Tc possui 3 subrvores: Td, Tf e Te onde Td = {D, G, H} Tf = {F, I} Te = {E} As subrvores Tb, Te, Tg, Th, Ti possuem apenas o n raiz e nenhuma subrvore. Ns filhos, pais, tios, irmos e av Seja v o n raiz da subrvore Tv de T. Os ns razes w1, w2, ... wj das subrvores de Tv so chamados filhos de v. v chamado pai de w1, w2, ... wj. Os ns w1, w2, ...wj so irmos. Se z filho de w1 ento w2 tio de z e v av de z. Grau de sada, descendente e ancestral Nmero de filhos de um n chamado grau de sada desse n. Se x pertence subrvore Tv, ento, x descendente de v e v ancestral, ou antecessor, de x. Se neste caso x diferente de v ento x descendente prprio de v e v ancestral prprio de x. N folha e n interior Um n que no possui descendentes prprios chamado de n folha, ou seja, um n folha aquele com grau de sada nulo. Um n que no folha (isto , possui grau de sada diferente de zero) chamado n interior ou n interno. Grau de uma rvore Grau de uma rvore o mximo entre os graus de seus ns. Floresta Uma floresta um conjunto de zero ou mais rvores.
Estrutura de Dados
Caminho, comprimento do caminho Uma seqncia de ns distintos v1, v2, ..., vk, tal que existe sempre entre ns consecutivos ( isto , entre v1 e v2, entre v2 e v3, ... , v(k-1) e vk) a relao " filho de"ou " pai de" denominada um caminho na rvore. Diz-se que v1 alcana vk e que vk alcanado por v1. Um caminho de vk vrtices obtido pela sequncia de k-1 pares. O valor k-1 o comprimento do caminho. Nvel (ou profundidade) e altura de um n Nvel ou profundidade, de um n o nmero de ns do caminho da raiz at o n. O nvel da raiz, portanto, 1. A altura de um n v o nmero de ns no maior caminho de v at um de seus descendentes. As folhas tm altura 1. Nvel da raiz (profundidade) e altura de uma rvore O nvel da raiz 1 (acima). A altura de uma rvore T igual ao mximo nvel de seus ns. Representa-se a altura de T por h(T) e a altura da subrvore de raiz v por h(v). rvore Ordenada
Uma rvore ordenada aquela na qual os filhos de cada n esto ordenados. Assume-se ordenao da esquerda para a direita. Desse modo, a rvore do primeiro exemplo ordenada, mas, a rvore abaixo no. rvores Isomorfas Duas rvores no ordenadas so isomorfas quando puderem se tornar coincidentes atravs de uma permutao na ordem das subrvores de seus ns. Duas rvores ordenadas so isomorfas quando forem coincidentes segundo a ordenao existente entre seus ns. rvore Cheia Uma rvore de grau d uma rvore cheia se possui o nmero mximo de ns, isto , todos os ns tm nmero mximo de filhos exceto as folhas, e todas as folhas esto na mesma altura.
10
Estrutura de Dados
rvore cheia de grau 2: implementao seqencial.
rvore Binria Uma rvore Binria T um conjunto finito de elementos denominados ns ou vrtices, tal que: T = 0 e a rvore dita vazia ou existe um n especial r, chamado raiz de T, os restantes podem ser divididos em dois subconjuntos disjuntos, Tre e Trd, que so as subrvores esquerda e direita de r, respectivamente e as quais, por sua vez, tambm so rvores binrias.
rvore Binria de Busca Uma rvore Binria de Busca T (ABB) ou rvore Binria de Pesquisa tal que ou T = 0 e a rvore dita vazia ou seu n raiz contm uma chave e: Todas as chaves da subrvore esquerda so menores que a chave da raiz. Todas as chaves da subrvore direita so maiores que a chave raiz. As subrvores direita e esquerda so tambm rvores Binrias de Busca.
11
Estrutura de Dados
3. Implementao das Estruturas Estticas

A seguir, faremos a implementao de todas as operaes bsicas das estruturas de dados vistas na seo anterior. Primeiramente, sero implementadas as estruturas estticas, usando vetores. Para estas, tambm sero feitos os algoritmos, com o objetivo de facilitar o aprendizado. As estruturas dinmicas sero implementadas diretamente na linguagem C, na seo 4.
3.1 Lista Esttica Desordenada

Esta estrutura implementada usando vetores e no se preocupa com ordenao. Os elementos so colocados na estrutura por ordem de chegada. Nas prximas sees ser descrita cada uma das operaes feitas nesta estrutura. Em seguida ser apresentado o algoritmo de cada operao e o programa em C. No exemplo, teremos uma lista com os dados dos alunos de uma turma (para simplificar, cada aluno tem apenas a matrcula e o nome).
3.1.1 Operaes Bsicas

Inserir Elemento A figura abaixo ilustra a insero de trs elementos em uma lista esttica desordenada. Inicialmente o vetor est vazio. O primeiro elemento a chegar o aluno Jos com matrcula 256. Este ser colocado na primeira posio do vetor.
12
Estrutura de Dados
Posteriormente, chegam mais dois alunos (Ana com matrcula 132 e Paulo com matrcula 429), que so colocados nas prximas posies disponveis do vetor (posio 2 e posio 3). Quando uma insero vai ser executada, necessrio verificar se o vetor tem posies disponveis. Caso contrrio, a insero no pode ser efetuada. Consultar Elemento Depois que um elemento inserido, a operao mais executada a consulta. Para a consulta necessrio saber qual elemento deseja consultar. Neste caso faremos uma consulta por matrcula. Para isso, a matrcula do aluno a ser consultado deve ser lida. feita uma visita ou varredura em todas as posies ocupadas do vetor, a procura do elemento.
No vetor da figura acima temos seis elementos. Vamos consultar o elemento de matrcula 578. Para encontr-lo, temos que varrer o vetor desde o seu incio e paramos na posio 4 que a posio onde ele se encontra. Caso quisssemos consultar o elemento de matrcula 192, iramos varrer todo o vetor, elemento a elemento e ao chegar na sexta posio (que a ultima) ficaramos sabendo que este elemento no se encontra no vetor. Quando um elemento encontrado, seus dados so apresentados e quando ele no est no vetor, uma mensagem de erro deve ser dada ao usurio. Alterar Elemento A alterao importante para o momento que se tenha cadastrado um dado incorretamente ou mesmo eles sofram uma alterao (exemplo: modificar o telefone do cliente). Para a alterar os dados de um elemento necessrio saber qual elemento deseja alterar. Neste caso faremos a busca por matrcula. Para isso, a matrcula do aluno a ser alterado deve ser lida.
13
Estrutura de Dados
feita a varredura em todas as posies ocupadas do vetor, a procura da matrcula. Assim que o elemento encontrado, seus dados devem ser apresentados ao usurio (neste caso a matrcula e o nome). Dessa forma ele pode verificar se realmente aquele o elemento a ser alterado, alm de informar qual campo dever ser alterado e qual o novo valor para aquele campo. Quando o elemento no encontrado, uma mensagem de erro deve ser dada ao usurio. Caso deseje, assim que os dados forem alterados, o registro do aluno apresentado novamente para o usurio. Deve tomar cuidado quando a alterao de um campo, influencie em outro campo, fazendo-se necessrio uma alterao indireta, por exemplo: o professor cadastrou a nota do aluno incorretamente. A alterao desta nota ir influenciar na mdia do aluno. Remover Elemento Caso um elemento no precise mais fazer parte da estrutura, ele pode ser removido. Para remover os dados de um elemento necessrio saber qual elemento deseja remover. J que iremos Neste caso faremos a busca por matrcula. Para isso, a matrcula do aluno a ser removido deve ser lida. feita uma varredura em todas as posies ocupadas do vetor, a procura da matrcula. Assim que o elemento encontrado, seus dados devem ser apresentados ao usurio (neste caso a matrcula e o nome). Dessa forma ele pode verificar se realmente aquele o elemento a ser removido. Quando o elemento no encontrado, uma mensagem de erro deve ser dada ao usurio. Numa lista desordenada, para a remoo ser efetuada, o ltimo elemento do vetor deve ser transferido para a posio do elemento removido.
Listagem de Todos os Elementos A operao de listagem possibilita a visualizao dos dados de todos os elementos cadastrados. feita uma varredura no vetor e todos os dados de todos os elementos so apresentados ao usurio. Caso a lista esteja vazia, ser apresentada uma mensagem.
14
Estrutura de Dados
3.1.2 Algoritmo
INICIO tipo regaluno = registro caracter: nome; inteiro: mat; real: media; fimregistro; tipo vetorturma = vetor [1..50] de regaluno; vetorturma: turma; inteiro: op, qa; mdulo inserir; se (qa = 50) ento escreva(no pode inserir); seno inicio qa qa + 1; leia(turma[qa].mat, turma[qa].nome, turma[qa].med); escreva(Inserido com sucesso); fim; fimse; fimmdulo; mdulo procura(inteiro: matprocurada); inteiro i, p; p 0; i 0; enquanto (i<qa) e (p=0) faa i i+1; se (turma[i].mat = matprocurada) ento p i; fimse; fimenquanto; retorne(p); fimmdulo; mdulo consultar; inteiro: posicao, matcon; leia(matcon); posicao procura(matcon); se (posicao <> 0) ento escreva(turma[posicao].mat, turma[posicao].nome, turma[posicao].med); seno escreva(Matricula no cadastrada); fimse; fimmdulo;
15
Estrutura de Dados
mdulo remover; inteiro: posicao, matrem, confirma; leia(matrem); posicao procura(matrem); se (posicao <> 0) ento inicio escreva(turma[posicao].mat, turma[posicao].nome, turma[posicao].med); escreva(Confirma remoo(1-sim/2-no)?); leia(confirma) se (confirma = 1) ento inicio turma[posicao] turma[qa]; qa qa - 1; escreva(Removido com Sucesso!); fim; seno escreva(Remocao Cancelada); fimse; fim; seno escreva(Matricula nao cadastrada); fimse; fimmdulo; mdulo alterar; inteiro: posicao, matalt,confirma; leia(matalt); posicao procura(matalt); se (posicao <> 0) ento inicio escreva(turma[posicao].mat, turma[posicao].nome, turma[posicao].med); escreva(Alterar Nome(1-sim/2-no)?); leia(confirma) se (confirma = 1) ento leia(turma[posicao].nome); fimse; escreva(Alterar Media(1-sim/2-no)?); leia(confirma) se (confirma = 1) ento leia(turma[posicao].med); fimse; escreva(turma[posicao].mat, turma[posicao].nome, turma[posicao].med); escreva(Alterado com Sucesso!); fim; seno escreva(Matricula no cadastrada); fimse; fimmdulo;
16
Estrutura de Dados
mdulo listagem; inteiro: i; se (qa > 0) ento inicio escreva(Matricula Nome Media); para i de 1 at qa faa escreva(turma[i].mat, turma[i].nome, turma[i].med); fimpara; fim; seno escreva(Turma Vazia); fimse; fimmdulo; qa 0; repita escreva(Informe a opcao desejada(1-inserir/2remover/3-consultar /4-alterar/5-listagem/0-sair: ); leia(op); escolha op caso 1: inserir; caso 2: remover; caso 3: consultar; caso 4: alterar; caso 5: listagem; fimescolha; at op = 0; FIM.
3.1.3 Programa em C
#include <stdio.h> #include <conio.h> #include <string.h> #include <stdlib.h> // Programa para executar funcoes de uma lista estatica desordenada typedef struct { int mat; char nome[31]; float media; }TAlunos; TAlunos turma[30]; const int maximo= 30; int qa, op; //*********************************************************************** void linha() { int i; for (i=1;i<=80;i++) printf("_"); printf("\n"); }
17
Estrutura de Dados
void cabec() { system("cls"); printf("Faculdade Santa Maria - Lista Estatica Desordenada\n"); linha(); } // modulo que retorna a posicao do elemento procurado int procura(int procurado) { int j, posicao; posicao = -1; for(j = 0; j<qa; j++) { if (procurado==turma[j].mat) { posicao = j; break; } } return posicao; } // modulo para mostrar o elemento na posicao indice void mostre (int pos) { printf("\n\nMatricula Aluno Media"); printf("\n--------------------------------------------"); printf("\n%9d %-20s %5.2f", turma[pos].mat, turma[pos].nome, turma[pos].media); printf("\n--------------------------------------------\n\n"); } //Inserir novo aluno void inserir() { int cont; do{ cabec(); printf("\nInserir Novo Aluno\n\n"); if (qa < maximo) // verifica se o vetor pode receber novo aluno { printf("\nMatricula do Aluno: "); scanf("%d",&turma[qa].mat); printf("\nNome: "); fflush(stdin); gets(turma[qa].nome); printf("\nMedia: "); scanf("%f",&turma[qa].media); qa++; printf("\n\nAluno Inserido com Sucesso!!!\n\n"); } else // vetor cheio { printf("\n\n\aNao Pode Inserir - Turma Cheia!!!\n\n"); getche(); break; } printf("\n\nInserir outro(1-sim/2-nao)? "); scanf("%d",&cont); }while (cont == 1); }
18
Estrutura de Dados
//Remover aluno cadastrado void remover() { int matrem, i, cont, achou, conrem; do{ cabec(); printf("\nRemover Aluno\n\n"); printf("\nMatricula do Aluno: "); scanf("%d",&matrem); achou = procura(matrem); if (achou != -1) { mostre(achou); printf("\nDeseja remover o aluno (1-sim/2-nao)? "); scanf("%d",&conrem); if (conrem==1) // verifica se quer remover { turma[i]= turma[qa-1]; qa--; printf("\n\nAluno removido com Sucesso!!!\n"); } else printf("\n\n\aO aluno nao foi removido!!!\n"); break; } else // aluno nao foi encontrado printf("\n\naNumero de Matricula Incorreto!!!!!!\n"); printf("\n\nRemover outro(1-sim/2-nao)? "); scanf("%d",&cont); }while (cont == 1); } //Consultar aluno cadastrado por matricula void consultarmat() { int i, matcon, achou, cont; do { cabec(); printf("\nConsultar Aluno por Matricula\n\n"); printf("\nMatricula do Aluno: "); scanf("%d",&matcon); achou = procura(matcon); if (achou != -1) mostre(achou); else // aluno nao foi encontrado printf("\n\n\aNumero de Matricula Incorreto!!!!!!\n"); printf("\n\nConsultar outro(1-sim/2-nao)? "); scanf("%d",&cont); } while (cont == 1); } //Alterar dados de aluno cadastrado void alterar() { int achou, i, matalt, conalt, cont; do { cabec(); printf("\nAlterar Dados do Aluno\n\n"); printf("\nMatricula do Aluno: ");
19
Estrutura de Dados
scanf("%d",&matalt); achou = procura(matalt); if (achou != -1) { mostre(achou); printf("\nDeseja Alterar o nome do aluno (1-sim/2-nao)? "); scanf("%d",&conalt); if (conalt == 1) { printf("\n\tNome : "); fflush(stdin); gets(turma[achou].nome); } printf("\nDeseja Alterar a Media do aluno (1-sim/2-nao)? "); scanf("%d",&conalt); if (conalt == 1) { printf("\nMedia: "); scanf("%f",&turma[achou].media); } mostre(achou); printf("\n\nAluno Alterado com Sucesso!!!\n"); } else // aluno nao foi encontrado printf("\n\n\aNumero de Matricula Incorreto!!!!!!\n"); printf("\n\nContinuar alterando aluno (1-sim/2-nao)? "); scanf("%d",&cont); } while (cont == 1); } //Imprimir relatorio com as informaoes de todos alunos void listagem() { int i; cabec(); printf("\nRelatorio Geral\n"); printf("\n\nMatricula Aluno Media"); printf("\n---------------------------------------------"); for(i = 0; i < qa; i++) printf("\n%9d %-20s %5.2f", turma[i].mat, turma[i].nome, turma[i].media); printf("\n---------------------------------------------"); printf("\n\nDigite qualquer tecla para sair... "); getche(); } //Programa principal main() { qa =0; do // tela com o menu do opcoes { cabec(); printf("Opcoes:\n\n"); printf(" 1- Inserir novo Aluno\n\n"); printf(" 2- Remover Aluno\n\n"); printf(" 3- Consultar Aluno por Matricula\n\n"); printf(" 4- Alterar Dados de Aluno\n\n"); printf(" 5- Listagem de Alunos\n\n"); printf(" 0- Sair do Programa\n");
20
Estrutura de Dados
linha(); printf("\n Informe a Opcao desejada: "); scanf("%d",&op); switch(op) { case 1: inserir(); break; case 2: remover(); break; case 3: consultarmat(); break; case 4: alterar(); break; case 5: listagem(); break; case 0: break; default : printf("\n\a Opcao Invalida! Tecle enter..."); getche(); break; } } while (op != 0); }
3.2 Lista Esttica Ordenada

Nesse tipo de lista, os elementos devem ser colocados na estrutura obedecendo a uma ordenao. Qualquer operao feita na estrutura, no pode afetar na ordenao da mesma. A vantagem dessa lista ser notada principalmente nos momentos que necessite percorrer a lista a procura de algum elemento. Aqui o programa anterior modificado, fazendo com que os alunos sejam armazenados no vetor por ordem de matrcula.

Inserir Elemento Para inserir um elemento em uma lista ordenada podem ocorrer cinco possibilidades: 1. a lista est cheia:nesse caso a insero cancelada; 2. a lista est vazia: o elemento colocado na primeira posio do vetor; 3. o elemento a ser inserido menor do que o primeiro da lista; 4. o elemento a ser inserido maior do que o ultimo da lista; 5. o elemento novo ser inserido entre elementos da lista. A figura a seguir ilustra a insero de quatro elementos em uma lista esttica ordenada. Inicialmente o vetor est vazio. O primeiro elemento a chegar o aluno Jos com matrcula 256. Este ser colocado na primeira posio do vetor. Posteriormente, chega Ana com matrcula 132. Para que a lista fique ordenada, deve verificar em qual posio o elemento deve ser inserido. Nesse caso, a matrcula 132 menor que 256
21
Estrutura de Dados
(que a primeira da lista). Assim, todos os elementos a partir da posio onde o elemento de matrcula 256 se encontra, devem se deslocar uma posio, abrindo espao para o elemento ser inserido. Mais tarde chega o elemento de matrcula 429. Esta matrcula maior do que todas as matrculas do vetor, portanto, ele inserido no final do vetor, sem necessidade de deslocamentos. Por fim, chega o elemento de matrcula 197. Devemos descobrir onde se encontra o primeiro elemento maior do que o que ser inserido, ou seja, seu sucessor imediato. Neste caso, ele deve entrar na posio do elemento de matrcula 256. O espao deve ser liberado, fazendo-se necessrio o deslocamento de todos os elementos a partir do elemento de matrcula 256. A principal questo da insero ordenada descobrir o local onde o elemento deve ser inserido e, se necessrio, fazer os deslocamentos.
22
Estrutura de Dados
Consultar Elemento A matrcula do aluno a ser consultado deve ser lida. feita uma varredura em todas as posies ocupadas do vetor, a procura da matrcula. No caso de uma lista ordenada, se estivssemos procurando um aluno de matrcula 120, assim que fizssemos a leitura da primeira matrcula do vetor, j saberamos que a matrcula 120 no est no vetor, evitando uma varredura at o final do vetor. Na estrutura ordenada, as consultas so mais eficientes.
Alterar Elemento A diferena da alterao ordenada e desordenada que, numa lista ordenada, se o campo que ordena a lista for alterado, deve verificar se a lista permanece ordenada. Por exemplo, se alterarmos a matrcula de um aluno, pode ser que a lista fique desordenada. Tem duas solues - no permitir a alterao do campo que ordena a lista ou sempre que o campo for alterado verificada se a lista continua ordenada, os demais passos para alterar so iguais lista desordenada. Remover Elemento Comeamos com a leitura da matrcula do aluno a ser removido. feita uma varredura em todas as posies ocupadas do vetor, a procura da matrcula. Assim que o elemento encontrado, seus dados devem ser apresentados ao usurio (neste caso a matrcula e o nome). Dessa forma ele pode verificar se realmente aquele o elemento a ser removido. Quando o elemento no encontrado, uma mensagem de erro deve ser dada ao usurio. No exemplo da figura a seguir, desejamos remover o elemento de matrcula 256. Para que a lista fique contnua e ordenada, todos os elementos que vem depois do elemento que ser removido, devem ser trazidos uma posio a frente.
23
Estrutura de Dados
Listagem de Todos os Elementos A operao de listagem possibilita a visualizao dos dados de todos os elementos cadastrados. feita uma varredura no vetor e todos os dados de todos os elementos so apresentados ao usurio.
3.2.2 Algoritmo
INICIO tipo regaluno = registro caracter: nome; inteiro: mat; real: media; fimregistro; tipo vetorturma = vetor [1..50] de regaluno; vetorturma: turma; inteiro: op, qa; mdulo verificalocal(inteiro: matins); inteiro i, local; local 0; se (qa = 0) ento local 1; seno inicio se (matins > turma[qa].mat) ento local qa + 1; seno inicio local 1; enquanto (turma[local].mat < matins) faa local local + 1; fimenquanto;
24
Estrutura de Dados
para i de qa at local passo -1 faa turma[i+1]=turma[i]; fimpara; fim; fimse; fim; fimse; retorne (local); fimmdulo; mdulo inserir; inteiro: l, matl; se (qa = 50) ento escreva(no pode inserir); seno inicio leia(matl); l verificalocal(matl); turma[l].mat matl; leia(turma[l].nome, turma[l].med); qa qa + 1; escreva(Inserido com sucesso); fim; fimse; fimmdulo; mdulo procura(inteiro: matprocurada); inteiro i, p; p 0; i 1; enquanto (i<=qa) e (p=0) e (turma[i].mat<=matprocurada) faa se (turma[i].mat = matprocurada) ento p i; fimse; i i+1; fimenquanto; retorne(p); fimmdulo; mdulo consultar; inteiro: posicao, matcon; leia(matcon); posicao procura(matcon); se (posicao <> 0) ento escreva(turma[posicao].mat, turma[posicao].nome, turma[posicao].med); seno escreva(Matricula no cadastrada); fimse; fimmdulo;
25
Estrutura de Dados
mdulo remover; inteiro: posicao, matrem, confirma, i; leia(matrem); posicao procura(matrem); se (posio <> 0) ento inicio escreva(turma[posicao].mat, turma[posicao].nome, turma[posicao].med); escreva(Confirma remoo(1-sim/2-no)?); leia(confirma) se (confirma = 1) entao inicio para i de posicao at qa-1 faa turma[i] turma[i+1]; fimpara; qa qa - 1; escreva(Removido com Sucesso!); fim seno escreva(Remocao Cancelada); fimse; fim; seno escreva(Matricula no cadastrada); fimse; fimmdulo; mdulo alterar; inteiro: posicao, matalt,confirma; leia(matalt); posicao procura(matalt); se (posicao <> 0) ento inicio escreva(turma[posicao].mat, turma[posicao].nome, turma[posicao].med); escreva(Alterar Nome(1-sim/2-no)?); leia(confirma) se (confirma = 1) ento leia(turma[posicao].nome); fimse; escreva(Alterar Media(1-sim/2-no)?); leia(confirma) se (confirma = 1) ento leia(turma[posicao].med); fimse; escreva(turma[posicao].mat, turma[posicao].nome, turma[posicao].med); escreva(Alterado com Sucesso!); fim; seno escreva(Matricula no cadastrada); fimse; fimmdulo;
26
Estrutura de Dados
mdulo listagem; inteiro: i; se (qa > 0) ento inicio escreva(Matricula Nome Media); para i de 1 at qa faa escreva(turma[i].mat, turma[i].nome, turma[i].med); fimpara; fim; seno escreva(Turma Vazia); fimse; fimmdulo; qa 0; repita escreva(Informe a opcao desejada(1-inserir/2remover/3-consultar /4-alterar/5-listagem/0-sair: ); leia(op) escolha op caso 1: inserir; caso 2: remover; caso 3: consultar; caso 4: alterar; caso 5: listagem; fimescolha ate op = 0; FIM.
3.2.3 Programa em C
#include <stdio.h> #include <conio.h> #include <stdlib.h> // Programa para executar funcoes de uma lista estatica ordenada. typedef struct { int mat; char nome[31]; float media; }TAlunos; TAlunos turma[30]; TAlunos al; const int maximo= 30; int qa, op; void linha() { int i; for (i=1;i<=80;i++) printf("_"); printf("\n"); }
27
Estrutura de Dados
void cabec() { system("cls"); printf("Faculdade Santa Maria - Lista Estatica Ordenada\n"); linha(); } // Verificar em que posicao deve ser colocado o novo aluno a ser inserido. void colocarordem() { int i, local; local = -1; if (qa==0) turma[0] = al; else { for (i=0;i<qa;i++) { if (al.mat<turma[i].mat) { local = i; break; } } if (local==-1) turma[qa] = al; else { for (i=qa;i>local;i--) turma[i]=turma[i-1]; turma[local]=al; } } } // modulo que retorna a posicao do elemento procurado int procura(int procurado) { int j, posicao; posicao = -1; for(j = 0; j<qa; j++) { if (procurado==turma[j].mat) { posicao = j; break; } else { if (procurado<turma[j].mat) break; } } return posicao; } // modulo para mostrar o elemento na posicao indice void mostre (int indice) { printf("\n\nMatricula Aluno Media"); printf("\n---------------------------------------------"); printf("\n%9d %-20s %5.2f", turma[indice].mat, turma[indice].nome, turma[indice].media); printf("\n----------------------------------------------\n\n"); }
28
Estrutura de Dados
// Inserir um novo aluno na escola void inserir() { int cont; do{ cabec(); printf("\nInserir Novo Aluno\n"); if (qa < maximo) // verifica se o vetor pode receber novo aluno { printf("\nMatricula do Aluno: "); scanf("%d",&al.mat); printf("\nNome: "); fflush(stdin); gets(al.nome); printf("\nMedia: "); scanf("%f",&al.media); colocarordem(); qa++; printf("\n\nAluno Inserido com Sucesso!!!\n"); } else // vetor cheio { printf("\n\n\aNao Pode Inserir - Turma Cheia!!!\n"); getche(); break; } printf("\n\nContinuar inserindo aluno (1-sim/2-nao)? "); scanf("%d",&cont); }while (cont == 1); } // Remover um aluno da escola void remover() { int matrem, i, achou, continuar, conrem; do{ cabec(); printf("\nRemover Aluno\n\n"); printf("\nMatricula do Aluno: "); scanf("%d",&matrem); achou = procura(matrem); if (achou!=-1) { mostre(achou); printf("\nDeseja remover o aluno (1-sim/2-nao)? "); scanf("%d",&conrem); if (conrem == 1) { for (i=achou;i<qa;i++) turma[i]=turma[i+1]; qa--; printf("\n\nAluno removido com Sucesso!!!\n"); } else printf("\n\n\aO aluno nao foi removido!!!\n"); } else printf("\n\n\aNumero de Matricula Incorreto!!!!!!\n"); printf("\n\nContinuar removendo aluno (1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1); }
29
Estrutura de Dados
//Consultar um aluno da escola void consultar() { int matcon, achou, continuar; do{ cabec(); printf("\nConsultar Aluno\n\n"); printf("\nMatricula do Aluno: "); scanf("%d",&matcon); achou = procura(matcon); if (achou!=-1) mostre(achou); else printf("\n\n\aNumero de Matricula Incorreto!!!!!!\n"); printf("\n\nContinuar consultando aluno(1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1); } //Fazer alteracao dos dados de um aluno void alterar() { int matalt, achou, conalt, continuar; do{ cabec(); printf("\nAlterar Dados do Aluno\n\n"); printf("\nMatricula do Aluno: "); scanf("%d",&matalt); achou = procura(matalt); if (achou!=-1) { mostre(achou); printf("\nDeseja Alterar o nome do aluno (1-sim/2-nao)? "); scanf("%d",&conalt); if (conalt == 1) { printf("\nNome : "); fflush(stdin); gets(turma[achou].nome); } printf("\nDeseja Alterar a media do aluno (1-sim/2-nao)? "); scanf("%d",&conalt); if (conalt == 1) { printf("\nMedia: "); scanf("%f",&turma[achou].media); } mostre(achou); printf("\n\nAluno Alterado com Sucesso!!!\n"); } else printf("\n\n\aNumero de Matricula Incorreto!!!!!!\n"); printf("\n\nContinuar alterando aluno(1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1); }
30
Estrutura de Dados
//Imprimir o relatorio contendo os dados de todos os alunos void listagem() { int i; float soma=0; cabec(); printf("\nRelatorio Geral\n"); printf("\nMatricula Aluno Media"); printf("\n--------------------------------------------"); for(i = 0; i<qa; i++) { printf("\n%9d %-20s %5.2f", turma[i].mat, turma[i].nome, turma[i].media); soma += turma[i].media; } printf("\n--------------------------------------------"); printf("\n\nMedia da turma = %.2f",soma/qa); printf("\n\nDigite qualquer tecla para sair"); getche(); } //Programa principal main() { qa=0; do { cabec(); printf("\n Opcoes: \n\n"); printf("\t1- Inserir novo Aluno\n\n"); printf("\t2- Remover Aluno\n\n"); printf("\t3- Consultar Aluno\n\n"); printf("\t4- Alterar dados de Aluno\n\n"); printf("\t5- Listagem de Alunos\n\n"); printf("\t0- Sair do Programa\n\n\n"); linha(); printf("Informe a Opcao desejada: "); scanf("%d",&op); switch(op) { case 1: inserir(); break; case 2: remover(); break; case 3: consultar(); break; case 4: alterar(); break; case 5: listagem(); break; case 0: break; default : printf("\nOpcao Invalida! Tecle enter.."); getche(); break; } }while(op!=0); }
31
Estrutura de Dados
3.3 Fila Esttica

Nesta seo iremos verificar as operaes em uma fila implementada com vetores. As operaes bsicas em uma fila: inserir elemento no final da fila, remover o elemento do incio da fila, consultar o primeiro da fila, listar todos oser implementado simula a fila de atendimento de um banco.

Inserir Elemento Todo elemento que vai ser inserido em uma fila colocado no final da estrutura. A figura abaixo ilustra a chegada de trs clientes na fila. Os clientes vo sendo inseridos por ordem de chegada.
Consultar Primeiro da Fila Em uma fila, a consulta feita apenas do primeiro elemento da fila. Assim, teremos a informao de qual ser o prximo elemento a ser retirado. Na figura abaixo, o primeiro elemento da fila o cliente Joo, com conta nmero 3456. Quando o vetor estiver vazio, apresentada uma mensagem de fila vazia ao usurio.
32
Estrutura de Dados
Remover Primeiro da Fila Em uma fila, o elemento removido sempre o que chegou h mais tempo, ou seja, o elemento da primeira posio do vetor. Na figura abaixo iremos remover o primeiro elemento da fila (neste caso, Joo). Os elementos seguintes devem ser deslocados uma posio a frente. Com isso, o segundo elemento da fila passa a ser o primeiro, o terceiro passa a ser o segundo e assim por diante.
Listagem de Todos os Elementos da Fila A operao de listagem possibilita a visualizao dos dados de todos os elementos da fila. feita uma varredura no vetor e todos os dados de todos os elementos so apresentados ao usurio.
3.3.2 Algoritmo
INICIO tipo regfila = registro caracter: nome; inteiro: conta, agencia; fimregistro; tipo vetorfila = vetor [1..50] de regfila; vetorfila: fila; inteiro: op, qe; mdulo inserir; se (qe = 50) ento escreva(Fila cheia - no pode inserir); seno
33
Estrutura de Dados
inicio qe qe + 1; leia(fila[qe].agencia, fila[qe].conta, fila[qe].nome); escreva(Inserido com sucesso); fim; fimse; fimmodulo; mdulo consultarprimeiro; se (qe <> 0) ento escreva(fila[1].agencia, fila[1].conta, fila[1].nome); seno escreva(Fila Vazia); fimse; fimmdulo; mdulo removerprimeiro; inteiro: confirma, i; se (qe <> 0) ento inicio escreva(fila[1].agencia, fila[1].conta, fila[1].nome); escreva(Confirma remoo(1-sim/2-no)?); leia(confirma); se (confirma = 1) ento inicio para i de 1 at qe-1 faa turma[i] turma[i+1]; fimpara; qe qe - 1; escreva(Removido com Sucesso); fim; seno escreva(Remocao Cancelada); fimse; fim; seno escreva(Fila Vazia); fimse; fimmdulo; mdulo listagem; inteiro: i; se (qe > 0) ento inicio escreva(Agencia Conta Nome); para i de 1 at qe faa escreva(fila[i].agencia, fila[i].conta, fila[i].nome); fimpara; fim; seno escreva(Fila Vazia); fimse; fimmdulo;
34
Estrutura de Dados
qe 0; repita escreva(Informe a opcao desejada(1-inserir/2-remover primeiro /3-consultar primeiro/4-listagem/0-sair: ); leia(op); escolha op caso 1: inserir; caso 2: removerprimeiro; caso 3: consultarprimeiro; caso 4: listagem; fimescolha; at op = 0; FIM.
3.3.3 Programa em C
#include <stdio.h> #include <conio.h> #include <stdlib.h> // Implementao de fila usando vetor /* Estrutura que ser usada para cada elemento da fila */ typedef struct tipo_cliente { int conta, agencia; char nome[15]; int tipo; } TCliente;
TCliente cliente[30]; TCliente cl; int op, tamfila; /************************************************************************/ void linha() { int i; for (i=1;i<=80;i++) printf("_"); printf("\n"); } void cabec() { system("cls"); printf("Banco Poupe Muito - Fila Estatica\n"); linha(); } /* Funcao para inserir um novo cliente no final da fila */ void inserir () { int continuar; do{ // leitura dos dados do cliente
35
Estrutura de Dados
cabec(); printf("\n Chegada de novo cliente na fila \n"); printf("\n Numero da conta: "); scanf("%d",&cl.conta); printf("\n Numero da agencia: "); scanf("%d",&cl.agencia); printf("\n Nome: "); fflush(stdin); gets(cl.nome); printf("\n Tipo de cliente(1- especial, 2-normal): "); scanf("%d",&cl.tipo); // Inserir cliente na fila if (tamfila <30) /* Se ainda tem vaga na fila */ { cliente[tamfila] = cl; tamfila++; printf("\n\nInserido com Sucesso!!!!\n\n"); } else /* Fila cheia*/ printf("\n\nFila cheia, cliente nao inserido!!!!\n\n"); printf("\n Continuar inserindo (1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1); // verifica se quer continuar inserindo } /* Consultar um primeiro cliente da fila */ void consultarprimeiro() { cabec(); printf("\nConsulta primeiro cliente da fila\n"); if (tamfila != 0) { printf("\n\nAgencia Conta Nome Tipo\n"); printf("--------------------------------------------------------\n"); printf("%4d %4d %-15s %2d\n", cliente[0].agencia,cliente[0].conta, cliente[0].nome, cliente[0].tipo); printf("--------------------------------------------------------\n"); } else printf("\n\nA fila est vazia!!\n\n"); printf("\n\nTecle enter para voltar para o menu\n"); getche(); } /* remover um cliente da fila */ void retirafila() { int i, confrem, continuar; do{ cabec(); printf("\nRetira primeiro cliente da fila \n"); if (tamfila != 0) // verifica se tem elementos na fila { printf("\n\nAgencia Conta Nome Tipo\n"); printf("---------------------------------------------------\n"); printf("%4d %4d %-15s %2d\n", cliente[0].agencia, cliente[0].conta, cliente[0].nome, cliente[0].tipo); printf("---------------------------------------------------\n");
36
Estrutura de Dados
printf("\n\nconfirma retirada do cliente (1-sim, 2-nao)? "); scanf("%d",&confrem); if (confrem ==1) // confirma que quer remover { for (i=0; i<tamfila; i++) cliente[i] = cliente[i+1]; tamfila--; printf("\n\n Retirado da fila com sucesso!!!!\n\n"); } else // cancelou a remocao printf("\n\n Retirada cancelada\n\n"); } else // fila vazia printf("\n\nFila vazia!!\n\n"); printf("\n\nDeseja retirar outro cliente(1-sim, 2-nao)? "); scanf("%d",&continuar); }while (continuar ==1); // continuar retirando cliente da fila } /* Lista todos os clientes da fila */ void listar () { int i; cabec(); printf("\nListagem de clientes da fila\n"); if (tamfila != 0) { printf("\n\nAgencia Conta Nome Tipo\n"); printf("-------------------------------------------------------\n"); for (i=0;i<tamfila;i++) printf("%4d %4d %-15s %2d\n", cliente[i].agencia,cliente[i].conta, cliente[i].nome, cliente[i].tipo); printf("-------------------------------------------------------\n"); printf("\n\nQuantidade de clientes na fila = %d\n",tamfila); } else printf("\n\n Nao tem nenhum cliente na fila"); printf("\n\n\nTecle enter para voltar para o menu\n"); getche(); } // Programa principal main() { tamfila= 0; do { cabec(); printf("\nOpcoes: "); printf("\n\n 1 - Inserir cliente na fila"); printf("\n\n 2 - Consultar primeiro da fila"); printf("\n\n 3 - Retirar primeiro cliente da fila"); printf("\n\n 4 - Listar todos os clientes da fila"); printf("\n\n 0 - para sair \n"); linha(); printf("\nEntre com a sua opcao: "); scanf("%d", &op); /* Le a opcao do usuario */ switch(op) { case 1: inserir(); break;
37
Estrutura de Dados
} } while (op != 0); }
case 2: consultarprimeiro();break; case 3: retirafila(); break; case 4: listar(); break; case 0: break; default: printf("\nOpcao nao valida");
3.4 Pilha Esttica

A seguir vamos analisar a implementao de pilha esttica. Neste exemplo ser implementada uma pilha de livros.

Inserir Elemento Todo elemento que vai ser inserido em uma pilha colocado no final da estrutura. A figura abaixo ilustra a chegada de trs livros colocados na pilha. Os livros vo sendo inseridos por ordem de chegada.
Consultar Topo da Pilha Em uma pilha, a consulta feita apenas do elemento do topo, ou seja o ltimo elemento a ser inserido. Assim, teremos a informao de qual ser o prximo elemento a ser retirado. Na figura abaixo, o elemento do topo da pilha o livro de cdigo 4 e ttulo Fsica, armazenado na posio 3 do vetor. Quando o vetor estiver vazio, apresentada uma mensagem de pilha vazia ao usurio.
38
Estrutura de Dados
Remover Topo da Pilha Em uma pilha, o elemento removido sempre o que chegou h menos tempo, ou seja, o elemento da ltima posio do vetor. Na figura abaixo iremos remover o elemento do topo da pilha (neste caso, o elemento da posio 3). No h necessidade de deslocamentos.
Listagem de Todos os Elementos da Pilha A operao de listagem possibilita a visualizao dos dados de todos os elementos da pilha. feita uma varredura no vetor e todos os dados de todos os elementos so apresentados ao usurio.
3.4.2 Algoritmo
INICIO tipo regpilha = registro caracter: titulo; inteiro: codigo, editora; fimregistro; tipo vetorpilha = vetor [1..50] de regpilha; vetorpilha: pilha; inteiro: op, qe; mdulo inserir; se (qe = 50) ento escreva(Pilha cheia - no pode inserir); seno inicio qe qe + 1;
39
Estrutura de Dados
leia(pilha[qe].codigo, pilha[qe].editora, pilha[qe].titulo); escreva(Inserido com sucesso); fim; fimse; fimmdulo; mdulo consultartopo; se (qe <> 0) ento escreva(pilha[qe].codigo, pilha[qe].editora, pilha[qe].titulo); seno escreva(Pilha Vazia); fimse; fimmdulo; mdulo removertopo; inteiro: confirma; se (qe <> 0) ento inicio escreva(pilha[qe].codigo, pilha[qe].editora, pilha[qe].titulo); escreva(Confirma remoo(1-sim/2-no)?); leia(confirma); se (confirma = 1) ento inicio qe qe - 1; escreva(Removido com Sucesso); fim seno escreva(Remocao Cancelada); fimse; fim seno escreva(Pilha Vazia); fimse; fimmdulo; mdulo listagem; inteiro: i; se (qe > 0) ento inicio escreva(Codigo Editora Titulo); para i de 1 at qe faa escreva(pilha[i].codigo, pilha[i].editora, pilha[i].titulo); fimpara; fim; seno escreva(Pilha Vazia); fimse; fimmdulo; qe 0; repita escreva(Informe a opcao desejada(1-inserir/2-remover topo /3-consultar topo/4-listagem/0-sair: );
40
Estrutura de Dados
leia(op); escolha op caso 1: inserir; caso 2: removertopo; caso 3: consultartopo; caso 4: listagem; fimescolha; at op = 0; FIM.
3.4.3 Programa em C
#include <stdio.h> #include <conio.h> #include <stdlib.h> // Implementao de pilha usando vetor /* Estrutura que ser usada para cada elemento da pilha */ typedef struct tipo_livro { int codigo, editora; char titulo[30]; } TLivro;
TLivro livro[30]; TLivro ll; int op, tampilha; /***********************************************************************/ void linha() { int i; for (i=1;i<=80;i++) printf("_"); printf("\n"); } void cabec() { system("cls"); printf("Pilha de Livros - Estatica\n"); linha(); } /* Funcao para inserir um novo livro na pilha */ void inserir () { int continuar; do{ cabec(); printf("\nColocar livro no topo da pilha \n"); printf("\nCodigo do livro: "); scanf("%d",&ll.codigo); printf("\nTitulo do Livro: "); fflush(stdin); gets(ll.titulo); printf("\nEditora(1- Campus, 2-Makron Books, 3-Moderna): "); scanf("%d",&ll.editora);
41
Estrutura de Dados
// Inserir livro na pilha if (tampilha <30) /* Se ainda tem vaga na pilha */ { livro[tampilha] = ll; tampilha++; printf("\n\nInserido com Sucesso!!!!\n\n"); } else /* Pilha cheia*/ printf("\n\nPilha cheia, Livro nao inserido!!!!\n\n"); printf("\n Continuar inserindo (1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1); // verifica se quer continuar inserindo livros } /* Consultar topo da pilha*/ void consultatopo() { cabec(); printf("\nConsulta topo da pilha\n"); if (tampilha != 0) { printf("\n\nCod Titulo Editora\n"); printf("-----------------------------------------------------\n"); printf("%2d %-20s %7d\n", livro[tampilha-1].codigo, livro[tampilha-1].titulo, livro[tampilha-1].editora); printf("-----------------------------------------------------\n"); } else printf("\n\nA pilha esta vazia!!\n\n"); printf("\n\nTecle enter para voltar para o menu\n"); getche(); } /* remover um livro da pilha */ void retirapilha() { int i, confrem, continuar; do{ cabec(); printf("\nRetira livro do topo da pilha \n"); if (tampilha != 0) // verifica se tem elementos na pilha { printf("\n\nCodigo Titulo Editora\n"); printf("---------------------------------------------------\n"); printf("%6d %-20s %7d\n", livro[tampilha-1].codigo, livro[tampilha-1].titulo, livro[tampilha-1].editora); printf("---------------------------------------------------\n"); printf("\n\nconfirma retirada do livro (1-sim, 2-nao)? "); scanf("%d",&confrem); if (confrem ==1) // confirma que quer remover { tampilha--; printf("\n\n Retirado da Pilha com sucesso!!!!\n\n"); } else // cancelou a remocao printf("\n\n Retirada cancelada\n\n"); } else // pilha vazia printf("\n\nPilha vazia!!\n\n"); printf("\n\nDeseja retirar outro livro(1-sim, 2-nao)? "); scanf("%d",&continuar);
42
Estrutura de Dados
}while (continuar ==1); // continuar retirando livro da pilha } /* Lista todos os livros da pilha */ void listar () { int i; cabec(); printf("\nListagem dos livros da pilha\n"); if (tampilha != 0) { printf("\n\nCodigo Titulo Editora\n"); printf("-----------------------------------------------------\n"); for (i=tampilha-1;i>=0;i--) printf("%6d %-20s %7d\n", livro[i].codigo, livro[i].titulo, livro[i].editora); printf("-----------------------------------------------------\n"); printf("\n\nQuantidade de livros na pilha = %d\n",tampilha); } else printf("\n\n Nao tem nenhum livro na pilha"); printf("\n\n\nTecle enter para voltar para o menu\n"); getche(); } // Programa principal main() { tampilha= 0; do { cabec(); printf("\nOpcoes: \n"); printf("\n 1 - Inserir livro na pilha"); printf("\n 2 - Consultar topo da pilha"); printf("\n 3 - Retirar livro do topo"); printf("\n 4 - Listar todos os livros da pilha"); printf("\n 0 - Sair \n"); linha(); printf("\nEntre com a sua opcao: "); scanf("%d", &op); /* Le a opcao do usuario */ switch(op) { case 1: inserir(); break; case 2: consultatopo();break; case 3: retirapilha(); break; case 4: listar(); break; case 0: break; default: printf("\n\n Opcao invalida"); getche(); break; } } while (op != 0); }
43
Estrutura de Dados
4. Implementao das Estruturas Dinmicas

A seguir, todos os programas das estruturas de dados feitos na seo anterior sero implementados utilizando alocao dinmica (ponteiros). Quando alocamos espao de memria de forma dinmica, temos as seguintes vantagens: programas mais rpidos e uso eficiente da memria. No caso das estruturas dinmicas, a implementao ser mostrada diretamente na linguagem C.
4.1 Alocao Dinmica

Ponteiros
Ponteiros so variveis que armazenam um endereo de memria. Se uma varivel contm o endereo de outra, ento a primeira (o ponteiro) aponta para a segunda. int a,*x; x = &a; O *significa que esta sendo declarado o ponteiro x. O ponteiro "x" aponta para o "inteiro" a, ou seja, ele armazena o endereo de memria da varivel a. Operadores & (E comercial) fornece o endereo de determinada varivel. Atribui o endereo de uma varivel para um ponteiro. * (Asterstico) que acessa o contedo de uma varivel, cujo endereo o valor do ponteiro. No confundir com o operador aritmtico de multiplicao de mesmo smbolo. Devolve o valor endereado pelo ponteiro.
main() { int *pont, cont, valor; cont = 100; pont = &cont; valor = *pont; printf("%d",valor); /* 100 */ } main() { int x,y,*px,*py; x = 100; px = &x; // px tem o endereco de x
44
Estrutura de Dados
py = px; // py tem o endereco de x y = *py; // y = 100, pois recebe o valor de x atravs de py printf("%d %d",x,y); }
Simule a execuo dos programas abaixo:

#include <stdio.h> main() { int i,k,*pi,*pk; i = 2; k = 0; pk = &k; pi = &i; *pk = i; // varivel apontada por pk recebe o valor de i printf("para *pk = i, temos k= %d\n",k); k = *pi; printf("para k = *pi, temos k= %d\n",k); scanf("%c",&a); } #include <stdio.h> main() { int x,y,*px,*py; printf("Digite um valor: "); scanf("%d",&x); px = &x; y = *px; printf("digitou= %d e y= %d\n",x,y); *px = 8; printf("valor mudou para %d\n",x); }
Funes malloc e free As funes malloc() e free() permitem que utilizemos a rea de memria livre para criar nossas variveis. As variveis sero criadas em tempo de execuo. A funo malloc() aloca memria e tem esse prottipo: ponteiro = malloc(numero_de_bytes); O numero_de_bytes a quantidade de memria que deseja alocar; A funo malloc() retorna um ponteiro para a primeira rea livre; A funo malloc faz parte a biblioteca stdlib.h int *p; p = malloc(10000);
45
Estrutura de Dados
A funo free() desaloca memria e tem esse prottipo: free(ponteiro); Ponteiro para registros typedef struct { int mat; char nome[15]; }TAluno; Declarao do ponteiro para registro TAluno *pa1 = NULL, *pa2 = NULL; Alocao de memria para um registro pa2 = (TAluno *)malloc(sizeof(TAluno)); Atribuio a um campo do registro pa2->mat = 3; for (i=0;i<=14;i++) pa2->nome[i] =nomel[i]; Liberar memria de endereo pa2 free(pa2);
4.2 Lista Dinmica Desordenada

Esta lista implementada usando ponteiros. A memria para armazenar os dados alocada em tempo de execuo. Na prxima seo ser descrito o funcionamento de cada uma das operaes e na seo 4.2.2 temos o cdigo de um programa completo que faz o cadastro dos alunos de uma turma em uma lista usando ponteiros. Esta lista possui dois ponteiros, um que guarda o endereo do primeiro elemento da lista (incio) e outro que guarda o endereo do ltimo elemento da lista (fim).
46
Estrutura de Dados

Inserir Elemento A figura abaixo ilustra a insero de trs elementos em uma lista dinmica desordenada. Inicialmente a lista est vazia, portanto o valor do ponteiro incio e fim NULL (passo 1). Quando um elemento vai ser inserido, a memria alocada e os dados so armazenados (passo 2). Todo n criado em uma lista dinmica desordenada, no tem vizinho seguinte, por isso ele aponta para NULL. Na insero do primeiro elemento, os ponteiros incio e fim apontam para este elemento (no exemplo, endereo 1010).
No passo 3 temos a chegada de um outro elemento. A memria alocada e o novo n tem os dados preenchidos e tem que ser anexado aos outros ns da lista. Todo n que chega aponta para NULL e o ponteiro fim passa a ter o endereo do n que acabou de chegar. O n que anteriormente era o ltimo da lista(1010) passar a ter como vizinho o n que acabou de chegar (ou seja, aponta para 1040). O passo 4 mostra uma outra insero de n. Veja que a cada novo elemento, apenas o endereo do ponteiro fim modificado. O ponteiro incio permanece com o mesmo valor.
47
Estrutura de Dados
Consultar Elemento Para fazer uma consulta em uma lista dinmica necessrio saber qual elemento deseja consultar. Neste caso faremos uma consulta por matrcula. Um ponteiro auxiliar ser usado para percorrer a lista, visitando cada n a procura do elemento.
Na figura acima temos uma lista com trs elementos. Caso quisssemos consultar o elemento de matrcula 25, iramos percorrer a lista at chegar no ltimo n, cujo endereo do vizinho NULL (n de endereo 1080) e ficaramos sabendo que este elemento no se encontra na lista. Quando um elemento encontrado, seus dados so apresentados e quando ele no est na lista, uma mensagem de erro deve ser dada ao usurio. Remover Elemento Para a remover um elemento necessrio saber qual elemento deseja remover. Para isso, a matrcula do aluno a ser removido deve ser lida. feita uma varredura em todos os ns da lista. Assim que o elemento encontrado, seus dados devem ser apresentados ao usurio (neste caso a matrcula e o nome). Dessa forma ele pode verificar se realmente aquele o elemento a ser removido. Quando o elemento no encontrado, uma mensagem de erro deve ser dada ao usurio. Na figura a seguir so ilustrados os trs casos de remoo: remover primeiro da lista, ltimo da lista, elemento no meio da lista. No passo 1 temos a lista com cinco elementos. Primeiramente ser feita a remoo do aluno com matrcula 10. Este o primeiro n da lista. Esta remoo feita modificando o valor do n incio para o endereo do vizinho do n que est sendo removido, neste caso, endereo 1040 (Passo 2). Em seguida ser removido a aluno de matrcula 17. Este aluno o ultimo n da lista, a sua remoo ir ter que atualizar o ponteiro fim. Alm disso o elemento que tinha como vizinho seguinte o n de matrcula 17, ter agora NULL como vizinho. Portanto, dois ponteiros so atualizados (Passo 3). No passo 4 ser feita a ltima remoo, aluno com matrcula 14 (endereo 1050), que est armazenado em um n no meio da lista. Nesta remoo, os ponteiros incio e fim no so alterados. No entanto, o elemento que vem antes do removido (1040), ter agora como vizinho o elemento que era vizinho do que ser removido (1070).
48
Estrutura de Dados
Listagem de Todos os Elementos A operao de listagem possibilita a visualizao dos dados de todos os elementos cadastrados. feita uma varredura na lista partindo do endereo incio at o ltimo n, todos os dados de todos os elementos so apresentados ao usurio.
4.2.2 Programa em C
#include #include #include // Lista <stdio.h> <conio.h> <stdlib.h> desordenada usando ponteiro - alocacao dinamica int mat; char nome[20]; struct tipo_aluno *prox; } TAluno;
49
typedef struct tipo_aluno {
Estrutura de Dados
TAluno *inicio = NULL; TAluno *fim = NULL; TAluno *noatual; int op, qa; /*****************************************************************/ void linha() { int i; for (i=1;i<=80;i++) printf("_"); printf("\n"); } void cabec() { system("cls"); printf("Faculdade Santa Maria - Lista Dinamica Desordenada\n"); linha(); } /* Funcao para inserir um novo no, ao final da lista */ void inserir () { TAluno *novono; int i, matl, continuar; char nomel[20]; do{ cabec(); printf("\n Inserir novo aluno \n"); printf("\n Matricula: "); scanf("%d",&matl); printf("\n Nome: "); fflush(stdin); gets(nomel); fflush(stdin); qa++; //Aloca memoria para o novo aluno e coloca os dados novono = (TAluno *)malloc(sizeof(TAluno)); novono->mat = matl; for (i=0;i<=19;i++) novono->nome[i] =nomel[i]; novono->prox = NULL; // Inserir novono na lista de alunos if (inicio == NULL) { inicio = novono; fim = novono; } else { fim->prox = novono; fim = novono; } printf("\n\nInserido com Sucesso!!!!\n"); printf("\nContinuar inserindo (1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1); }
50
Estrutura de Dados
/* Consultar um aluno na lista */ void consultar() { int matc, continuar, achou=0; do{ cabec(); printf("\nConsulta aluno pelo numero de matricula\n\n"); printf("\nMatricula: "); scanf("%d",&matc); noatual = inicio; while(noatual != NULL) { if (noatual->mat == matc) { achou = 1; printf("\n\nMatricula Nome\n"); printf("---------------------------------------\n"); printf("%9d %-20s\n",noatual->mat, noatual->nome); printf("---------------------------------------\n"); break; } else noatual = noatual->prox; } if (achou == 0) printf("\n\nAluno nao encontrado!!\n"); printf("\nContinuar consultando (1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1); } /* remover um aluno da lista */ void remover() { TAluno *noantrem; int matr, confrem, continuar, achou; do{ achou = 0; cabec(); printf("\nRemove aluno \n\n"); printf("\nMatricula: "); scanf("%d",&matr); noatual = inicio; while(noatual != NULL) { if (noatual->mat == matr) { achou = 1; printf("\n\nMatricula Nome\n"); printf("---------------------------------------\n"); printf("%9d %-20s\n",noatual->mat, noatual->nome); printf("---------------------------------------\n"); printf("\n\nDeseja remover o aluno (1-sim, 2-nao)? "); scanf("%d",&confrem); if (confrem ==1) { if (noatual == inicio) inicio = inicio->prox; else { noantrem->prox=noatual->prox; if (noatual == fim) fim=noantrem;
51
Estrutura de Dados
} qa--; free(noatual); printf("\n\nRemovido com sucesso!!!!\n"); } else printf("\n\nRemocao cancelada\n"); break;
} else { noantrem = noatual; noatual = noatual->prox; }
} if (achou == 0) printf("\n\nAluno nao encontrado!!\n"); printf("\n\nDeseja remover outro (1-sim, 2-nao)? "); scanf("%d",&continuar); }while (continuar ==1); } /* Lista todos os alunos presentes na lista */ void listar () { noatual = inicio; cabec(); printf("\nListagem de Alunos\n\n"); if (qa != 0) { printf("\n\nMatricula Nome\n"); printf("---------------------------------------\n"); while( noatual != NULL) { printf("%9d %-20s\n",noatual->mat, noatual->nome); noatual = noatual->prox; } printf("---------------------------------------\n"); printf("\n\nQuantidade de Alunos = %d\n",qa); } else printf("\n\n Nao tem nenhum aluno cadastrado"); printf("\n\n\nTecle enter para voltar para o menu\n"); getche(); } //Programa Principal main() { qa = 0; do { cabec(); printf("\n Opcoes: \n\n"); printf("\t1- Inserir novo Aluno\n\n"); printf("\t2- Remover Aluno\n\n"); printf("\t3- Consultar Aluno\n\n"); printf("\t4- Listagem de Alunos\n\n"); printf("\t0- Sair do Programa\n\n\n"); linha();
52
Estrutura de Dados
printf("Informe a Opcao desejada: "); scanf("%d",&op); switch(op) { case 1: inserir(); break; case 2: remover(); break; case 3: consultar(); break; case 4: listar(); break; case 0: break; default : printf("\nOpcao Invalida! break; } }while(op!=0); noatual = inicio; while (noatual != NULL) { inicio = noatual->prox; free(noatual); noatual = inicio; } }
Tecle
enter...");
getche();
4.3 Lista Dinmica Ordenada

Esta lista implementada usando ponteiros, no entanto, quando for feito o caminhamento pelos ns da lista, ela deve estar ordenada por algum campo, neste exemplo o campo de ordenao a matrcula. Esta lista possui apenas o ponteiro incio, que guarda o endereo do primeiro elemento da lista.

Inserir Elemento Na figura ilustrada a insero de quatro elementos em uma lista dinmica ordenada. No passo 1 a lista est vazia, com o ponteiro incio apontando para NULL. No passo 2 temos a insero do elemento de matrcula 17. Como a lista est vazia, o ponteiro incio vai apontar para este elemento (endereo 1080). No passo 3 temos a chegada de um outro elemento, matrcula 10. verificado que ele tem a matrcula menor do que o primeiro elemento da lista, ento este novo elemento ter que ser inserido no incio da lista. Assim, o elemento novo vai apontar para o primeiro da lista e o ponteiro incio ir apontar para o novo n. Em seguida, teremos a insero de um aluno com matrcula 14, que ser inserido no meio da lista. Para isso, teremos que descobrir entre quais elementos ele ir ser inserido, para manter a lista ordenada e fazer as ligaes dos ponteiros corretamente.
53
Estrutura de Dados
Finalmente, no passo 5 teremos a insero do aluno com matrcula 22. Esse ser inserido no final da lista. Consultar Elemento Para fazer uma consulta necessrio primeiro saber qual elemento deseja consultar. Um ponteiro auxiliar ser usado para percorrer a lista, visitando cada n a procura do elemento.
Na figura acima temos uma lista com quatro elementos. Caso quisssemos consultar o elemento de matrcula 25, iramos percorrer a lista at chegar no ltimo n, cujo endereo do vizinho NULL (n de endereo 1040) e ficaramos sabendo que este elemento no se encontra na lista. Se procurssemos a matrcula 8, assim que fosse feita a comparao com o primeiro elemento da lista, j saberamos que a matricula 8 no se encontra na lista e a consulta finalizada. A busca executada enquanto no encontra o elemento procurado ou enquanto no encontra um elemento cuja matrcula maior do que a matrcula que est sendo procurada.
54
Estrutura de Dados
Remover Elemento A remoo em uma lista dinmica ordenada segue a mesma regra de uma lista desordenada. A nica diferena que no teremos o ponteiro fim para atualizar. Para remover um elemento necessrio saber qual elemento deseja remover. Para isso, a matrcula do aluno a ser removido deve ser lida. feita uma varredura em todos os ns da lista. Assim que o elemento encontrado, seus dados devem ser apresentados ao usurio (neste caso a matrcula e o nome). Quando o elemento no encontrado, uma mensagem de erro deve ser dada ao usurio. Na figura a seguir so ilustrados os dois casos de remoo: primeiro da lista e meio ou fim da lista. Quando o primeiro elemento da lista removido, passo 2, o endereo do incio precisa ser atualizado. No passo 3 o elemento a ser removido o ltimo da lista. Neste caso, o elemento que apontava para o elemento removido (1080), ter que apontar para o elemento que o elemento removido aponta (NULL).
55
Estrutura de Dados
4.3.2 Programa em C
#include #include #include // Lista <stdio.h> <conio.h> <stdlib.h> ordenada usando ponteiro - alocacao dinamica
/* Estrutura que ser usada para criar os ns da lista */ typedef struct tipo_aluno { int mat; char nome[15]; struct tipo_aluno *prox; } TAluno; TAluno *inicio = NULL; /* Ponteiro para a inicio da lista */ TAluno *noatual; /* Ponteiro a ser usado para percorrer a lista*/ int op, qa; void linha() { int i; for (i=1;i<=80;i++) printf("_"); printf("\n"); } void cabec() { system("cls"); printf("Faculdade Santa Maria - Lista Dinamica Ordenada\n"); linha(); } /* Funcao para inserir um novo no, ao final da lista */ void inserir () { TAluno *novono, *antinserido; int i, matl,continuar; char nomel[15]; do{ cabec(); printf("\nInserir novo aluno \n"); printf("\nMatricula: "); scanf("%d",&matl); fflush(stdin); printf("\nNome: "); gets(nomel); qa++; //Aloca memoria para o novo aluno e coloca os dados novono = (TAluno *) malloc(sizeof(TAluno)); novono->mat = matl; for (i=0;i<=14;i++) novono->nome[i] =nomel[i]; antinserido = NULL; // Inserir novono na lista de alunos if (inicio == NULL) /* Ainda nao existe nenhum aluno na lista */ { inicio = novono; novono->prox = NULL; }
56
Estrutura de Dados
else { noatual = inicio; if (noatual->mat > matl) // aluno inserido no inicio da lista { novono->prox = inicio; inicio = novono; } else // aluno sera inserido no meio ou final da lista { while(noatual != NULL) { if (noatual->mat < matl) // procura o local da insercao { antinserido = noatual; noatual = noatual->prox; } else // encontrou o local onde sera inserido noatual = NULL; } novono->prox = antinserido->prox; antinserido->prox = novono; } } printf("\n\nInserido com Sucesso!!!!\n"); printf("\nContinuar inserindo (1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1); // verifica se quer continuar removendo } /* Consultar um aluno na lista */ void consultar() { int matc, continuar, achou=0; do{ cabec(); printf("\nConsulta aluno pelo numero de matricula\n\n"); printf("Matricula: "); scanf("%d",&matc); noatual = inicio; // coloca ponteiro no inicio da lista while(noatual != NULL) // percorre a lista procurando o aluno { if (noatual->mat == matc) // aluno encontrado { achou = 1; printf("\n\nMat Nome \n"); printf("----------------------------\n"); printf("%2d %-15s\n", noatual->mat, noatual->nome); printf("----------------------------\n"); break; } else // procura no proximo aluno { noatual = noatual->prox; if (noatual != NULL) { if (noatual->mat > matc) break; } } } if (achou == 0) // aluno nao esta na lista printf("\n\nAluno nao encontrado!!\n\n"); printf("\nContinuar consultando (1-sim/2-nao)? "); scanf("%d",&continuar);
57
Estrutura de Dados
}while (continuar == 1); } /* remover um aluno da lista */ void remover() { TAluno *noantrem; int matr, confrem, continuar, achou; do{ achou = 0; cabec(); printf("\nRemove aluno \n\n"); printf("Matricula: "); scanf("%d",&matr); noatual = inicio; //ponteiro que ira percorrer a lista while(noatual != NULL) // percorre a lista a procura do aluno { if (noatual->mat == matr) // verifica se o aluno { achou = 1; // impressao dos dados do aluno para conferencia printf("\n\nMatricula Nome\n"); printf("----------------------------------------\n"); printf("%9d %-15s\n", noatual->mat, noatual->nome); printf("----------------------------------------\n"); printf("\n\nDeseja remover o aluno (1-sim, 2-nao)? "); scanf("%d",&confrem); if (confrem ==1) // confirma que quer remover { if (noatual == inicio) // verifica se o primeiro da lista inicio = inicio->prox; else // removido esta no meio ou final da lista noantrem->prox=noatual->prox; // atualiza a quatidade de alunos e reprovados ou aprovados qa--; free(noatual); // libera memoria do no removido printf("\n\n Removido com sucesso!!!!\n"); } else // cancelou a remocao printf("\n\n Remocao cancelada\n"); break; } else // passa para o proximo no para continuar a busca { noantrem = noatual; noatual = noatual->prox; if (noatual !=NULL) { if (noatual->mat > matr) break; } } } if (achou == 0) // o elemento nao foi encontrado na lista printf("\n\nAluno nao encontrado!!\n\n"); printf("\n\nDeseja remover outro (1-sim, 2-nao)? "); scanf("%d",&continuar); }while (continuar ==1); // continuar removendo aluno }
58
Estrutura de Dados
/* Lista todos os alunos presentes na lista */ void listar () { noatual = inicio; // no auxiliar marca o inicio da lista cabec(); printf("\nListagem de Alunos\n\n"); if (qa != 0) // verifica se tem aluno cadastrado { printf("\n\nMatricula Nome\n"); printf("----------------------------------------\n"); while( noatual != NULL) // percorre toda a lista ate chegar no final { printf("%9d %-15s\n", noatual->mat, noatual->nome); noatual = noatual->prox; // Faz noatual apontar para o proximo no } printf("----------------------------------------\n"); printf("\n\nQuantidade de Alunos: %d\n",qa); } else printf("\n\nNao tem nenhum aluno cadastrado"); printf("\n\nTecle enter para voltar para o menu..."); getche(); } // Programa principal main() { qa = 0; do { cabec(); printf("\nOpcoes: \n\n"); printf(" 1 - Inserir novo aluno\n"); printf(" 2 - Consultar aluno\n"); printf(" 3 - Remover aluno\n"); printf(" 4 - Listar todos os alunos\n"); printf(" 0 - para sair \n\n"); printf("Entre com a sua opcao: "); scanf("%d", &op); /* Le a opcao do usuario */ switch(op) { case 1: inserir(); break; case 2: consultar();break; case 3: remover(); break; case 4: listar(); break; case 0: break; default: printf("\n\n Opcao invalida"); getche(); break; } fflush(stdin); /* Limpa o buffer de entrada */ } while (op != 0); /* Desaloca a memoria alocada para os elementos da lista */ noatual = inicio; while (noatual != NULL) { inicio = noatual->prox; free(noatual); noatual = inicio; } }
59
Estrutura de Dados
4.4 Lista Duplamente Encadeada Ordenada

Nessa lista teremos dois ponteiros em cada n. Um que ir armazenar o endereo do n anterior e o outro pra armazenar o endereo do n posterior. Dessa forma, as consultas sero melhoradas e podemos percorrer a lista da esquerda para direita e da direita para esquerda.

Inserir Elemento Na figura ilustrada a insero de trs elementos em uma lista duplamente encadeada ordenada. No passo 1 a lista est vazia, com o ponteiro incio apontando para NULL. No passo 2 temos a insero do elemento de matrcula 17. Como a lista est vazia, o ponteiro incio vai apontar para este elemento (endereo 1080). Este n no tem vizinhos, por isso os seus ponteiros apontam para NULL.
No passo 3 temos a chegada de um outro elemento, matrcula 10. verificado que ele tem a matrcula menor do que o primeiro elemento da lista, ento este novo elemento ter que ser inserido no incio da lista. Assim, o elemento novo vai apontar para o primeiro da lista e o ponteiro incio ir apontar para o novo n e o elemento que era o primeiro da lista, ter o elemento novo como vizinho anterior. Em seguida, teremos a insero de um aluno com matrcula 14, que ser inserido no meio da lista. Para isso, teremos que descobrir entre quais elementos ele ir ser inserido, para manter a lista ordenada e fazer as ligaes dos ponteiros corretamente.
60
Estrutura de Dados
Consultar Elemento Para fazer uma consulta necessrio primeiro saber qual elemento deseja consultar. Um ponteiro auxiliar ser usado para percorrer a lista, visitando cada n a procura do elemento. A consulta similar a consulta em uma lista de encadeamento simples. Remover Elemento Para remover um elemento necessrio saber qual elemento deseja remover. Para isso, a matrcula do aluno a ser removido deve ser lida. feita uma varredura em todos os ns da lista. Assim que o elemento encontrado, seus dados devem ser apresentados ao usurio (neste caso a matrcula e o nome). Quando o elemento no encontrado, uma mensagem de erro deve ser dada ao usurio. Na figura a seguir ser ilustrada a remoo do primeiro elemento da lista (matrcula 10). Quando o primeiro elemento da lista removido, passo 2, o endereo do incio precisa ser atualizado. Alm disso, o segundo elemento da lista (matrcula 14), passar a ser o primeiro e por isso, no ter mais vizinho anterior.
4.4.2 Programa em C
#include #include #include // Lista <stdio.h> <conio.h> <stdlib.h> duplamente encadeada - alocacao dinamica int mat; char nome[15]; float m;
61
typedef struct tipo_aluno {
Estrutura de Dados
struct tipo_aluno *ant, *prox; } TAluno; TAluno *inicio = NULL; /* Ponteiro para a inicio da lista */ TAluno *noatual; /* Ponteiro a ser usado para percorrer a lista*/ int op, qa; /*************************************************************************/ void linha() { int i; for (i=1;i<=80;i++) printf("_"); printf("\n"); } void cabec() { system("cls"); printf("Faculdade Santa Maria - Lista Duplamente Encadeada Ordenada\n"); linha(); } /* Funcao para inserir um novo no, ao final da lista */ void inserir () { TAluno *novono, *antinserido; int i, matl, continuar; float ml; char st, nomel[15]; do{ cabec(); printf("\n Inserir novo aluno \n"); printf("\n Matricula: "); scanf("%d",&matl); printf("\n Nome: "); fflush(stdin); gets(nomel); printf("\n media: "); scanf("%f",&ml); qa++; //Aloca memoria para o novo aluno e coloca os dados novono = (TAluno *) malloc(sizeof(TAluno)); novono->mat = matl; for (i=0;i<=14;i++) novono->nome[i] =nomel[i]; novono->m = ml; antinserido = NULL; // Inserir novono na lista de alunos if (inicio == NULL) /* Ainda nao existe nenhum aluno na lista */ { inicio = novono; novono->prox = NULL; novono->ant = NULL; } else // ja existem alunos na lista { noatual = inicio; if (noatual->mat > matl) // aluno sera inserido no inicio
62
Estrutura de Dados
{ novono->prox = inicio; novono->ant = NULL; inicio->ant = novono; inicio = novono; } else // aluno sera inserido no meio ou final da lista { while(noatual != NULL) { if (noatual->mat < matl) // procura o local da insercao { antinserido = noatual; noatual = noatual->prox; } else // encontrou o local onde sera inserido break; } novono->prox = antinserido->prox; novono->ant = antinserido; antinserido->prox = novono; if (noatual != NULL) noatual->ant = novono; } } printf("\n\nInserido com Sucesso!!!!\n\n"); printf("\n Continuar inserindo (1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1); // verifica se quer continuar removendo } /* Consultar um aluno na lista */ void consultar() { int matc, continuar, achou=0; do{ cabec(); printf("\nConsulta aluno pelo numero de matricula\n\n"); printf("\nMatricula: "); scanf("%d",&matc); noatual = inicio; // coloca ponteiro no inicio da lista while(noatual != NULL) // percorre a lista procurando o aluno { if (noatual->mat == matc) // aluno encontrado { achou = 1; printf("\n\nMat Nome Media\n"); printf("-----------------------------------------\n"); printf("%2d %-15s %5.2f\n", noatual->mat, noatual->nome,noatual->m); printf("-----------------------------------------\n"); break; } else // procura no proximo aluno { noatual = noatual->prox; if (noatual != NULL) { if (noatual->mat > matc) break; } } }
63
Estrutura de Dados
if (achou == 0) // aluno nao esta na lista printf("\n\nAluno nao encontrado!!\n\n"); printf("\nContinuar consultando (1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1);
/* remover um aluno da lista */ void remover() { TAluno *noantrem, *noposrem; int matr, confrem, continuar, achou; do{ achou = 0; cabec(); printf("\nRemove aluno \n\n"); printf("\nMatricula: "); scanf("%d",&matr); noatual = inicio; //ponteiro que ira percorrer a lista while(noatual != NULL) // percorre a lista a procura do aluno { if (noatual->mat == matr) // verifica se o que deseja remover { achou = 1; // impressao dos dados do aluno para conferencia printf("\n\nMat Nome Media\n"); printf("---------------------------------------\n"); printf("%2d %-15s %5.2f\n", noatual->mat, noatual->nome,noatual->m); printf("---------------------------------------\n"); printf("\n\nDeseja remover o aluno (1-sim, 2-nao)? "); scanf("%d",&confrem); if (confrem ==1) // confirma que quer remover { if (noatual == inicio) // verifica se o primeiro da lista { inicio = inicio->prox; inicio->ant = NULL; } else // removido esta no meio ou final da lista { noantrem->prox=noatual->prox; noposrem= noatual->prox; if (noposrem != NULL) noposrem->ant = noantrem; } // atualiza a quatidade de alunos e reprovados ou aprovados qa--; free(noatual); // libera memoria do no removido printf("\n\n Removido com sucesso!!!!\n\n"); } else // cancelou a remocao { printf("\n\n Remocao cancelada\n\n"); } break; }
64
Estrutura de Dados
else // passa para o proximo no para continuar a busca { noantrem = noatual; noatual = noatual->prox; if (noatual !=NULL) if (noatual->mat > matr) break; } } if (achou == 0) // o elemento nao foi encontrado na lista printf("\n\nAluno nao encontrado!!\n\n"); printf("\n\nDeseja remover outro (1-sim, 2-nao)? "); scanf("%d",&continuar); }while (continuar ==1); // continuar removendo aluno } /* Lista todos os alunos presentes na lista */ void listar () { noatual = inicio; // no auxiliar marca o inicio da lista cabec(); printf("\nListagem de Alunos\n\n"); if (qa != 0) // verifica se tem aluno cadastrado { printf("\n\nMat Nome Media\n"); printf("-----------------------------------------\n"); while( noatual != NULL) { printf("%2d %-15s %5.2f\n", noatual->mat, noatual->nome,noatual->m); noatual = noatual->prox; // Faz noatual apontar para o proximo no } printf("-----------------------------------------\n"); printf("\n\nQuantidade de Alunos = %d\n",qa); } else printf("\n\n Nao tem nenhum aluno cadastrado"); printf("\n\n\nTecle enter para voltar para o menu\n"); getche(); } //Programa principal main() { qa = 0; do { cabec(); printf("\n Opcoes: \n\n"); printf("\t1- Inserir novo Aluno\n\n"); printf("\t2- Remover Aluno\n\n"); printf("\t3- Consultar Aluno\n\n"); printf("\t4- Listagem de Alunos\n\n"); printf("\t0- Sair do Programa\n\n\n"); linha(); printf("Informe a Opcao desejada: "); scanf("%d",&op); switch(op) { case 1: inserir(); break; case 2: remover(); break; case 3: consultar(); break;
65
Estrutura de Dados
case 4: listar(); break; case 0: break; default : printf("\nOpcao Invalida! Tecle enter..."); getche(); break; } }while(op!=0); noatual = inicio; while (noatual != NULL) { inicio = noatual->prox; free(noatual); noatual = inicio; }
4.5 Fila Dinmica

Nesta seo iremos analisar as operaes bsicas em uma fila implementada com ponteiros e posteriormente o seu cdigo em C.

Inserir Elemento Todo elemento que vai ser inserido em uma fila colocado no final da estrutura.
66
Estrutura de Dados
A figura ilustra a chegada de dois clientes na fila. Inicialmente a fila est vazia, portanto o valor do ponteiro incio e fim NULL (passo 1). Quando um elemento vai ser inserido, a memria alocada e os dados so armazenados (passo 2). Todo n criado em uma fila dinmica, no tem vizinho seguinte, por isso ele aponta para NULL. Na insero do primeiro elemento, os ponteiros incio e fim apontam para este elemento (no exemplo, endereo 1010). No passo 3 temos a chegada do cliente 12, que ser armazenado no final da estrutura, o ltimo elemento da fila o ter (endereo 1070) como vizinho e o ponteiro fim ir apontar para o novo elemento. Consultar Primeiro da Fila Em uma fila, a consulta feita apenas do primeiro elemento da fila. Assim teremos a informao de qual ser o prximo elemento a ser retirado. O primeiro elemento da fila o elemento do endereo incio. Quando incio estiver apontando para NULL, significa que a fila est vazia. Remover Primeiro da Fila Em uma fila, o elemento removido sempre o que chegou h mais tempo, ou seja, o elemento apontado por incio. Quando um elemento removido, o endereo do ponteiro incio deve apontar para o vizinho do primeiro da fila.
Listagem de Todos os Elementos da Fila A operao de listagem possibilita a visualizao dos dados de todos os elementos da fila. feita uma varredura na fila e todos os dados de todos os elementos so apresentados ao usurio.
67
Estrutura de Dados
4.5.2 Programa em C
#include <stdio.h> #include <conio.h> #include <stdlib.h> // Implementao de fila usando ponteiro /* Estrutura que ser usada para criar os ns da fila */ typedef struct tipo_cliente { int conta, agencia; char nome[15]; int tipo; struct tipo_cliente *prox; } TCliente; TCliente *inicio = NULL; /* Ponteiro para o inicio da fila */ TCliente *fim = NULL; /* Ponteiro para o fim da fila */ TCliente *noatual; /* Ponteiro a ser usado para percorrer a fila*/ int op, tamfila; /*************************************************************************/ void linha() { int i; for (i=1;i<=80;i++) printf("_"); printf("\n"); } void cabec() { system("cls"); printf("Banco Poupe Muito - Fila Dinamica\n"); linha(); } /* Funcao para inserir um novo no, ao final da fila */ void inserir () { TCliente *novono; int i, contal, agencial, tipol, continuar; char nomel[15]; do{ // leitura dos dados do cliente cabec(); printf("\n Chegada de novo cliente na fila \n"); printf("\n Numero da conta: "); scanf("%d",&contal); printf("\n Numero da agencia: "); scanf("%d",&agencial); printf("\n Nome: "); fflush(stdin); gets(nomel); printf("\n Tipo de cliente(1- especial, 2-normal): "); scanf("%d",&tipol); tamfila++; //Aloca memoria para o novo cliente
68
Estrutura de Dados
novono = (TCliente *) malloc(sizeof(TCliente)); novono->conta = contal; novono->agencia = agencial; for (i=0;i<=14;i++) novono->nome[i] =nomel[i]; novono->tipo = tipol; novono->prox = NULL; // Inserir novono na fila de cliente if (inicio == NULL) /* Se ainda nao existe nenhum cliente na fila */ { inicio = novono; fim = novono; } else /* Se ja existem clientes na fila*/ { fim->prox = novono; /* Faz o ultimo no apontar para o novo no */ fim = novono; /* final da fila atualizado */ } printf("\n\nInserido com Sucesso!!!!\n\n"); printf("\n Continuar inserindo (1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1); // verifica se quer continuar inserindo } /* Consultar um primeiro cliente da fila */ void consultarprimeiro() { cabec(); printf("\nConsulta primeiro cliente da fila\n\n"); noatual = inicio; // coloca ponteiro no inicio da lista if (noatual != NULL) { printf("\n\nAgencia Conta Nome Tipo\n"); printf("-------------------------------------------------------\n"); printf("%4d %4d %-15s %2d\n", noatual->agencia, noatual->conta, noatual->nome, noatual->tipo); printf("-------------------------------------------------------\n"); } else printf("\nA fila est vazia!!\n\n"); printf("\n\nTecle enter para voltar para o menu\n"); getche(); } /* remover um cliente da fila */ void retirafila() { int confrem, continuar; do{ cabec(); printf("\nRetira primeiro cliente da fila \n\n"); noatual = inicio; //ponteiro que ira apontar para o primeiro no if (noatual != NULL) // verifica se tem elementos na fila { printf("\n\nAgencia Conta Nome Tipo\n"); printf("---------------------------------------------------\n"); printf("%4d %4d %-15s %2d\n", noatual->agencia, noatual->conta, noatual->nome, noatual->tipo); printf("---------------------------------------------------\n");
69
Estrutura de Dados
printf("\n\nconfirma retirada do cliente (1-sim, 2-nao)? "); scanf("%d",&confrem); if (confrem ==1) // confirma que quer remover { inicio = inicio->prox; free(noatual); // libera memoria do no removido tamfila--; printf("\n\n Retirado da fila com sucesso!!!!\n\n"); } else // cancelou a remocao printf("\n\n Retirada cancelada\n\n"); } else // fila vazia printf("\n\nFila vazia!!\n\n"); printf("\n\nDeseja retirar outro cliente(1-sim, 2-nao)? "); scanf("%d",&continuar); }while (continuar ==1); // continuar retirando cliente da fila } /* Lista todos os clientes da fila */ void listar () { noatual = inicio; // no auxiliar marca o inicio da lista cabec(); printf("\nListagem de clientes da fila\n\n"); if (tamfila != 0) { printf("\n\nAgencia Conta Nome Tipo\n"); printf("-------------------------------------------------------\n"); while( noatual != NULL) // percorre toda a fila ate chegar no final { printf("%4d %4d %-15s %2d\n", noatual->agencia, noatual->conta, noatual->nome, noatual->tipo); noatual = noatual->prox; // Faz noatual apontar para o proximo no } printf("-------------------------------------------------------\n"); printf("\n\nQuantidade de clientes na fila = %d\n",tamfila); } else printf("\n\n Nao tem nenhum cliente na fila"); printf("\n\n\nTecle enter para voltar para o menu\n"); getche(); } // Programa principal main() { tamfila= 0; do { cabec(); printf("\nOpcoes: "); printf("\n\n 1 - Inserir cliente na fila"); printf("\n\n 2 - Consultar primeiro da fila"); printf("\n\n 3 - Retirar primeiro cliente da fila"); printf("\n\n 4 - Listar todos os clientes da fila"); printf("\n\n 0 - para sair \n"); linha(); printf("\nEntre com a sua opcao: "); scanf("%d", &op); /* Le a opcao do usuario */
70
Estrutura de Dados
switch(op) { case 1: inserir(); break; case 2: consultarprimeiro();break; case 3: retirafila(); break; case 4: listar(); break; case 0: break; default: printf("\nOpcao nao valida"); } } while (op != 0); noatual = inicio; while (noatual != NULL) { inicio = noatual->prox; free(noatual); noatual = inicio; }
4.6 Pilha Dinmica

Nesta seo iremos analisar as operaes bsicas em uma pilha implementada com ponteiros e posteriormente o seu cdigo em C.

Inserir Elemento Todo elemento que vai ser inserido em uma pilha colocado no final da estrutura. A figura abaixo ilustra a chegada de trs livros colocados na pilha.
71
Estrutura de Dados
Cada elemento que chega, ser inserido no incio da estrutura. Portando, o ponteiro incio sempre modificado a cada insero. Na Figura a pilha inicia vazia, com o ponteiro incio apontando para NULL (Passo 1). No passo 2 um elemento inserido na pilha, por ser o primeiro, ele no tem vizinho e o ponteiro incio passa a apontar para o novo n (endereo 1080). No passo 3 um novo elemento inserido, o ponteiro incio deve ser atualizado e o novo n deve apontar para o elemento que estava no incio da pilha (endereo 1080). No passo 4, um novo elemento inserido e as atualizaes dos ponteiros devem ser feitas. Consultar Topo da Pilha Em uma pilha, a consulta feita apenas do elemento do topo, ou seja o ltimo elemento a ser inserido, que neste caso o elemento apontado pelo ponteiro incio. Se o ponteiro incio aponta para NULL significa que a pilha est vazia. Remover Topo da Pilha Em uma pilha, o elemento removido sempre o que chegou h menos tempo, ou seja, o elemento da apontado pelo ponteiro incio. Na figura abaixo iremos remover o elemento do topo da pilha. O ponteiro incio deve ser atualizado, apontando para o elemento que era vizinho do elemento removido.
Listagem de Todos os Elementos da Pilha A operao de listagem possibilita a visualizao dos dados de todos os elementos da pilha. feita uma varredura na pilha e todos os dados de todos os elementos so apresentados ao usurio.
4.6.1 Programa em C
#include <stdio.h> #include <conio.h> #include <stdlib.h> // Implementao de pilha usando ponteiro
72
Estrutura de Dados
/* Estrutura que ser usada para criar os ns da pilha */ typedef struct tipo_livro { int codigo, editora; char titulo[30]; struct tipo_livro *prox; } TLivro; TLivro *inicio = NULL; /* Ponteiro para o inicio da pilha */ TLivro *noatual; /* Ponteiro a ser usado para percorrer a pilha*/ int op, tampilha; /*************************************************************************/ void linha() { int i; for (i=1;i<=80;i++) printf("_"); printf("\n"); } void cabec() { system("cls"); printf("Pilha de Livros - Dinamica\n"); linha(); } /* Funcao para inserir um novo no, no inicio da pilha */ void inserir () { TLivro *novono; int i, codl, edl, continuar; char titl[30]; do{ cabec(); printf("\nColocar livro no topo da pilha \n"); printf("\nCodigo do livro: "); scanf("%d",&codl); printf("\nTitulo do Livro: "); fflush(stdin); gets(titl); printf("\nEditora(1- Campus, 2-Makron Books, 3-Moderna): "); scanf("%d",&edl); // Inserir livro na pilha tampilha++; //Aloca memoria para o novo livro novono = (TLivro *) malloc(sizeof(TLivro)); novono->codigo = codl; novono->editora = edl; for (i=0;i<=29;i++) novono->titulo[i] =titl[i]; novono->prox = inicio; inicio = novono; printf("\n\nInserido com Sucesso!!!!\n\n"); printf("\nContinuar inserindo (1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1); // verifica se quer continuar inserindo livros }
73
Estrutura de Dados
/* Consultar livro do topo da pilha */ void consultatopo() { cabec(); printf("\nConsulta topo da pilha\n\n"); if (inicio != NULL) { printf("\n\nCodigo Titulo Editora\n"); printf("-----------------------------------------------------\n"); printf("%6d %-20s %7d\n", inicio->codigo, inicio->titulo,inicio->editora); printf("-----------------------------------------------------\n"); } else printf("\nA pilha est vazia!!\n\n"); printf("\n\nTecle enter para voltar para o menu\n"); getche(); } /* remover livro do topo da pilha */ void retirapilha() { int confrem, continuar; do{ cabec(); printf("\nRetira livro do topo da pilha \n"); noatual = inicio; //ponteiro que ira apontar para o primeiro no if (inicio != NULL) // verifica se tem elementos na pilha { printf("\n\nCodigo Titulo Editora\n"); printf("---------------------------------------------------\n"); printf("%6d %-20s %7d\n", inicio->codigo, inicio->titulo,inicio->editora); printf("---------------------------------------------------\n"); printf("\n\nconfirma retirada do livro (1-sim, 2-nao)? "); scanf("%d",&confrem); if (confrem ==1) // confirma que quer remover { inicio = inicio->prox; free(noatual); // libera memoria do no removido tampilha; printf("\n\n Retirado da Pilha com sucesso!!!!\n\n"); } else // cancelou a remocao printf("\n\n Retirada cancelada\n\n"); } else // pilha vazia printf("\n\nPilha vazia!!\n\n"); printf("\n\nDeseja retirar outro livro(1-sim, 2-nao)? "); scanf("%d",&continuar); }while (continuar ==1); // continuar retirando livro da pilha } /* Lista todos os livros da pilha */ void listar () { noatual = inicio; // no auxiliar marca o inicio da lista cabec(); printf("\nListagem dos livros da pilha\n\n");
74
Estrutura de Dados
if (inicio != NULL) { printf("\n\nCodigo Titulo Editora\n"); printf("-----------------------------------------------------\n"); while( noatual != NULL) // percorre toda a pilha { printf("%6d %-20s %7d\n", noatual->codigo, noatual->titulo, noatual->editora); noatual = noatual->prox; // Faz noatual apontar para proximo no } printf("-----------------------------------------------------\n"); printf("\n\nQuantidade de livros na pilha = %d\n",tampilha); } else printf("\n\n Nao tem nenhum livro na pilha"); printf("\n\n\nTecle enter para voltar para o menu\n"); getche();
//Programa principal main() { tampilha= 0; do { cabec(); printf("\nOpcoes: \n"); printf("\n 1 - Inserir livro na pilha"); printf("\n 2 - Consultar topo da pilha"); printf("\n 3 - Retirar livro do topo"); printf("\n 4 - Listar todos os livros da pilha"); printf("\n 0 - Sair \n"); linha(); printf("\nEntre com a sua opcao: "); scanf("%d", &op); /* Le a opcao do usuario */ switch(op) { case 1: inserir(); break; case 2: consultatopo();break; case 3: retirapilha(); break; case 4: listar(); break; case 0: break; default: printf("\n\n Opcao invalida"); getche(); break; } } while (op != 0); noatual = inicio; while (noatual != NULL) { inicio = noatual->prox; free(noatual); noatual = inicio; } }
75
Estrutura de Dados
5. Ordenao e Pesquisa
A ordenao facilita o acesso aos dados. Quando recebemos um conjunto de dados desordenados, devemos realizar sobre eles um pr-processamento de forma a classific-los. Muitas vezes necessitamos organizar uma estrutura de dados para facilitar a pesquisa. Para alcanarmos um dado armazenado na estrutura, tambm temos que usar mtodos de pesquisa (busca) eficientes. Neste tpico iremos tratar mtodos clssicos de ordenar uma lista desordenada implementada com vetores e mtodos de pesquisa para buscas em uma lista esttica ordenada.
5.1 Ordenao
Os mtodos de ordenao de dados realizam classificaes segundo uma chave de ordenao. Nesta chave, especifica-se o tipo de ordem que queremos dar aos dados (crescente, decrescente, etc.) e o campo da estrutura que ser afetado (campo nome, campo matrcula, etc.). Tipos de mtodos de ordenao: Por troca: so baseados na troca de posio dos dados, de forma a orden-los. Por seleo:parte do princpio de realizar o isolamento de elementos para posies ordenadas. Por insero: baseiam-se no deslocamento de elementos da estrutura frente a um elemento de busca.
Imagine as cartas de um baralho: Para ordenar as cartas utilizando troca, espalhe-as voltadas para cima e ento troque as cartas fora de ordem at que todo baralho esteja ordenado; Utilizando seleo, espalhe as cartas na mesa, selecione a carta de menor valor, retire-a do baralho e coloque-a na mo. O processo continua e termina quando todas as cartas estiverem na sua mo; Para ordenar as cartas por insero, segure todas as cartas na mo. Ponha uma carta por vez na mesa, sempre a inserindo na posio correta.
5.1.1 Mtodo da Ordenao por Troca

Mtodo da Bolha(bubble sort): esse metodo muito simples de implementar, no entando um dos piores mtodos de ordeno quando se fala de desempenho. Ela envolve repetidas comparaes e, se necessrio, a troca de dois elementos adjacentes. A figura a seguir mostra o que acontece com o vetor no decorrer da execuo do mtodo da bolha.
76
Estrutura de Dados
5.1.2 Mtodo da Ordenao por Seleo

Este mtodo procura o menor elemento do vetor e coloca na primeira posio. A seguir, procura o menor elemento do vetor a partir do segundo elemento e coloca na segunda posio do vetor. Continua o processo at que existam apenas os dois ltimos elementos do vetor para serem comparados.
77
Estrutura de Dados
A figura a seguir mostra o que acontece com o vetor no decorrer da execuo do mtodo de ordenao por seleo.
78
Estrutura de Dados
5.1.3 Mtodo da Ordenao por Insero

Insero Direta: Neste mtodo, considera-se o segmento j ordenado como sendo formado pelo primeiro elemento do vetor de chaves. Os demais elementos, ou seja do 2 ao ltimo, pertencem ao segmento no ordenado. A partir desta situao inicial, toma-se um a um dos elementos no ordenados, a partir do primeiro e, por busca seqencial realizada no segmento j ordenado, localiza-se a sua posio relativa correta. Aps a insero, a fronteira entre os dois segmentos deslocada uma posio para a direita, indicando, com isto, que o segmento ordenado ganhou um elemento e o no ordenado perdeu um. O processo prossegue at que todos os elementos do segundo segmento tenham sido inseridos no primeiro. A figura a seguir mostra o que acontece com o vetor no decorrer da execuo deste mtodo.
79
Estrutura de Dados
5.2 Pesquisa
Busca de dados dentro de um conjunto. A Busca seqencial procura do primeiro ao ltimo elemento do vetor at encontrar o elemento. Mtodo mais simples, j utilizado nos nossos programas. A Busca Binria o mtodo aplicado para conjunto de dados ordenados. Muito parecido com o mtodo que usamos quando desejamos procurar um nmero numa lista telefnica. Programa que implementa os mtodos de ordenao e pesquisa
#include <stdio.h> #include <conio.h> #include <stdlib.h> // Programa para executar metodos de ordenao numa lista desordenada // estatica typedef struct { int mat; char nome[31], sit; float nota1, nota2, media; }alunos; alunos turma[30]; float soma; int qa, ap,rp,op; void linha() { int i; for (i=1;i<=80;i++) printf("_"); printf("\n"); } void cabec() { system("cls"); printf("Faculdade Santa Maria - Ordenacao e Pesquisa\n"); linha(); } //Inserir novo aluno void inserir() { int cont; do{ cabec(); printf("\n\nInserir Novo Aluno\n\n"); printf("\n\tNumero de Matricula do Aluno: "); scanf("%d",&turma[qa].mat); printf("\n\tNome: "); fflush(stdin); gets(turma[qa].nome); printf("\n\tNota 1: "); scanf("%f",&turma[qa].nota1); printf("\n\tNota 2: "); scanf("%f",&turma[qa].nota2);
80
Estrutura de Dados
turma[qa].media= (turma[qa].nota1+turma[qa].nota2)/2; soma += turma[qa].media; if (turma[qa].media>=6) { turma[qa].sit= 'A'; ap++; } else { turma[qa].sit= 'R'; rp++; } qa++; printf("\n\n\tAluno Inserido com Sucesso!!!\n\n"); printf("\n\n\tContinuar inserindo aluno (1-sim/2-nao)? "); scanf("%d",&cont); }while (cont == 1);
//Metodo de ordenao da Bolha void bolha() { int i, fim, troquei; alunos aux; fim = qa-1; do { troquei = 0; for (i=0; i<=fim-1; i++) { if (turma[i].mat > turma[i+1].mat) { aux = turma[i]; turma[i] = turma[i+1]; turma[i+1] = aux; troquei = 1; } } fim--; } while (troquei ==1); printf("\n\n Ordenacao pelo metodo da Bolha\n\n"); printf("\n\n Vetor Ordenado com Sucesso!!!\n\n"); getche(); } //Metodo de ordenao por Insero void insercao() { int i, k; alunos aux; for (i=1; i<=qa-1; i++) { k=i; aux = turma[i]; while ((k>0)&&(aux.mat<turma[k-1].mat)) { turma[k] = turma[k-1]; k--; } turma[k]=aux; } printf("\n\n Ordenacao pelo metodo da Insercao\n\n");
81
Estrutura de Dados
printf("\n\n Vetor Ordenado com Sucesso!!!\n\n"); getche();
//Metodo de ordenao por Seleo void selecao() { int i,k,pmenor; alunos aux; for (i=0; i<=qa-2; i++) { pmenor = i; for (k=i+1; k<=qa-1; k++) { if (turma[k].mat < turma[pmenor].mat) pmenor = k; } if (i!=pmenor) { aux = turma[i]; turma[i] = turma[pmenor]; turma[pmenor] = aux; } } printf("\n\n Ordenacao pelo metodo da Selecao\n\n"); printf("\n\n Vetor Ordenado com Sucesso!!!\n\n"); getche(); } // Metodos de Busca com para listas ordenadas //Metodo de busca binaria void binaria() { int matcon, achou, continuar, inicio, fim, meio; alunos aux; do{ cabec(); printf("\n\nConsultar Aluno - Busca Sequencial\n\n"); printf("\n\tNumero de Matricula do Aluno: "); scanf("%d",&matcon); achou = 0; inicio = 0; fim = qa-1; while (inicio<=fim) { meio = (inicio + fim)/2; printf("\nmeio = %d\n\n",meio); if (turma[meio].mat == matcon) { printf("\nMat Aluno Nota1 Nota2 Media Sit"); printf("\n--------------------------------------------------"); printf("\n%2d %-20s %5.2f %5.2f %5.2f %c", turma[meio].mat, turma[meio].nome, turma[meio].nota1, turma[meio].nota2, turma[meio].media, turma[meio].sit); printf("\n--------------------------------------------------"); achou = 1; break; }
82
Estrutura de Dados
if (matcon >turma[meio].mat) inicio = meio +1; else fim = meio -1; } if (achou == 0) printf("\n\n\tNumero de Matricula Incorreto!!!!!!\n\n"); printf("\n\n\tContinuar consultando aluno(1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1); } //Metodo de busca sequencial void sequencial() { int i, matcon, achou, continuar; do{ cabec(); printf("\n\nConsultar Aluno - Busca Sequencial\n\n"); printf("\n\tNumero de Matricula do Aluno: "); scanf("%d",&matcon); achou = -1; for(i = 0; i<qa; i++) { if (matcon==turma[i].mat) { achou = i; break; } else { if (matcon<turma[i].mat) break; } } if (achou!=-1) { printf("\nMat Aluno Nota1 Nota2 Media Sit"); printf("\n--------------------------------------------------"); printf("\n%2d %-20s %5.2f %5.2f %5.2f %c", turma[achou].mat,turma[achou].nome, turma[achou].nota1, turma[achou].nota2,turma[achou].media,turma[achou].sit); printf("\n--------------------------------------------------"); } else printf("\n\n\tNumero de Matricula Incorreto!!!!!!\n\n"); printf("\n\n\tContinuar consultando aluno(1-sim/2-nao)? "); scanf("%d",&continuar); }while (continuar == 1); } //Imprimir relatorio com as informaoes de todos alunos void listagem() { int i; cabec(); printf("\n\nRelatorio Geral\n"); printf("\nMat Aluno Nota1 Nota2 Media Sit"); printf("\n------------------------------------------------------------"); for(i = 0; i < qa; i++) printf("\n%2d %-20s %5.2f %5.2f %5.2f %c",turma[i].mat,
83
Estrutura de Dados
turma[i].nome, turma[i].nota1, turma[i].nota2, turma[i].media, turma[i].sit); printf("\n------------------------------------------------------------"); printf("\n\nMedia da turma = %.2f",soma/qa); printf("\n\nQuantidade de aprovados = %d",ap); printf("\n\nQuantidade de reprovados = %d",rp); printf("\n\n\tDigite qualquer tecla para sair\n\n\n "); getche(); } //Programa principal main() { op = 1; soma = 0; ap = rp = qa =0; while (op != 0) { cabec(); printf("Opcoes: \n\n"); printf(" 1- Inserir Aluno\n\n"); printf(" 2- Ordenacao Bolha\n\n"); printf(" 3- Ordenacao por Selecao\n\n"); printf(" 4- Ordenacao por Insercao\n\n"); printf(" 5- Busca Sequencial\n\n"); printf(" 6- Busca Binaria\n\n"); printf(" 7- Listagem\n\n"); printf(" 0- Sair do Programa\n"); linha(); printf(" Informe a Opcao desejada: "); scanf("%d",&op); switch(op) { case 1: inserir(); break; case 2: bolha(); break; case 3: selecao(); break; case 4: insercao(); break; case 5: sequencial(); break; case 6: binaria(); break; case 7: listagem(); break; case 0: break; default: printf("\nOpcao Invalida!!!!"); getche();break; } } }
84

Estrutura de Dados - Sonia Virginia Alves Franca

Caricato da

Informazioni sul documento

Descrizione originale:

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Estrutura de Dados - Sonia Virginia Alves Franca

Caricato da

Copyright:

Formati disponibili

Snia Virginia Alves Frana

3. Implementao das Estruturas Estticas .......................................................................................... 12

3.2 Lista Esttica Ordenada.............................................................................................................................21

3.3 Fila Esttica .................................................................................................................................................32

3.4 Pilha Esttica...............................................................................................................................................38

4. Implementao das Estruturas Dinmicas ....................................................................................... 44

4.3 Lista Dinmica Ordenada ..........................................................................................................................53

4.4 Lista Duplamente Encadeada Ordenada..................................................................................................60

4.5 Fila Dinmica ..............................................................................................................................................66

4.6 Pilha Dinmica ............................................................................................................................................71

5. Ordenao e Pesquisa ........................................................................................................................ 76

2. Tipos de Estruturas de Dados

rvore cheia de grau 2: implementao seqencial.

3. Implementao das Estruturas Estticas

3.1 Lista Esttica Desordenada

3.1.1 Operaes Bsicas

3.2 Lista Esttica Ordenada

3.2.1 Operaes Bsicas

3.3 Fila Esttica

3.3.1 Operaes Bsicas

} } while (op != 0); }

3.4 Pilha Esttica

3.4.1 Operaes Bsicas

4. Implementao das Estruturas Dinmicas

4.1 Alocao Dinmica

Simule a execuo dos programas abaixo:

4.2 Lista Dinmica Desordenada

4.2.1 Operaes Bsicas

typedef struct tipo_aluno {

} qa--; free(noatual); printf("\n\nRemovido com sucesso!!!!\n"); } else printf("\n\nRemocao cancelada\n"); break;

} else { noantrem = noatual; noatual = noatual->prox; }

4.3 Lista Dinmica Ordenada

4.3.1 Operaes Bsicas

4.4 Lista Duplamente Encadeada Ordenada

4.4.1 Operaes Bsicas

typedef struct tipo_aluno {

4.5 Fila Dinmica

4.5.1 Operaes Bsicas

4.6 Pilha Dinmica

4.6.1 Operaes Bsicas

5.1.1 Mtodo da Ordenao por Troca

5.1.2 Mtodo da Ordenao por Seleo

5.1.3 Mtodo da Ordenao por Insero

printf("\n\n Vetor Ordenado com Sucesso!!!\n\n"); getche();

Potrebbero piacerti anche