Lista Pilha

Melissa Nonato - Código do exercício comentado
Exercício 1: Crie uma função chamada criaPilhaque inicializa uma pilha vazia e a
retorna como um ponteiro.
typedef struct {
int itens[MAX_TAMANHO];
int topo;
} Pilha;
Pilha* criaPilha() {
Pilha* novaPilha = (Pilha*)malloc(sizeof(Pilha));
if (novaPilha == NULL) {
printf("Erro: Falha na alocação de memória para a pilha.\n");
exit(1);
}
novaPilha->topo = -1; // Inicializa o topo como -1 (pilha vazia)
return novaPilha;
}
int main() {
Pilha* minhaPilha = criaPilha();
printf("Pilha criada com sucesso!\n");
return 0;
}
Exercício 2: Crie uma função chamada empilhaque recebe uma pilha e um valor inteiro
como parâmetros e empilha o valor na pilha.
typedef struct { // definindo uma estrutura chamada struct

int itens[MAX_TAMANHO]; // criando uma array de inteiros chamada itens
int topo; // criando uma array de inteiros chamada topo
} Pilha; // essa estrutura toda representa a pilha onde itens armazenará os
elementos da pilha e o topo indicaará a posição do elemento no topo da pilha
Pilha* criaPilha() { //função criaPilha responsável por criar e inicializar uma

pilha,aloca dinamicamente memória para a piha através do malloc e retorna um
ponteiro para a pilha que foi recém-criada
if (novaPilha == NULL) { // verifica se a alocação de memória foi bem sucedida,
se a novaPilha for NULL signfica que a alocação falho e será impressa uma mensafem
de erro seguita pela chamada de exit(1) para encerrar o programa com um código de
erro
Pilha* novaPilha = (Pilha*)malloc(sizeof(Pilha)); // aqui o ponteiro novaPilha
é declarado e é alocada memória dinamicamente para uma nova instância da esutura
Pila usando malloc. A funcção sizeof(Pilha) é usada para determinar o tamanho
necessário para alocar memória para a estrutura Pilha. O ponteiro é convetido para
o tipo Pilha*
printf("Erro: Falha na alocação de memória para a pilha.\n"); // mensagem
exibida caso ocorra um erro na verificação da alocação de memória
exit(1); // encerra o programa com um código de erro caso haja falh na
alocação de memória
}
novaPilha->topo = -1; // Inicializa o topo como -1 (pilha vazia) // o campo
topo da estrutura novaPilha é inicializado com -1, o que indica que a pilha está
vazia no momento da criação
return novaPilha; // a função retorna o ponteiro para a pilha recém criada
}
void empilha(Pilha* pilha, int valor) { // a função empilha é responsável por
adicionar um valor na pilha, ela recebe um ponteiro para a pilha pilha e um valor
inteiro valor como argumentos
if (pilha->topo == MAX_TAMANHO - 1) { // verifica condicionalmente se a pilha
está cheia, a pilha está cheia quando topo é igual a MAX_TAMANHO - 1. Se a pilha
estiver cheia, uma mensagem de erro é apresentada, indicando que não é possível
empilhar o valor desejado
printf("Erro: Pilha cheia, não é possível empilhar o valor %d.\n",
valor); // mensagem de erro apresentada caso a verificação condicional indicar que
a pilha está cheia
} else { // caso a pilha não esteja cheia
pilha->itens[++(pilha->topo)] = valor; // o valor valor é adicionado a
pilha, o campo topo é incrementado em 1 antes de ser usado com índica para o array
itens. Isso significa que o novo elemento será empilhado no topo da pilha
}
}
int main() {
Pilha* minhaPilha = criaPilha(); // no main é criada uma nova pilha chamada
minhaPilha, é criada chamandao a função criaPilha(). Ela aloca dinamicamente
memória para a pilha e a inicializa
printf("Pilha criada com sucesso!\n"); //é exibida a mensagem de que a pilha
foi criada com sucesso
empilha(minhaPilha, 10); // um valor de 10 é empilhado na pilha minhaPilha

empilha(minhaPilha, 20);// um valor de 20 é empilhado na pilha minhaPilha
empilha(minhaPilha, 30);// um valor de 30 é empilhado na pilha minhaPilha
// Você pode adicionar mais valores à pilha conforme necessário.

free(minhaPilha); // a memória alocada dinamicamente para a pilha minhaPilha é
liberada antes de encerrar o programa para evitar vazamentos de memoria
return 0;
}
Neste exemplo, a função empilha verifica se a pilha não está cheia (limite definido
como MAX_TAMANHO) e, se não estiver cheia, empilha o valor passado como argumento
na pilha. O código cria uma pilha, empilha alguns valores nela e, em seguida,
libera a memória da pilha antes de encerrar o programa.
Exercício 3: Crie uma função chamada desempilhaque recebe uma pilha como parâmetro
e remove o elemento do topo da pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}
void empilha(Pilha* pilha, int valor) {
if (pilha->topo == MAX_TAMANHO - 1) {
printf("Erro: Pilha cheia, não é possível empilhar o valor %d.\n", valor);
} else {
pilha->itens[++(pilha->topo)] = valor;
}
}
int desempilha(Pilha* pilha) {

if (pilha->topo == -1) {
printf("Erro: Pilha vazia, não é possível desempilhar.\n");
return -1; // Ou outro valor de erro adequado
} else {
return pilha->itens[(pilha->topo)--];
}
}
int main() {
empilha(minhaPilha, 10);
int valorDesempilhado = desempilha(minhaPilha);
printf("Valor desempilhado: %d\n", valorDesempilhado);
free(minhaPilha);
return 0;
}
Exercício 4: Crie uma função chamada topoPilhaquerecebe uma pilha como parâmetro e
retorna o elemento do topo da pilha sem removê-lo.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}
int topoPilha(Pilha* pilha) {

printf("Erro: Pilha vazia, não há elemento no topo.\n");
} else {
return pilha->itens[pilha->topo];
}
}
int main() {
int valorTopo = topoPilha(minhaPilha);

printf("Elemento no topo da pilha: %d\n", valorTopo);
free(minhaPilha);
return 0;
}
Exercício 5: Crie uma função chamada tamanhoPilhaque recebe uma pilha como
parâmetro e retorna o número de elementos na pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}
} else {
}
}
int tamanhoPilha(Pilha* pilha) {
return pilha->topo + 1; // O tamanho é o topo + 1
}
int main() {
int tamanho = tamanhoPilha(minhaPilha);

printf("Tamanho da pilha: %d\n", tamanho);
free(minhaPilha);
return 0;
}
Exercício 6: Crie uma função chamada limpaPilhaque recebe uma pilha como parâmetro
e a esvazia, removendo todos os elementos.
#include <stdlib.h>
#define MAX_TAMANHO 100
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}
void limpaPilha(Pilha* pilha) {

pilha->topo = -1; // Define o topo como -1 para esvaziar a pilha
}
int main() {
printf("Tamanho da pilha antes da limpeza: %d\n", minhaPilha->topo + 1);
limpaPilha(minhaPilha);
printf("Pilha esvaziada.\n");
printf("Tamanho da pilha após a limpeza: %d\n", minhaPilha->topo + 1);
free(minhaPilha);
return 0;
}
Exercício 7: Crie uma função chamada copiaPilhaque recebe uma pilha como parâmetro
e retorna uma cópia da pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}
Pilha* copiaPilha(Pilha* pilha) {

Pilha* novaPilha = criaPilha();
for (int i = 0; i <= pilha->topo; i++) {

empilha(novaPilha, pilha->itens[i]);
}
return novaPilha;
}
int main() {
Pilha* copiaMinhaPilha = copiaPilha(minhaPilha);

printf("Pilha copiada.\n");
free(minhaPilha);
free(copiaMinhaPilha);
return 0;
}
Exercício 8: Crie uma função chamada invertePilhaque recebe uma pilha como
parâmetro e inverte a ordem dos elementos na pilha original.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
void invertePilha(Pilha* pilha) {

Pilha* pilhaAuxiliar = criaPilha();
// Transferir elementos da pilha original para a pilha auxiliar

while (pilha->topo != -1) {
int valor = desempilha(pilha);
empilha(pilhaAuxiliar, valor);
}
// Transferir elementos da pilha auxiliar de volta para a pilha original

while (pilhaAuxiliar->topo != -1) {
int valor = desempilha(pilhaAuxiliar);
empilha(pilha, valor);
}
free(pilhaAuxiliar); // Liberar a pilha auxiliar

}
void imprimirPilha(Pilha* pilha) {

// Imprimir elementos da pilha original enquanto os desempilha

printf("%d ", valor);
}
// Transferir elementos de volta para a pilha original

}
}
int main() {
printf("Pilha original: ");

imprimirPilha(minhaPilha);
printf("\n");
invertePilha(minhaPilha);
printf("Pilha invertida: ");

printf("\n");
free(minhaPilha);
return 0;
}
Exercício 9: Crie uma função chamada verificaPilhaVaziaque recebe uma pilha como
parâmetro e retorna verdadeiro se a pilha estiver vazia e falso caso contrário.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}
bool verificaPilhaVazia(Pilha* pilha) {

return (pilha->topo == -1); // Verdadeiro se o topo for -1 (pilha vazia), falso
caso contrário
}
int main() {
printf("A pilha está vazia? %s\n", verificaPilhaVazia(minhaPilha) ? "Sim" :

"Não");
printf("A pilha está vazia? %s\n", verificaPilhaVazia(minhaPilha) ? "Sim" :

"Não");
free(minhaPilha);
return 0;
}
Exercício 10: Crie uma função chamada concatenaPilhasquerecebe duas pilhas como
parâmetros e concatena os elementos da segunda pilha no final da primeira pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
void concatenaPilhas(Pilha* pilha1, Pilha* pilha2) {

// Desempilhe os elementos da pilha2 e empilhe na pilha1
while (pilha2->topo != -1) {
int valor = desempilha(pilha2);
empilha(pilha1, valor);
}
}

