C++ Desempilhar e mostrar elementos- Pilha com alocação

DarkWindG · 13 de maio de 2019

Estou com problema na hora de fazer um desempilhar e uma função que mostre todos os elementos, toda vez que faço da algum erro.

os erros na ultima compilação são: "Há mais argumentos que o necessário na função 'int pop(Pilha*)' " e "Erro neste ponto do arquivo(no case 2)"

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <locale>



using namespace std;

typedef int Elemento;

typedef struct nodo{

Elemento item;

struct nodo *prox;

}* No;

typedef struct{

No topo;
int tamanho;

}Pilha;

void inicializaPilha(Pilha *p){

p->topo=NULL;

}

void push(Pilha *p, Elemento ele){

No novoNo;

novoNo = (nodo*) malloc(sizeof(struct nodo));

novoNo->item=ele;

novoNo->prox=p->topo;

p->topo=novoNo;

}

int pop(Pilha *p){

Elemento ele;

No aux;

if (p->topo!=NULL){

ele = p->topo->item;

aux = p->topo;

p->topo = p->topo->prox;

free(aux);

} else{

puts("A pilha está vazia - Underflow");

}

return ele;

}


 main()
{
	Pilha B;
	No A;
	inicializaPilha(&B);
	int escolha, valor;

	
	while(escolha!=5){
		
		cout <<"Empilhar";
		cout <<"Desempilhar";
		cin >> escolha;
		
		switch(escolha){
			case 1:
				
				cout <<"Insira o valor:/n";
				cin >> valor;
				
				push(&B,valor);
				break;
			case 2:
				
				
				cout <<"Valor removido/n";
				pop(&B,valor);
				break
		}
		
	}
	
	return 0;
}

Flávio Pedroza · 13 de maio de 2019

A função pop só pede um argumento, então o correto seria:

case 2:
				
				
				cout <<"Valor removido/n";
				pop(&B);
				break

Benjamin Breeg · 13 de maio de 2019

Cara no C++ você pode alocar a memoria de uma forma + simples..

Você só precisa criar um struct que vai ser servir de lista encadeada para a pilha e ai fazer a alocação de memoria.

Modifiquei o seu exemplo por alto para você entender melhor. Eu não sou familiarizado com C para implementar listas encadeadas e alocar memoria mais em C++ é +/- isso.

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <locale>

using namespace std;

struct no{
    int elem;
    struct no *prox;
};
struct no* topo = NULL;

void push(int valor)
{
    struct no* novoNo = (struct no*) malloc(sizeof(struct no));
    novoNo->elem=valor;
    novoNo->prox=topo;
    topo=novoNo;
}

void pop()
{
    if (topo==NULL)
        cout << "A pilha está vazia - Underflow" << endl;
    else {
      cout<<"Elemento removido: "<< topo->elem <<endl;
      topo = topo->prox;
   }
}
 int main()
{
	int escolha, valor;

	while(escolha!=5){
		cout <<"Empilhar" << endl;
		cout <<"Desempilhar" << endl;
		cin >> escolha;

		switch(escolha){
			case 1:
				cout <<"Insira o valor:\n";
				cin >> valor;
				push(valor);
				break;
			case 2:
				pop();
				break;
		}

	}

	return 0;
}

DarkWindG · 14 de maio de 2019

o desempilhar funcionou agora, mas continua sem ideia de como fazer a função mostrar, tudo que achei na internet não funcionou.

14 de maio de 2019

@LucasAC Olá. Para imprimir essa estrutura de dados (pilha), basicamente seria isso:

void imprimir() {

    struct no* aux = topo;

    do {
        cout << aux->elem << " ";
        aux = aux->prox;
    } while (aux != NULL);
}

Seria interessante verificar se a pilha não está vazia antes de imprimir (na função imprimir mesmo)

Só que está imprimindo ao contrário (!?)

Peguei por base o código do @Benjamin Breeg

Benjamin Breeg · 14 de maio de 2019

Como assim ao contrario.. esta certo.. ta exibindo do ultimo elemento empilhado ao primeiro, o primeiro elemento que foi inserido na pilha é o último a ser removido.

14 de maio de 2019

@Benjamin Breeg Olá. Veja nesse exemplo bem didático:

#include <iostream>
using namespace std;

#define CAPACIDADE 5

int pilha[CAPACIDADE];

int fim = 0;

void push(int elem) {

    if (fim >= CAPACIDADE) {
        cout << "A estrutura de dados esta cheia" << endl;
    } else {
        pilha[fim] = elem;
        fim++;
    }
}

int pop() {

    if (fim == 0) {
        cout << "A estrutura de dados esta vazia" << endl;
        return -1;
    }
    return pilha[--fim];
}

void imprimir() {

    if (fim == 0) {
        cout << "Estrutura de dados vazia" << endl;
    } else {
        for (int i = 0; i < fim; i++) {
            cout << pilha[i] << " ";
        }
    }
}

int vazia() {
    return (fim == 0);
}

int main() {

    int n;

    push(1);
    push(2);
    push(3);
    push(4);
    push(5);
    push(6);

    imprimir();

    cout << endl;

    while (!vazia()) {
        n = pop();
        cout << "Atendendo elemento: " << n << endl;
    }

    imprimir();

    push(7);
    push(8);
    push(9);
    push(10);
    push(11);

    imprimir();

    return 0;
}

Fiz esse código apenas para revisar sobre o assunto

