struct Nodo { int struct Nodo typedef struct Nodo *PNodo; PNodo ConstruirPilha () { int PNodo Criar printf scanf while Push printf scanf return

Transcrição

1 Considere as declarações de Nodo e PNodo (adaptada dos apontamentos) seguintes: struct Nodo { int Elemento; struct Nodo *Ant; ; typedef struct Nodo *PNodo; Copiar para o ficheiro PilhaInteiros.h e adaptar as funções associadas às seguintes operações: Criar, Vazia, Push, Pop e Topo. 1) Implementar uma função para construir uma pilha S com valores inteiros positivos, inseridos a partir do teclado. PNodo ConstruirPilha () { int X; PNodo S = Criar(); printf( Inserir um inteiro positivo não nulo (negativo para terminar): \n ); scanf( %d, &X); while (X > 0) { S = Push(X, S); printf( Inserir um inteiro positivo (negativo para terminar): \n ); scanf( %d, &X); return S; 2) Usando a definição de pilha de inteiros em cima, implemente uma função que dada uma pilha S, determine o segundo elemento a partir do topo da pilha S. Nota: para se consultar o 2º elemento a partir do topo, o elemento que está no topo tem que ser removido; desta forma, a pilha S poderá sofrer alteração. int ConsultarSegundoElemento_1 (PNodo *S) { if (Vazia(*S) == 1) return -1; // operação sem sucesso, pois a pilha S está vazia if (Vazia(*S) == 1) // se a pilha S ficou vazia, então não há 2º elemento return -1; return Topo(*S);

2 Programa principal: int Num; Num = ConsultarSegundoElemento_1(&S); printf( O segundo elemento da pilha é : %d\n, Num); printf( Sem segundo elemento!\n ); 3) Usando a definição de pilha de inteiros em cima, implemente uma função que dada uma pilha S, determine o segundo elemento a partir do topo da pilha S, mas deixando a pilha S inalterada. Nota: para se consultar o 2º elemento a partir do topo, o elemento que está no topo tem que ser removido e depois terá que ser inserido de novo; desta forma, a pilha S não sofre qualquer alteração em termos de conteúdo, mas o indicador de topo sim. int ConsultarSegundoElemento_2(PNodo *S) { int Aux, Num; if (Vazia(*S) == 1) return -1; // operação sem sucesso, pois a pilha S está vazia Aux = Topo(*S); // elemento no topo para ser reinserido mais tarde if (Vazia(*S) == 1) { // se a pilha S ficou vazia, então não há 2º elemento *S = Push(Aux, *S); // reinserir o elemento removido return -1; Num = Topo(*S); // retirar o 2º elemento e guardá-lo *S = Push(Aux, *S); // reinserir o elemento removido return Num; // devolver o 2º elemento

3 Programa principal: int Num; Num = ConsultarSegundoElemento_2(&S); printf( O segundo elemento da pilha é : %d\n, Num); printf( Sem segundo elemento!\n ); 4) Usando a definição de pilha de inteiros em cima, implemente uma função que dada uma pilha S e um inteiro N, determine o N-ésimo elemento a partir do topo da pilha S. Nota: remover os N-1 elementos do topo da pilha e consultar o N-ésimo elemento int ConsultarNesimoElemento_1 (PNodo *S, int N) { int k; for (k = 1; k < N; k++) { // remover os N-1 elementos do topo if (Vazia(*S) == 1) return -1; // operação sem sucesso, a pilha S está vazia if (Vazia(*S) == 1) // se a pilha S ficou vazia, então não há 2º elemento return -1; return Topo(*S);

4 Programa principal: int Num, N; printf( Insira um valor inteiro maior do que 0 : ); scanf( %d, &N); Num = ConsultarNesimoElemento_1(&S, N); printf( O %dº elemento da pilha é : %d\n, N, Num); printf( Sem %dº elemento na pilha!\n, N); 5) Usando a definição de pilha de inteiros em cima, implemente uma função que dada uma pilha S e um inteiro N, determine o N-ésimo elemento a partir do topo da pilha S, deixando a pilha S inalterada. (Sugestão: usar uma pilha auxiliar). Nota: remover os N-1 elementos do topo da pilha e inseri-los numa pilha auxiliar; consultar o N-ésimo elemento e reinserir os N-1 elementos da pilha auxiliar na pilha S int ConsultarNesimoElemento_2 (PNodo *S, int N) { int Num = -1, k, flag = 1, cont = 0; PNodo SAux = Criar(); while (cont < N && flag == 1) { // passar os N-1 elementos de S para SAux if (Vazia(*S)) flag = 0; // operação sem sucesso, a pilha S está vazia cont++; SAux = Push(SAux, Topo(*S)); if (flag == 1 &&!Vazia(*S)) // foram removidos N-1 elementos e Num = Topo(*S); // S não vazia; logo, há N-ésimo elemento

5 for (k = 1; k <= cont; k++) { // reinserir os elementos de SAux em S *S = Push(*S, Topo(SAux); SAux = Pop(SAux); return Num; // Num = -1, se não há N-ésimo elemento Programa principal: int Num, N; printf( Insira um valor inteiro maior do que 0 : ); scanf( %d, &N); Num = ConsultarNesimoElemento_2(&S, N); printf( O %dº elemento da pilha é : %d\n, N, Num); printf( Sem %dº elemento na pilha!\n ); 6) Usando a definição de pilha de inteiros em cima, implemente uma função que dada uma pilha S, determine o elemento do fundo da pilha S. Nota: remover todos os elementos da pilha S, guardando sempre o último elemento que será o que se encontra no fundo da pilha quando esta ficar vazia. int ConsultarElementoFundo_1 (PNodo *S) { int Num = -1; while (Vazia(*S) == 0) { Num = Topo(*S); return Num;

6 7) Usando a definição de pilha de inteiros em cima, implemente uma função de dada uma pilha S, determine o elemento do fundo da pilha, deixando a pilha inalterada. Nota: remover todos os elementos da pilha S, guardo-os numa pilha auxiliar; o elemento do fundo da pilha S é o que se encontra no topo da pilha auxiliar. int ConsultarElementoFundo_2 (PNodo *S) { int Num = -1; PNodo SAux = Criar(); while (Vazia(*S) == 0) { SAux = Push(SAux, Topo(*S)); Num = Topo(SAux); while (Vazia(SAux) == 0) { *S = Push(*S, Topo(SAux)); SAux = Pop(SAux); SAux = LibertarNodo(SAux); return Num;