// Imprimir elementos da pilha enquanto os desempilha

}

}

}
int main() {
Pilha* pilha1 = criaPilha();
empilha(pilha1, 10);
printf("Pilha 1 antes da concatenação: ");

imprimirPilha(pilha1);
printf("\n");
printf("Pilha 2 antes da concatenação: ");

printf("\n");
concatenaPilhas(pilha1, pilha2);
printf("Pilha 1 após a concatenação: ");

printf("\n");
free(pilha1);
free(pilha2);
return 0;
}
Exercício 11: Crie uma função chamada invertePilhaSemUmaPilhaAuxiliarque recebe uma

pilha como parâmetro e inverte a ordem dos elementos na pilha original, sem usar
uma pilha auxiliar.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
void invertePilhaSemPilhaAuxiliar(Pilha* pilha) {

if (pilha->topo != -1) {
invertePilhaSemPilhaAuxiliar(pilha); // Chamada recursiva
insereNoFundo(pilha, valor);
}
}
// Função para inserir um elemento no fundo da pilha

void insereNoFundo(Pilha* pilha, int valor) {
} else {
int temp = desempilha(pilha);
insereNoFundo(pilha, valor);
empilha(pilha, temp);
}
}


}
}

}
int main() {

printf("\n");
invertePilhaSemPilhaAuxiliar(minhaPilha);
printf("Pilha invertida: ");

printf("\n");
free(minhaPilha);
return 0;
Exercício 12: Crie uma função chamada calculaMediaPilhaque recebe uma pilha de
números inteiros como parâmetro e retorna a média dos valores na pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
float calculaMediaPilha(Pilha* pilha) {

int soma = 0;
int quantidade = 0;
// Desempilhe os elementos, calcule a soma e a quantidade

soma += valor;
quantidade++;
}
// Verifique se a pilha estava vazia

if (quantidade == 0) {
printf("A pilha está vazia. Não é possível calcular a média.\n");
return 0.0; // Ou outro valor de erro adequado
}
return (float)soma / quantidade;

}
int main() {
float media = calculaMediaPilha(minhaPilha);
printf("Média dos valores na pilha: %.2f\n", media);
free(minhaPilha);
return 0;
}
Exercício 13: Crie uma função chamada ordenaPilhaque recebe uma pilha de números
inteiros como parâmetro e a ordena em ordem crescente.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
void ordenaPilha(Pilha* pilha) {


while (pilhaAuxiliar->topo != -1 && pilhaAuxiliar->itens[pilhaAuxiliar-

>topo] > valor) {
int temp = desempilha(pilhaAuxiliar);
empilha(pilha, temp);
}
}

}

}


}

}

}
int main() {

printf("\n");
ordenaPilha(minhaPilha);
printf("Pilha ordenada em ordem crescente: ");

printf("\n");
free(minhaPilha);
return 0;
}
Exercício 14: Crie uma função chamada copiaPilhaInvertidaque recebe uma pilha como
parâmetro e retorna uma cópia invertida da pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
Pilha* copiaPilhaInvertida(Pilha* pilha) {

Pilha* copiaPilha = criaPilha();
// Copia a pilha original para a pilha de cópia

empilha(copiaPilha, valor);
}
// Inverte a ordem na pilha de cópia

}
// Libera a pilha auxiliar

