ALGORITMOS E ESTRUTURAS DE DADOS Terceiro Trabalho Prático Recursividade e Pilhas

Transcrição

1 Universidade Federal de Ouro Preto Instituto de Ciências Exatas e Biológicas Departamento de Computação ALGORITMOS E ESTRUTURAS DE DADOS Terceiro Trabalho Prático Recursividade e Pilhas Luiz Henrique Santos Professor - David Menotti Monitor - Kayran dos Santos Ouro Preto 18 de novembro de 2009

2 Sumário 1 Introdução Considerações iniciais Especificação do problema Algoritmo e estruturas de dados TAD - TPilha Função FPVazia Função PEhVazia Função PEmpilha Função PDesempilha Função PTamanho Funções de Verificação Função Prioridade Função VerificaExpressao Função ConverteToPosfix Função ResolveExpressao Main Análise de complexidade dos algoritmos Função FPVazia Função PEhVazia Função PEmpilha Função PDesempilha Função PTamanho Funções de Verificação Função Prioridade Função VerificaExpressao Função ConverteToPosfix Função ResolveExpressao Main Testes 19 5 Conclusão 21 Lista de Figuras 1 Conversão da expressão A*(B+C)/C Resolução da expressão AB+CD-/* Empilha, Desempilha, Pilha Vazia e Tamanho Avaliação de Expressões Conversão paraa forma PosFixa Resolução das expressões

3 Lista de Programas 1 TAD - TPilha Função FPVazia Função PEhVazia Função PEmpilha Função PDesempilha Função PTamanho Funções de Verificação Função Prioridade Função VerificaExpressao Função ConverteToPosfix Função ResolveExpressao Main

4 1 Introdução Consiste em utilizar os conceitos de pilhas e recursividade para a solução de um problema, o cálculo de expressões aritméticas. Esse trabalho é baseado em um dos problemas da Olímpiada Brasileira de Informática do Instituto de Computação da UNICAMP. 1.1 Considerações iniciais Ambiente de desenvolvimento do código fonte: Microsoft Visual C Professional Edition. Linguagem utilizada: Linguagem C. Ambiente de desenvolvimento da documentação: TeXnicCenter 1 BETA Editor de L A TEX. Na análise da ordem de complexidade dos algoritmos será analisado o pior caso sempre. Foram passados ponteiros de estruturas para as funções para economizar memória. 1.2 Especificação do problema A disseminação dos computadores se deve principalmente à capacidade de eles se comportarem como outras máquinas, vindo a substituir muitas destas. Esta flexibilidade é possível porque podemos alterar a funcionalidade de um computador, de modo que ele opere da forma que desejarmos: essa é a base do que chamamos programação. Sua tarefa é escrever um programa que faça com que o computador opere como uma calculadora simples. O seu programa deve ler expressões aritméticas e produzir como saída o valor dessas expressões, como uma calculadora faria. O programa deve implementar apenas um subconjunto reduzido das operações disponíveis em uma calculadora: somas, subtrações, multiplicações e divisões. Entrada A entrada deve ser lida de um arquivo a ser fornecido como parâmetro em linha de comando ( int main(int argc, char**argv) ) composta de vários conjuntos de testes, onde cada linha do arquivo contém uma expressão aritmética a ser avaliada, no seguinte formato: X 1 s 1 X 2 s 2 X 3 s 3...X m 1 s m 1 X m onde X i, 1 i m, é um operando ou uma nova expressão que pode conter parentesis de abertururaaa ( e fechamento ) ; s j, 1 j m, é um operador, representado pelos símbolos + -, * ou / ; Não há espaços em branco entre operandos e operadores. 1

5 O final da entrada é indicado pelo final do arquivo. Lembre-se de respeitar a ordem de precedência entre os operadores. Isto é, a multiplicação (*) e divisão (/) tem precedência sobre a adição (+) e subtração (-). Exemplo de Entrada 4 3+5*2 3*5+2 (3+5)*2 (20/(5*2)+7-(10*5)) Saída Para cada expressão de teste do arquivo de entrada, seu programa deve produzir três linhas. A primeira linha deve conter um identificador da expressão, no formato "Teste n", onde n é numerado a partir de 1. Na segunda linha deve aparecer o resultado encontrado pelo seu programa. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente. Exemplo de Saída Teste 1 4 Teste 2 13 Teste 3 17 Teste 4-39 Teste 5 55 (esta saída corresponde ao exemplo de entrada acima) Restrições Os operandos são valores inteiros limitados entre 0 e 100. [2] 2

6 2 Algoritmo e estruturas de dados 2.1 TAD - TPilha // Definição do TAD typedef char TChave ; typedef double TValor ; typedef struct 5 TChave Chave [ 2 ] ; TValor Valor ; int Dois ; TItem ; 10 typedef struct Celula Apontador ; typedef struct Celula TItem Item ; 15 Apontador pant ; TCelula ; typedef struct 20 Apontador pfundo ; Apontador ptopo ; int Tamanho ; TPilha ; Programa 1: TAD - TPilha Esse TAD TPilha foi criado para representar uma pilha simplesmente encadeada. Ele contem uma estrutura TChave do tipo char, uma estrutura TValor do tipo double, a estrutura TItem que tem um vetor de TChave de duas posições, um campo TValor e um campo Dois do tipo int que indica se o número tem 2 dígitos, uma estrutura Apontador que é do tipo ponteiro para Célula e uma estrutura TCelula que engloba TItem e possui um campo pant do tipo Apontador que aponta para a Célula abaixo. A estrutura TPilha possui 2 campos do tipo Apontador: pfundo, que é um apontador para o elemento no fundo da pilha e ptopo, que é um apontador para o elemento no topo da pilha. A pilha foi implementada com elemento cabeça. [3] 2.2 Função FPVazia //Função que f a z uma p i l h a v a z i a i n i c i a l i z a n d o a void FPVazia ( TPilha ppilha ) // aloca a c é l u l a cabeça 5 ppilha >ptopo = ( Apontador ) malloc ( sizeof ( TCelula ) ) ; // f a z o topo e o fundo apontarem pra e l a ppilha >pfundo = ppilha >ptopo ; //a c é l u l a cabeça não aponta para ninguém ppilha >ptopo >pant = NULL; 10 //o tamanho da p i l h a é 0 ppilha >Tamanho = 0 ; 3

7 Programa 2: Função FPVazia Essa função foi criada para inicializar uma pilha como vazia. Ela recebe como parâmetro um ponteiro para uma estrutura TPilha. Como foi usada uma implementação com elemento cabeça, devemos alocar o espaço para esse elemento. Fazemos os apontadores pfundo e ptopo apontarem para ele, fazemos esse elemento cabeça não apontar para ninguém e inicializamos o tamanho da pilha como Função PEhVazia //Função que v e r i f i c a se uma p i l h a é v a z i a int PEhVazia ( TPilha ppilha ) return ( ppilha >ptopo == ppilha >pfundo ) ; 5 Programa 3: Função PEhVazia Essa função foi criada para testar se uma PILHA é vazia. Se o ponteiro para o fundo apontar para a mesma célula que o ponteiro para o topo, a pilha está vazia. 2.4 Função PEmpilha //Função que empilha um item na p i l h a int PEmpilha ( TPilha ppilha, TItem pitem ) Apontador paux ; 5 // aloca o espaço paux = ( Apontador ) malloc ( sizeof ( TCelula ) ) ; // se nao c o n s e g u i r a l o c a r retorna 0 i f (paux == NULL) return 0 ; 10 // i n s e r e o item ppilha >ptopo >Item = pitem ; // f a z a c é l u l a apontar para o a n t i g o topo paux >pant = ppilha >ptopo ; 15 // f a z o topo apontar para a nova c é l u l a ppilha >ptopo = paux ; // incrementa o tamanho da p i l h a ppilha >Tamanho++; // retorna 1 indicando que o elemento f o i empilhado 20 return 1 ; Programa 4: Função PEmpilha Essa função foi criada para inserir um elemento na pilha. Pela definição de pilha, todo elemento deve ser inserido no seu topo. Ela recebe como parâmetros um ponteiro para uma estrutura TPilha e um ponteiro para uma estrutura TItem. Alocamos espaço para a nova célula, que será a célula cabeça e inserimos o item na célula apontado por ptopo. A nova célula criada deve apontar para o antigo topo e o novo topo é a célula alocada. Por fim, incrementamos o tamanho da pilha e retornamos 1 indicando q o elemento foi empilhado com sucesso. 4

8 2.5 Função PDesempilha //Função que desempilha um item da p i l h a int PDesempilha ( TPilha ppilha, TItem pitem ) 5 Apontador paux ; // se a p i l h a f o r v a z i a não pode se desempilhar i f ( PEhVazia ( ppilha ) ) return 0 ; 10 // guarda se a c é l u l a a s e r desempilhada paux = ppilha >ptopo ; // a t u a l i z a se o topo ppilha >ptopo = paux >pant ; // desempilha se o item 15 pitem = paux >pant >Item ; // l i b e r a sa a área de momoria do item desempilhado f r e e (paux) ; // decrementa o tamanho ppilha >Tamanho ; 20 // retorna 1 indicando q o item f o i dempilhado com s u cesso return 1 ; Programa 5: Função PDesempilha Essa função foi criada para retirar um elemento da pilha. Pela definição de pilha, o elemento retirado deve estar no topo da pilha. Ela recebe como parâmetros um ponteiro para uma TPilha e um ponteiro para TItem no qual será retornado o item retirado. Se a pilha for vazia não é possível retirar. Caso contrário, guardamos um ponteiro para a célula apontada por ptopo, que é a célula cabeça. A nova célula apontada por ptopo é a célula apontada pelo elemento cabeça. Passamos o item a ser desempilhado por ponteiro, que é o campo item da célula apontada pelo elemento cabeça. Por fim, liberamos a memória guardada e retornamos 1 indicando que o elemento foi desempilhado com sucesso. 2.6 Função PTamanho // Retorna o tamanho da p i l h a int PTamanho ( TPilha ppilha ) return ( ppilha >Tamanho) ; 5 Programa 6: Função PTamanho Essa função foi criada para retornar o tamanho da pilha. retorna o campo Tamanho da pilha. Ela simplesmente 5

9 2.7 Funções de Verificação // V e r i f i c a se o c a r a c t e r é um d í g i t o int EhNumero ( char ch ) return ( ch >= 48 && ch <= 57) ; // 0 a 9 5 // V e r i f i c a se o c a r a c t e r é um operador int EhOperador ( char ch ) 10 return ( ch == + ch == ch == ch == / ) ; // V e r i f i c a se o c a r a c t e r é um p a r e n t e s e s a b e r t o int EhParentesesAberto ( char ch ) 15 return ( ch == ( ) ; // V e r i f i c a se o c a r a c t e r é um p a r e n t e s e s fechado 20 int EhParentesesFechado ( char ch ) return ( ch == ) ) ; Programa 7: Funções de Verificação Essas funções foram criadas para identificar se um caracter é um operador, um número, um parêntese aberto ou um parêntese fechado. 2.8 Função Prioridade // V e r i f i c a a p r i o r i d a d e de um operador int P r i o r i d a d e ( char op ) i f ( op == ( ) 5 return 1 ; i f ( op == + op == ) return 2 ; 10 i f ( op == op == / ) return 3 ; return 0 ; Programa 8: Função Prioridade Essa função foi criada para verificar a prioridade de um operador. Ela recebe como parâmetro o operador, que é um caracter, identifica o operador e retorna a prioridade do operador que varia de 1 a 3. Parêntese aberto tem prioridade 1, soma e subtração 2 e multiplicação e divisão 3. Se o caracter não for nenhum desses a função retorna 0. 6

10 2.9 Função VerificaExpressao // V e r i f i c a se uma e s p r e s s ã o i n f i x a é v á l i d a. 1 >V 0 >F int V e r i f i c a E x p r e s s a o ( char Exp [ ] ) // i n t V e r i f i c a E x p r e s s a o ( char Exp ) 5 int i = 0 ; int NumParenteses = 0 ; //o primeiro c a r a c t e r da expressão nao pode s e r um operador i f ( EhOperador (Exp [ 0 ] ) ) return 0 ; 10 // enquanto nao chegar ao f i n a l da expressão while (Exp [ i ]!= \0 ) i f ( EhOperador (Exp [ i ] ) ) 15 // Dois operadores s e g u i d o s ou um operando e um p a r e n t e s e s fechado i f ( ( EhOperador (Exp [ i +1]) ) ( EhParentesesFechado (Exp [ i +1]) ) ) return 0 ; 20 else i f (EhNumero(Exp [ i ] ) ) i f (EhNumero(Exp [ i +1]) ) //3 números s e g u i d o s ou um número de 2 d i g i t o s seguido de p a r ê n t e s e a b e r t o 25 i f (EhNumero(Exp [ i +2]) ( EhParentesesAberto (Exp [ i +2]) ) ) return 0 ; //Numero de 2 d i g i t o s seguido de p a r e n t e s e s a b e r t o ( 30 i f (EhNumero(Exp [ i +1]) && ( EhParentesesAberto (Exp [ i +2]) ) ) return 0 ; //Numero de 1 d i g i t o seguido de p a r e n t e s e s a b e r t o ( i f ( EhParentesesAberto (Exp [ i +1]) ) 35 return 0 ; else i f ( EhParentesesAberto (Exp [ i ] ) ) // incrementa numero de p a r e n t e s e s 40 NumParenteses++; // ( s e g u i d o de operador ou ) i f ( ( EhOperador (Exp [ i +1]) EhParentesesFechado (Exp [ i +1]) ) ) return 0 ; 45 else i f ( EhParentesesFechado (Exp [ i ] ) ) // decrementa o número de p a r e n t e s e s NumParenteses ; 50 // ) s e g u i d o de número ou ( i f ( ( EhNumero(Exp [ i +1]) EhParentesesAberto (Exp [ i +1]) ) ) return 0 ; i ++; 55 7

11 // t e s t a se o número de p a r e n t e s e s a b e r t o é i g u a l ao de fechados i f ( NumParenteses!= 0) return 0 ; // expressao c o r r e t a 60 return 1 ; Programa 9: Função VerificaExpressao Essa função foi criada para avaliar uma expressão infixa. Se a função estiver escrita corretamente ela retorna 1 e se for encontrado algum erro a função ja retorna 0. Foram analisados as seguintes possibilidades de erro: Dois operadores seguidos ou um operando e um parêntese fechado; Três números seguidos ou um número válido seguido de parêntese aberto; Número incorreto de parênteses; Parêntese aberto seguido de operando ou parêntese fechado; Parêntese fechado seguido de número ou parêntese aberto; Parêntese aberto seguido de operando ou parêntese fechado. A função percorre a expressão infixa até encontrar o seu final, o caracter 0. Ela verifica todas as possibilidades de erro citadas acima para cada caracter da expressão e retorna 0 imediatamente se algum erro for encontrado. Ela também conta o número de parênteses abertos e fechados e verifica se são iguais após percorrer toda a expressão. Se nenhum erro for encontrado, a função retorna 1 indicando sucesso. 8

12 2.10 Função ConverteToPosfix // Converte uma expressão da forma i n f i x a para forma p o s f i x a int ConverteToPosfix ( char ExpInfixa [ ], TItem ExpPosfixa [ ] ) TPilha Pilha ; 5 TItem item ; int i = 0 ; // i n d i c e i n f i x a int j = 0 ; // i n d i c e p o s f i x a //Se a expressão não e s t i v e r correnao podemos c o n v e r t e r i f (! ( V e r i f i c a E x p r e s s a o ( ExpInfixa ) ) ) 10 return 0 ; FPVazia(& Pilha ) ; // enquanto nao chegar ao f i n a l da expressão while ( ExpInfixa [ i ]!= \0 ) 15 // se f o r numero copia pra saida i f (EhNumero( ExpInfixa [ i ] ) ) //número de d o i s d í g i t o s 20 i f (EhNumero( ExpInfixa [ i +1]) ) // d i g i t o das desenas no í n d i c e 0 ExpPosfixa [ j ]. Chave [ 0 ] = ExpInfixa [ i ] ; // d i g i t o das unidades no í n d i c e 1 25 ExpPosfixa [ j ]. Chave [ 1 ] = ExpInfixa [ i +1]; // s e t a o campo indicando que o n é de 2 d i g i t o s ExpPosfixa [ j ]. Dois = 1 ; i ++; 30 else ExpPosfixa [ j ]. Chave [ 0 ] = ExpInfixa [ i ] ; //número de 1 d i g i t o ExpPosfixa [ j ]. Dois = 0 ; // não é de 2 d i g i t o s 35 j ++; else i f ( EhOperador ( ExpInfixa [ i ] ) ) // se f o r operador desempilha até achar um com p r i o r i d a d e menor e copia pra s a i da 40 while (! ( PEhVazia(& Pilha ) ) && ( P r i o r i d a d e ( Pilha. ptopo >pant > Item. Chave [ 0 ] ) >= P r i o r i d a d e ( ExpInfixa [ i ] ) ) ) PDesempilha(&Pilha, &item ) ; ExpPosfixa [ j ]. Chave [ 0 ] = item. Chave [ 0 ] ; j ++; 45 item. Chave [ 0 ] = ExpInfixa [ i ] ; // copia o operador encontrado PEmpilha(&Pilha, &item ) ; 50 else i f ( EhParentesesAberto ( ExpInfixa [ i ] ) ) // se f o r ( empilha item. Chave [ 0 ] = ExpInfixa [ i ] ; PEmpilha(&Pilha, &item ) ; 9

13 55 else i f ( EhParentesesFechado ( ExpInfixa [ i ] ) ) // se f o r ) desempilha até achar ( PDesempilha(&Pilha, &item ) ; 60 while (! ( EhParentesesAberto ( item. Chave [ 0 ] ) ) ) ExpPosfixa [ j ]. Chave [ 0 ] = item. Chave [ 0 ] ; j ++; PDesempilha(&Pilha, &item ) ; 65 i ++; 70 // copia todos os simbolos r e s t a n t e s para a saida while (! ( PEhVazia(& Pilha ) ) ) PDesempilha(&Pilha, &item ) ; ExpPosfixa [ j ]. Chave [ 0 ] = item. Chave [ 0 ] ; 75 j ++; // Fecha a s t r i n g com \0 ExpPosfixa [ j ]. Chave [ 0 ] = \0 ; 80 return 1 ; Programa 10: Função ConverteToPosfix Essa função foi criada converter uma expressão da forma infixa para a forma posfixa. Ela recebe como parâmetros e expressão a ser convertiva e uma variável do tipo vetor de TItem pra retornar a expressão posfixa. A conversão da forma Infixa para Posfixa com uso se Pilhas é efetuado da seguinte maneira : 1. Inicializa uma Pilha vazia; 2. Percorre toda a expressão, copiando todos os símbolos encontrados diretamente para uma expressão de saída; Ao encontrar um operador: Enquanto a Pilha não estiver vazia e houver um operador com prioridade maior ou igual ao encontrado, desempilhe o operador e copie-o no saída; Empilhe o operador encontrado; Ao encontrar um parêntese de abertura empilhe-o; Ao encontrar um parêntese de fechamento, desempilhe um símbolo da Pilha e coloque o na expressão de saída. Faça isto até encontrar o parêntese de abertura correspondente; 10

14 Segue um exemplo de conversão da expressão A*(B+C)/C Figura 1: Conversão da expressão A*(B+C)/C 11

15 2.11 Função ResolveExpressao // Resolve uma dada expressão int ResolveExpressao ( TItem PosFix [ ], double Resultado ) TPilha Pilha ; 5 TItem item1, item2 ; char aux1, aux2 ; int i = 0 ; // i n i c i a l i z a a p i l h a como v a z i a 10 FPVazia(& Pilha ) ; // Enquanto não f o r o f i n a l da expressão while (! ( PosFix [ i ]. Chave [ 0 ] == \0 ) ) 15 // se f o r numero empilha o i f (EhNumero( PosFix [ i ]. Chave [ 0 ] ) ) aux1 = PosFix [ i ]. Chave [ 0 ] ; 20 // se o número f o r de 2 d i g i t o s i f ( PosFix [ i ]. Dois == 1) aux2 = PosFix [ i ]. Chave [ 1 ] ; //10 o d i g i t o das dezenas + d i g i t o das unidades 25 item1. Valor = 10 a t o i (&aux1 ) + a t o i (&aux2 ) ; else item1. Valor = a t o i (&aux1 ) ; //1 d i g i t o 30 // empilha o número PEmpilha(&Pilha, &item1 ) ; // se f o r operador desempilha os 2 u l t i m o s e empilha o r e s u l t a d o else i f ( EhOperador ( PosFix [ i ]. Chave [ 0 ] ) ) 35 // desempilha os d o i s ú l t i m o s número antes do operador PDesempilha(&Pilha, &item1 ) ; //X PDesempilha(&Pilha, &item2 ) ; //Y 40 // i d e n t i f i c a q u a l operador switch ( PosFix [ i ]. Chave [ 0 ] ) case : 45 // empilha Y X item2. Valor = item1. Valor ; PEmpilha(&Pilha, &item2 ) ; break ; 50 case / : // empilha Y/X item2. Valor/= item1. Valor ; PEmpilha(&Pilha, &item2 ) ; 55 break ; 12

16 case + : // empilha Y+X 60 item2. Valor += item1. Valor ; PEmpilha(&Pilha, &item2 ) ; break ; case : 65 // empilha Y X item2. Valor = item1. Valor ; PEmpilha(&Pilha, &item2 ) ; break ; 70 i ++; //o r e s u l t a d o encontra se no topo da p i l h a PDesempilha(&Pilha, &item1 ) ; Resultado = item1. Valor ; return 1 ; Programa 11: Função ResolveExpressao Essa função foi criada para Calcular o valor de uma expressão matemática na forma posfixa. Ela recebe como parâmetros a expressão posfixa e uma variável do tipo ponteiro para double na qual será retornado o resultado. A vantagem desta forma posfixa é que sabemos que, percorrendo a expressão da esquerda par a direita, ao encontrarmos um operador, sabemos que ele opera sobre as duas variáveis anteriores a ele. Para converter um caracter para o seu valor numérico utilizou-se a função atoi. Seja a expressão: AB+CD-/*, supondo A=7, B=3, C=6, D=4, E=9: As etapas para resolver esta expressão são as seguintes: Iniciamos com uma Pilha vazia; Varremos a expressão e, para cada elemento encontrado, fazemos: Se for operando, então empilhar seu valor; Se for operador, então desempilhar os dois últimos valores, efetuar a operação com eles e empilhar de volta o resultado obtido; No final do processo, o resultado da avaliação estaráno topo da pilha. 13

17 Segue abaixo a descrição passo a passo da resolução da expressão citada acima [1] Figura 2: Resolução da expressão AB+CD-/* 14

18 2.12 Main #include <s t d i o. h> #include <s t d l i b. h> #include "TExp. h" 5 int main ( int argc, char argv [ ] ) char ArquivoEntrada = argv [ 1 ] ; // arquivo de entrada double Resultado ; // r e s u l t a d o int i = 1 ; 10 char Exp [ 5 0 ] = "" ; // expressão TItem ExpPosfixa [ 5 0 ] ; // expressão p o s f i x a // abre o arquivo em modo de l e i t u r a FILE fp = fopen ( ArquivoEntrada, " r " ) ; 15 i f (! fp ) p r i n t f ( "Erro na a b e r t u r a do arquivo " ) ; e x i t ( 0 ) ; 20 // enquanto nao f o r o f i n a l do arquivo while (! f e o f ( fp ) ) // l ê a expressão f s c a n f ( fp, "%s \n",exp) ; 25 p r i n t f ( " Teste %d\n", i ) ; // V e r i f i c a se a expressão e s t a c o r r e t a e a c o nverte i f ( ConverteToPosfix (Exp, ExpPosfixa ) ) 30 // r e s o l v e a expressão ResolveExpressao ( ExpPosfixa, &Resultado ) ; // imprime o r e s u l t a d o p r i n t f ( "%.1 l f \n\n", Resultado ) ; 35 else p r i n t f ( " Expressao i n c o r r e t a \n\n" ) ; // caso a expressão nao e s t e j a c o r r e t a // incrementa o contador 40 i ++; f c l o s e ( fp ) ; return 0 ; Programa 12: Main O Main do tem a finalidade de utilizar as funções definidas para avaliar expressões matemáticas, conversão para a forma posfixa e a resolução da expressão. O Main consiste de um parser que lê expressões de um arquivo de entrada passado por linha de comando, resolve cada expressão do arquivo e exibe os resultados na tela. Caso a expressão não esteja correta ele exibe uma mensagem indicando qual teste falhou. 15

19 3 Análise de complexidade dos algoritmos 3.1 Função FPVazia Essa função possui 4 comandos. Dessa forma, obtemos a funcao de complexidade para a função: O(n) = 4 (1) Resolvendo a equação obtemos: f(n) = 4 Então a ordem de complexidade da função é O (f(n)), ou seja, O(1). 3.2 Função PEhVazia Essa funcão possui 1 comparação. Dessa forma, obtemos a função de complexidade para a função: O(n) = 1 (2) Resolvendo a equação obtemos: f(n) = 1 Então a ordem de complexidade da função é O (f(n)), ou seja, O(1). 3.3 Função PEmpilha Essa função possui 1 comparação e 6 comandos. Dessa forma, obtemos a função de complexidade para a função: O(n) = 7 (3) Resolvendo a equação obtemos: f(n) = 7 Então a ordem de complexidade da função é O (f(n)), ou seja, O(1). 3.4 Função PDesempilha Essa função possui 1 comparação e 6 comandos. Dessa forma, obtemos a função de complexidade para a função: O(n) = 7 (4) Resolvendo a equação obtemos: f(n) = 7 Então a ordem de complexidade da função é O (f(n)), ou seja, O(1). 3.5 Função PTamanho Essa função possui apenas 1 comando. Dessa forma, obtemos a função de complexidade para a função: O(n) = 1 (5) Resolvendo a equação obtemos: f(n) = 1 Então a ordem de complexidade da função é O (f(n)), ou seja, O(1). 16

20 3.6 Funções de Verificação Essas funções juntas possuem no pior caso 9 comparações. Dessa forma, obtemos a função de complexidade para a função: O(n) = 9 (6) Resolvendo a equação obtemos: f(n) = 9 Então a ordem de complexidade da função é O (f(n)), ou seja, O(1). 3.7 Função Prioridade Essa função possui no pior caso 5 comparações. Dessa forma, obtemos a função de complexidade para a função: O(n) = 5 (7) Resolvendo a equação obtemos: f(n) = 5 Então a ordem de complexidade da função é O (f(n)), ou seja, O1). 3.8 Função VerificaExpressao Essa função possui 2 comparações, 1 atribuição e um loop que percorre toda a expressão que contém 6 comparações no pior caso. Dessa forma, obtemos a função de complexidade para a função: O(n) = 3 + n 1 i=0 6 (8) Resolvendo o somatório obtemos: f(n) = 6n + 3 Então a ordem de complexidade da função é O (f(n)), ou seja, O(n). 3.9 Função ConverteToPosfix Essa função possui 1 comparação, 2 atribuições, a chama da função FPVazia, um loop com a chamada da função PDesempilha e 2 comandos e um loop que percorre toda a expressão que contém 2 comparações e um loop com 2 comandos e a chamada da função PDesempilha, 1 comando e a chamada da função PEmpilha. Dessa forma, obtemos a função de complexidade para a função: O(n) = n 1 i=0 (2 + 7) + n 1 i=0 n 1 ( i=0 (2 + 7)) (9) Resolvendo o somatório obtemos: f(n) = 7 + 9n + 8n + 9n 2 = 9n n + 7 Então a ordem de complexidade da função é O (f(n)), ou seja, O(n 2 ). 17

21 3.10 Função ResolveExpressao Essa função possui 2 atribuições, a chamada das funções FPVazia e PDesempilha, e um loop, que percorre toda a expressão posfixa, que contém, no pior caso, 2 comparações, 2 chamadas da função PDesempilha, um switch com 4 comparações, 2 comandos e a chamada da função PEmpilha. Dessa forma, obtemos a função de complexidade para a função: O(n) = n 1 i= (10) Resolvendo o somatório obtemos: f(n) = 29n + 13 Então a ordem de complexidade da função é O (f(n)), ou seja, O(n) Main Como na função Main é feita a chamada de todas as funções, sua complexidade é dada pela soma de todas as outras complexidades. Dessa forma, obtemos a função de complexidade para a função: O(main) = O(max(O(n 2 ),O(n),O(1))) Resolvendo essa igualdade obtemos que a ordem de complexidade do Main é O(n 2 ). 18

22 4 Testes Foram executados alguns testes para verificar o funcionamento das funções do programa. Figura 3: Empilha, Desempilha, Pilha Vazia e Tamanho Figura 4: Avaliação de Expressões Figura 5: Conversão paraa forma PosFixa 19

23 Figura 6: Resolução das expressões 20

24 5 Conclusão Este trabalho possibilitou um aprofundamento maior sobre a linguagem C, bem como a revisão e fixação de conceitos sobre pilhas, ponteiros e avaliação de expressões matemáticas usando pilhas. Possibilitou também o aprendizado de pilhas implementadas por encadeamento (apontadores). Concluiu-se que avaliar uma expressão da forma posfixa é bem mais simples porque dispensa o uso de parênteses e não há prioridades definidas para os operadores, eles são avaliados na sequência que aparecem. O uso de pilha pra converter uma expressão para forma posfixa e avaliar uma expressão é bem simples e intuitivo. As dificuldades encontradas foram de descobrir que era mais fácil usar a forma posfixa de uma expressão, como convertê-la e avaliá-la. As mesmas foram sanadas com o auxilio da bibliografia citada e a ajuda do monitor. 21

25 Referências [1] Sérgio Furgeri. Avaliação de expressões, [2] David Menotti. CIC102 - Algoritmos e Estruturas de Dados 1, Outubro [3] N. Ziviani. Projeto de Algoritmos: com implementações em Pascal e C. Cengage Learning (Thomson / Pioneira), São Paulo, 2nd edition,