Desculpa a sinceridade, mas ousaria dizer que você está trabalhando com lista encadeada, tal como você mesmo mencionou, mas está inserindo os elementos no início da lista

Se estou errado peço que me corrijam!

Benjamin Breeg · 14 de maio de 2019

Não é apenas uma lista encadeada, o que esta sendo implementado é uma estrutura pilha usando lista encadeada.

14 de maio de 2019

Se alguém tive sugestões fique a vontade para postar!

adicionado 9 minutos depois

Tem esse material sobre lista encadeada que pode ser útil aqui

Acredito que, se inserirmos os elementos no final da lista, como é mostrado nesse material, a questão fica resolvida

Segue o link do mesmo:

https://www.ic.unicamp.br/~ra069320/PED/MC102/1s2008/Apostilas/Cap10.pdf

Uma pilha, como o @Benjamin Breeg já mencionou, segue o conceito LIFO (Last In First Out). Último que entra é o primeiro que sai, tal como uma pilha de pratos (por exemplo)

15 de maio de 2019

@LucasAC Olá. Dei uma olhada melhor em seu código e quase deu. Fica a seu critério mesmo falar o que acha, ok?

Segue o código:

#include <iostream>
#include <cstdlib>
using namespace std;

typedef int Elemento;

typedef struct nodo {
    Elemento item;
    struct nodo *prox;
}* No;


typedef struct {
    No topo;
    int tamanho;
} Pilha;

void inicializaPilha(Pilha *p) {
    p->topo = NULL;
}

void push(Pilha *p, Elemento elem) {

    No novoNo;

    novoNo = (nodo*) malloc(sizeof(struct nodo));

    novoNo->item = elem;

    novoNo->prox = p->topo;

    p->topo = novoNo;
}

int pop(Pilha *p) {

    Elemento elem;

    No aux;

    if (p->topo != NULL) {

        elem = p->topo->item;

        aux = p->topo;

        p->topo = p->topo->prox;

        free(aux);

    } else {
        puts("A pilha está vazia - Underflow");
    }
    return elem;
}

void imprimir(Pilha *p) {

    No aux = p->topo;

    while (aux != NULL) {
        cout << aux->item << " ";
        aux = aux->prox;
    }
    cout << endl;
}

int  main()
{
    Pilha B;
    No A;
    inicializaPilha(&B);
    int escolha, valor;
    int elemento;

    do {

        cout << "1 - Empilhar" << endl;
        cout << "2 - Desempilhar" << endl;
        cout << "3 - Imprimir" << endl;
        cout << "4 - Sair" << endl;
        cin >> escolha;

        switch (escolha) {
        case 1:

            cout <<"Insira o valor: ";
            cin >> valor;

            push(&B, valor);
            break;
        case 2:
            elemento = pop(&B);
            cout <<"Valor removido: " << elemento << endl;
            break;
        case 3:
            imprimir(&B);
            break;
        case 4:
            // Sair
            break;
        default:
            cout << "\nOpcao invalida!\n" << endl;
            break;
        }
    } while (escolha != 4);

    return 0;
}

A questão é a mesma mencionada acima, na hora de imprimir, mas isso é você que vê

Se for olhar no exemplo que postei os elementos são impressos conforme a ordem de inserção

Ficamos no aguardo

Forte abraço!

Benjamin Breeg · 15 de maio de 2019

Então agora esta funcionando como uma estrutura pilha, o primeiro exemplo de lista que você enviou foi usando vetor mas não fica dinâmico como ele queria, a pilha pode ser implementada usando vetores ou listas encadeadas.

Uma forma de fazer uma lista usando classes e new do c++ ao invés de malloc é +/- assim

#include <iostream>

using namespace std;

template<typename T>
class Lista
{
private:
    class No
    {
    public:
        No* prox;
        T elem;

        No(T elem, No* prox = nullptr)
        {
            this->elem = elem;
            this->prox = prox;
        }
        ~No()
        {
            delete this->prox;
        }
    };
    No* prim;
    int nos;
public:
    Lista()
    {
        this->prim = nullptr;
        this->nos = 0;
    }
    ~Lista()
    {
        delete this->prim;
    }

    void push(T elem)
    {
        if(this->prim == nullptr)
        {
            this->prim = new No(elem);
        }
        else
        {
            No* novo = this->prim;
            while(novo->prox != nullptr)
                novo = novo->prox;
            novo->prox = new No(elem);
        }
        this->nos++;
    }

	void mostra()
    {
        cout << "Mostrando os Elementos\n";
        No *ptr = prim;
        for(No *ptr = prim; ptr != nullptr; ptr = ptr->prox)
            cout << ptr->elem << "\n";
    }
};

int main()
{
    Lista<int> lista1;
    Lista<string> lista2;

    lista1.push(1);
    lista1.push(2);
    lista1.push(3);

    lista2.push("Um");
    lista2.push("Dois");
    lista2.push("Tres");

    lista1.mostra();
    lista2.mostra();

    system("PAUSE");
    return 0;
}

O template é para usar a lista com mais de um tipo.

15 de maio de 2019

@Benjamin Breeg É, a ideia, no exemplo que postei, foi apenas focar na didática. De fato não serve para a forma como o ele quer resolver o exercício mesmo

Mas por hoje tá bom

Obs: Você também não desiste assim tão rápido, hein!?

Forte abraço e desculpa alguma coisa!