free(pilhaAuxiliar);
return copiaPilha;
}


}

}

}
int main() {

printf("\n");
Pilha* copiaInvertida = copiaPilhaInvertida(minhaPilha);
printf("Cópia invertida da pilha original: ");

imprimirPilha(copiaInvertida);
printf("\n");
free(minhaPilha);
free(copiaInvertida);
return 0;
}
Exercício 15: Crie uma função chamada mesclaPilhasque recebe duas pilhas como
parâmetros e mescla os elementos das duas pilhas em uma terceira pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
Pilha* mesclaPilhas(Pilha* pilha1, Pilha* pilha2) {

Pilha* pilhaMesclada = criaPilha();
// Desempilhe os elementos da primeira pilha e empilhe na pilha mesclada

empilha(pilhaMesclada, valor);
}
// Desempilhe os elementos da segunda pilha e empilhe na pilha mesclada

empilha(pilhaMesclada, valor);
}
return pilhaMesclada;
}


}

}

}
int main() {
printf("Pilhas criadas com sucesso!\n");
printf("Pilha 1: ");
printf("\n");
printf("Pilha 2: ");
printf("\n");
Pilha* pilhaMesclada = mesclaPilhas(pilha1, pilha2);
printf("Pilha mesclada: ");

imprimirPilha(pilhaMesclada);
printf("\n");
free(pilha1);
free(pilha2);
free(pilhaMesclada);
return 0;
}
Exercício 16: Crie uma função chamada removeElementoPilhaque recebe uma pilha e um
valor como parâmetros e remove todas as ocorrências desse valor na pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
void removeElementoPilha(Pilha* pilha, int valor) {

// Desempilhe os elementos da pilha original e remova as ocorrências do valor

int elemento = desempilha(pilha);
if (elemento != valor) {
empilha(pilhaAuxiliar, elemento);
}
}

int elemento = desempilha(pilhaAuxiliar);
empilha(pilha, elemento);
}

}

}

}

}
int main() {
empilha(minhaPilha, 20); // Incluindo uma segunda ocorrência de 20

printf("\n");
int valorParaRemover = 20;

removeElementoPilha(minhaPilha, valorParaRemover);
printf("Pilha após a remoção de %d: ", valorParaRemover);

printf("\n");
free(minhaPilha);
return 0;
}
Exercício 17: Crie uma função chamada copiaNPrimeirosElementosque recebe uma pilha
e um número ncomo parâmetros e retorna uma cópia dos primeiros nelementos da pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}
} else {
}
}

} else {
}
}
Pilha* copiaNPrimeirosElementos(Pilha* pilha, int n) {

int contador = 0;
while (pilha->topo != -1 && contador < n) {

contador++;
}
// Inverte a ordem da cópia da pilha (caso deseje manter a ordem original)

while (copiaPilha->topo != -1) {
int valor = desempilha(copiaPilha);
}
}
return copiaPilha;
}


}

}

}
int main() {

printf("\n");
int n = 3; // Copiar os primeiros 3 elementos

Pilha* copiaDosPrimeirosNElementos = copiaNPrimeirosElementos(minhaPilha, n);
printf("Cópia dos primeiros %d elementos: ", n);

imprimirPilha(copiaDosPrimeirosNElementos);
printf("\n");
free(minhaPilha);
free(copiaDosPrimeirosNElementos);
return 0;
}
Exercício 18: Crie uma função chamada copiaElementosMaioresque recebe uma pilha e
um valor limitecomo parâmetros e retorna uma cópia dos elementos maiores que o
limitena pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}
} else {
}
}
Pilha* copiaElementosMaiores(Pilha* pilha, int limite) {

// Desempilhe os elementos da pilha original e copie os elementos maiores que o

limite
if (valor > limite) {
}
}

}
}
return copiaPilha;
}


}

}

}
int main() {

printf("\n");
int limite = 30; // Copiar os elementos maiores que 30

Pilha* copiaDosElementosMaiores = copiaElementosMaiores(minhaPilha, limite);
printf("Cópia dos elementos maiores que %d: ", limite);

imprimirPilha(copiaDosElementosMaiores);
printf("\n");
free(minhaPilha);
free(copiaDosElementosMaiores);
return 0;
}
Exercício 19: Crie uma função chamada copiaElementosMenoresque recebe uma pilha e
um valor limitecomo parâmetros e retorna uma cópia dos elementos menores que o
limitena pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
Pilha* copiaElementosMenores(Pilha* pilha, int limite) {
// Desempilhe os elementos da pilha original e copie os elementos menores que o

limite
if (valor < limite) {
}
}

}
}
return copiaPilha;
}


}

}

}
int main() {

printf("\n");
int limite = 30; // Copiar os elementos menores que 30

Pilha* copiaDosElementosMenores = copiaElementosMenores(minhaPilha, limite);
printf("Cópia dos elementos menores que %d: ", limite);

imprimirPilha(copiaDosElementosMenores);
printf("\n");
free(minhaPilha);
free(copiaDosElementosMenores);
return 0;
}
Exercício 20: Crie uma função chamada insereOrdenadoPilhaque recebe uma pilha e um
valor como parâmetros e insere o valor na pilha de forma ordenada em ordem
crescente.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
void insereOrdenadoPilha(Pilha* pilha, int valor) {

// Desempilhe os elementos da pilha original e encontre a posição correta para

o novo valor
while (pilha->topo != -1 && pilha->itens[pilha->topo] < valor) {
empilha(pilhaAuxiliar, elemento);
}
// Empilhe o novo valor na posição correta

// Transferir elementos maiores de volta para a pilha original

int elemento = desempilha(pilhaAuxiliar);
}

}


}

}

}
int main() {
insereOrdenadoPilha(minhaPilha, 30);
printf("Pilha ordenada: ");

printf("\n");
free(minhaPilha);
return 0;
}
Exercício 21: Crie uma função chamada somaElementosPilhaque recebe uma pilha como
parâmetro e retorna a soma de todos os elementos na pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
int somaElementosPilha(Pilha* pilha) {

int soma = 0;
// Desempilhe os elementos da pilha e some-os

soma += valor;
}
return soma;
}


}

}

}
int main() {

printf("\n");
int soma = somaElementosPilha(minhaPilha);

printf("Soma dos elementos na pilha: %d\n", soma);
free(minhaPilha);
return 0;
}
Exercício 22: Crie uma função chamada copiaPilhaque recebe uma pilha como parâmetro
e retorna uma cópia idêntica da pilha original.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
Pilha* copiaPilha(Pilha* pilha) {

Pilha* copia = criaPilha();
Pilha* auxiliar = criaPilha();
// Desempilhe os elementos da pilha original e empilhe na cópia

empilha(auxiliar, valor);
}
// Transferir elementos de volta para a pilha original e copia

while (auxiliar->topo != -1) {
int valor = desempilha(auxiliar);
empilha(copia, valor);
}
free(auxiliar); // Liberar a pilha auxiliar
return copia;
}


}

}

}
int main() {
printf("Pilha original criada com sucesso!\n");

printf("\n");
Pilha* copiaMinhaPilha = copiaPilha(minhaPilha);
printf("Cópia da pilha: ");

imprimirPilha(copiaMinhaPilha);
printf("\n");
free(minhaPilha);
free(copiaMinhaPilha);
return 0;
}
Exercício 23: Crie uma função chamada removeElementosParesque recebe uma pilha como
parâmetro e remove todos os elementos pares da pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
void removeElementosPares(Pilha* pilha) {

Pilha* pilhaImpares = criaPilha();
// Desempilhe os elementos da pilha original e empilhe apenas os ímpares

if (valor % 2 != 0) {
empilha(pilhaImpares, valor);
}
}
// Copie os elementos de volta para a pilha original

while (pilhaImpares->topo != -1) {
int valor = desempilha(pilhaImpares);
}
free(pilhaImpares); // Liberar a pilha de ímpares

}


}

}

}
int main() {

printf("\n");
removeElementosPares(minhaPilha);
printf("Pilha sem elementos pares: ");

printf("\n");
free(minhaPilha);
return 0;
}
Exercício 24: Crie uma função chamada inverteOrdemElementosque recebe uma pilha
como parâmetro e inverte a ordem dos elementos na pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
void inverteOrdemElementos(Pilha* pilha) {

// Desempilhe os elementos da pilha original e empilhe na pilha auxiliar

}
// Copie os elementos de volta para a pilha original (agora na ordem inversa)

}

}


}

}

}
int main() {

printf("\n");
inverteOrdemElementos(minhaPilha);
printf("Pilha com elementos invertidos: ");

printf("\n");
free(minhaPilha);
return 0;
}
Exercício 25: Crie uma função chamada tamanhoPilhaque recebe uma pilha como
parâmetro e retorna o número de elementos na pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
int tamanhoPilha(Pilha* pilha) {
return pilha->topo + 1;
}


}

}

}
int main() {

printf("\n");
int tamanho = tamanhoPilha(minhaPilha);

printf("Tamanho da pilha: %d\n", tamanho);
free(minhaPilha);
return 0;
}
Exercício 26: Crie uma função chamada comparaPilhasque recebe duas pilhas como
parâmetros e verifica se elas são iguais (ou seja, têm os mesmos elementos na mesma
ordem).
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
int comparaPilhas(Pilha* pilha1, Pilha* pilha2) {

if (pilha1->topo != pilha2->topo) {
return 0; // Pilhas têm tamanhos diferentes, não são iguais
}

int valor1 = desempilha(pilha1);
int valor2 = desempilha(pilha2);
if (valor1 != valor2) {
return 0; // Elementos diferentes, pilhas não são iguais
}
}
return 1; // Pilhas são iguais

}


}

}

}
int main() {
Pilha* pilhaA = criaPilha();
Pilha* pilhaB = criaPilha();
empilha(pilhaA, 10);
empilha(pilhaB, 10);
printf("Pilha A: ");
imprimirPilha(pilhaA);
printf("\n");
printf("Pilha B: ");
imprimirPilha(pilhaB);
printf("\n");
if (comparaPilhas(pilhaA, pilhaB)) {
printf("As pilhas A e B são iguais.\n");
} else {
printf("As pilhas A e B não são iguais.\n");
}
free(pilhaA);
free(pilhaB);
return 0;
}
Exercício 27: Crie uma função chamada intercalaPilhasque recebe duas pilhas como
parâmetros e cria uma terceira pilha com os elementos intercalados das duas pilhas
originais.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}
} else {
}
}
Pilha* intercalaPilhas(Pilha* pilhaA, Pilha* pilhaB) {

Pilha* pilhaResultado = criaPilha();
Pilha* pilhaAuxiliarA = criaPilha();

Pilha* pilhaAuxiliarB = criaPilha();
// Desempilhe os elementos das duas pilhas originais e empilhe na pilha de

resultado
while (pilhaA->topo != -1 || pilhaB->topo != -1) {
if (pilhaA->topo != -1) {
int valorA = desempilha(pilhaA);
empilha(pilhaResultado, valorA);
empilha(pilhaAuxiliarA, valorA);
}
if (pilhaB->topo != -1) {
int valorB = desempilha(pilhaB);
empilha(pilhaResultado, valorB);
empilha(pilhaAuxiliarB, valorB);
}
}
// Transferir elementos de volta para as pilhas originais

while (pilhaAuxiliarA->topo != -1) {
int valorA = desempilha(pilhaAuxiliarA);
empilha(pilhaA, valorA);
}
while (pilhaAuxiliarB->topo != -1) {

int valorB = desempilha(pilhaAuxiliarB);
empilha(pilhaB, valorB);
}
free(pilhaAuxiliarA);
free(pilhaAuxiliarB);
return pilhaResultado;
}


}

}

}
int main() {
Pilha* pilhaA = criaPilha();
Pilha* pilhaB = criaPilha();
printf("Pilha A: ");
imprimirPilha(pilhaA);
printf("\n");
printf("Pilha B: ");
imprimirPilha(pilhaB);
printf("\n");
Pilha* pilhaC = intercalaPilhas(pilhaA, pilhaB);
printf("Pilha C (intercalada): ");

imprimirPilha(pilhaC);
printf("\n");
free(pilhaA);
free(pilhaB);
free(pilhaC);
return 0;
}
Exercício 28: Crie uma função chamada removeElementoEspecificoque recebe uma pilha
e um valor como parâmetros e remove todas as ocorrências desse valor na pilha.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
void removeElementoEspecifico(Pilha* pilha, int valor) {

Pilha* pilhaTemporaria = criaPilha();

if (elemento != valor) {
empilha(pilhaTemporaria, elemento);
}
}
// Copie os elementos de volta para a pilha original

while (pilhaTemporaria->topo != -1) {
int elemento = desempilha(pilhaTemporaria);
}
free(pilhaTemporaria); // Liberar a pilha temporária

}


}

}

}
int main() {

printf("\n");
int valorARemover = 20;

removeElementoEspecifico(minhaPilha, valorARemover);
printf("Pilha após remover %d: ", valorARemover);

printf("\n");
free(minhaPilha);
return 0;
}
Exercício 29: Crie uma função chamada copiaInvertidaPilhaque recebe uma pilha como
parâmetro e retorna uma cópia invertida (em ordem contrária) da pilha original.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
Pilha* copiaInvertidaPilha(Pilha* pilhaOriginal) {

Pilha* pilhaCopiaInvertida = criaPilha();
// Desempilhe os elementos da pilha original e empilhe na pilha auxiliar na
ordem inversa
while (pilhaOriginal->topo != -1) {
int valor = desempilha(pilhaOriginal);
}
// Copie os elementos da pilha auxiliar para a pilha de cópia invertida

empilha(pilhaCopiaInvertida, valor);
}
return pilhaCopiaInvertida;
}


}

}

}
int main() {

printf("\n");
Pilha* pilhaCopiaInvertida = copiaInvertidaPilha(minhaPilha);
printf("Cópia invertida da pilha original: ");

imprimirPilha(pilhaCopiaInvertida);
printf("\n");
free(minhaPilha);
free(pilhaCopiaInvertida);
return 0;
}
Exercício 30: Crie uma função chamada pilhaEhPalindromoque recebe uma pilha como
parâmetro e verifica se ela representa um palíndromo. Um palíndromo é uma sequência
que é igual quando lida da esquerda para a direita e da direita para a esquerda.
typedef struct {
int topo;
} Pilha;
exit(1);
}
return novaPilha;
}

} else {
}
}

} else {
}
}
bool pilhaEhPalindromo(Pilha* pilha) {

Pilha* pilhaInvertida = criaPilha();
// Copie os elementos da pilha original para uma pilha invertida

for (int i = 0; i <= pilha->topo; i++) {
empilha(pilhaInvertida, pilha->itens[i]);
}
// Compare os elementos das duas pilhas

int elementoOriginal = desempilha(pilha);
int elementoInvertido = desempilha(pilhaInvertida);
if (elementoOriginal != elementoInvertido) {
free(pilhaInvertida);
return false; // Não é um palíndromo
}
}
free(pilhaInvertida);
return true; // É um palíndromo
}


}

}

}
int main() {

printf("\n");
if (pilhaEhPalindromo(minhaPilha)) {
printf("A pilha representa um palíndromo.\n");
} else {
printf("A pilha NÃO representa um palíndromo.\n");
}
free(minhaPilha);
return 0;
}

Lista Pilha

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Lista Pilha

Enviado por

Direitos autorais:

Formatos disponíveis

Melissa Nonato - Código do exercício comentado

typedef struct { // definindo uma estrutura chamada struct

Pilha* criaPilha() { //função criaPilha responsável por criar e inicializar uma

empilha(minhaPilha, 10); // um valor de 10 é empilhado na pilha minhaPilha

// Você pode adicionar mais valores à pilha conforme necessário.

int desempilha(Pilha* pilha) {

void empilha(Pilha* pilha, int valor) {

int topoPilha(Pilha* pilha) {

int valorTopo = topoPilha(minhaPilha);

int tamanho = tamanhoPilha(minhaPilha);

#define MAX_TAMANHO 100

void empilha(Pilha* pilha, int valor) {

void limpaPilha(Pilha* pilha) {

printf("Tamanho da pilha antes da limpeza: %d\n", minhaPilha->topo + 1);

printf("Tamanho da pilha após a limpeza: %d\n", minhaPilha->topo + 1);

void empilha(Pilha* pilha, int valor) {

Pilha* copiaPilha(Pilha* pilha) {

for (int i = 0; i <= pilha->topo; i++) {

Pilha* copiaMinhaPilha = copiaPilha(minhaPilha);

void empilha(Pilha* pilha, int valor) {

int desempilha(Pilha* pilha) {

void invertePilha(Pilha* pilha) {

// Transferir elementos da pilha original para a pilha auxiliar

// Transferir elementos da pilha auxiliar de volta para a pilha original

free(pilhaAuxiliar); // Liberar a pilha auxiliar

void imprimirPilha(Pilha* pilha) {

// Imprimir elementos da pilha original enquanto os desempilha

// Transferir elementos de volta para a pilha original

printf("Pilha original: ");

printf("Pilha invertida: ");

void empilha(Pilha* pilha, int valor) {

bool verificaPilhaVazia(Pilha* pilha) {

printf("A pilha está vazia? %s\n", verificaPilhaVazia(minhaPilha) ? "Sim" :

printf("A pilha está vazia? %s\n", verificaPilhaVazia(minhaPilha) ? "Sim" :

void empilha(Pilha* pilha, int valor) {

int desempilha(Pilha* pilha) {

void concatenaPilhas(Pilha* pilha1, Pilha* pilha2) {

void imprimirPilha(Pilha* pilha) {

// Imprimir elementos da pilha enquanto os desempilha

// Transferir elementos de volta para a pilha original

free(pilhaAuxiliar); // Liberar a pilha auxiliar

printf("Pilha 1 antes da concatenação: ");

printf("Pilha 2 antes da concatenação: ");

printf("Pilha 1 após a concatenação: ");

Exercício 11: Crie uma função chamada invertePilhaSemUmaPilhaAuxiliarque recebe uma

void empilha(Pilha* pilha, int valor) {

int desempilha(Pilha* pilha) {

void invertePilhaSemPilhaAuxiliar(Pilha* pilha) {

// Função para inserir um elemento no fundo da pilha

void imprimirPilha(Pilha* pilha) {

// Imprimir elementos da pilha enquanto os desempilha

free(pilhaAuxiliar); // Liberar a pilha auxiliar

printf("Pilha original: ");

printf("Pilha invertida: ");

void empilha(Pilha* pilha, int valor) {

int desempilha(Pilha* pilha) {

float calculaMediaPilha(Pilha* pilha) {

// Desempilhe os elementos, calcule a soma e a quantidade

// Verifique se a pilha estava vazia

return (float)soma / quantidade;

float media = calculaMediaPilha(minhaPilha);

printf("Média dos valores na pilha: %.2f\n", media);

void empilha(Pilha* pilha, int valor) {