C Fazer uma Pilha em Linguagem C

22 de maio de 2020

Alguém pode me ajudar já tentei fazer uns 15 códigos e nenhum dá certo

No caso das pilhas, as prerrogativas são as seguintes:
1 – A inserção de novos elementos é feita sempre ao final da pilha.
2 – A remoção de elementos também é feita somente no fim da pilha.
Assim, dizemos que a pilha opera ao estilho Last In, First Out (LIFO), ou seja, o último a entrar é o primeiro a sair.

Você deverá desenvolver um programa em Linguagem C que execute os seguintes passos:
1 - Preencher uma pilha com os números do seu R.A.;
2 - Imprimir a pilha na ordem em que os elementos foram inseridos (iniciando pela base, e finalizando pelo topo);
3 – Desempilhar todos os elementos, inserindo-os em uma segunda estrutura de dados do tipo pilha;
4 - Imprimir a nova pilha na ordem em que os elementos foram inseridos (iniciando pela base, e finalizando pelo topo).
Observação importante: seu código-fonte deve declara duas estruturas de dados tipo pilha distintas. A primeira impressão dos dados que seu programa deve fazer está relacionada ao conteúdo da primeira pilha (itens 1 e 2 do passo a passo apresentado acima). Já a segunda impressão dos dados que seu programa fará, está relacionada aos dados que foram inseridos na segunda pilha.
O resultado da execução do seu algoritmo, supondo que seu R.A. é igual ao número 12345678, deverá ser algo parecido com o seguinte:

arfneto · 22 de maio de 2020

pode postar algum programa e dizer qual a sua dificuldade?

23 de maio de 2020

int  elemento1[10];  // vetor que irá armazenar os elementos da pilha

  int  elementos;  // indicador do tamanho da pilha  

};

//----------------------------

// DECLARA AS FUNÇÕES

// ---------------------------

bool empilha(int valor,pilha *mystack );   // insere elementos na pilha

int desempilha(struct pilha *mystack );   // retira elemento da pilha

void imprimepilha(pilha *mystack );    // imprime a pilha

//----------------------------

// INICIO DO PROGRAMA

// ---------------------------

int main( ) {

   struct pilha pilha1;        // Declara a primeira pilha

   struct pilha pilha2;        // Declara a segunda pilha

   pilha1.elementos = pilha2.elementos = 0; // inicializa as pilhas.

   

// ADICIONA ELEMENTOS À PILHA 1

empilha(1,&pilha1);   // Chama a função empilha

empilha(2,&pilha1);   // o primeiro argumento é o numero a adicionar

   empilha(3,&pilha1);   // o segundo argumento é o endereço da pilha

   empilha(4,&pilha1);

   empilha(5,&pilha1);

   empilha(6,&pilha1);

   empilha(7,&pilha1);

   empilha(8,&pilha1);

imprimepilha(&pilha1);  // Chama a função imprimepilha. Argumento é o endereço da pilha



// DESEMPILHA ELEMENTOS DA PILHA 1, PASSANDO PARA PILHA 2

empilha(desempilha(&pilha1),&pilha2);  // desempilha da pilha 1, e empilha na pilha 2

empilha(desempilha(&pilha1),&pilha2); // o primeiro argumento é a função desempilha, que

empilha(desempilha(&pilha1),&pilha2); // desempilha o numero da pilha 1

empilha(desempilha(&pilha1),&pilha2); // o segundo argumento é o endereço da pilha 2

empilha(desempilha(&pilha1),&pilha2); // seria possivel fazer isso usando uma variavel

empilha(desempilha(&pilha1),&pilha2); // intermediaria para armazenar o valor desempilhado

empilha(desempilha(&pilha1),&pilha2); // da pilha1 antes de empilhar na pilha2

empilha(desempilha(&pilha1),&pilha2); //  

   imprimepilha(&pilha2);   // Chama a função imprimepilha. Argumento é o endereço da pilha    

return 0;

}

//----------------------------

// LISTA DE FUNÇÕES

// ---------------------------

//--------------------------------------------

// FUNÇÃO EMPILHA - ADICIONA NUMERO A PILHA

// -------------------------------------------

bool empilha(int valor,pilha *mystack) { // retorna TRUE se adicionou, e FALSE se erro



if (mystack->elementos==100) // se já estiver no tamanho máximo da pilha: 100 elementos

 {

  printf("Tamanho máximo da pilha excedido.\n"); // stack overflow

  return false; // Retorna mensagem de erro ao chamador da função

 }

mystack->elemento1[mystack->elementos]=valor; // adiciona o valor ao vetor da pilha

mystack->elementos++;      //  atualiza numero de elementos  

   //printf( "Elementos : %d\n", mystack->elementos);

   //printf( "Elemento incluido: %d\n\n", valor);

   return true; // retorna mensagem de sucesso  

}

//----------------------------------------------

// FUNÇÃO DESEMPILHA - RETIRA NUMERO A PILHA

// ---------------------------------------------

int desempilha(pilha *mystack ) { // retorna o valor retirado da pilha e -1 se erro.  

if (mystack->elementos==0) // pilha vazia  

 {

  printf("Nao ha elementos na pilha.\n"); // pilha zerada

  return -1; // Retorna mensagem de erro ao chamador da função

 }

mystack->elementos--; //  atualiza numero de elementos. Nao há necessidade de editar o vetor.

   //printf( "Elementos : %d\n", mystack->elementos);

   return mystack->elemento1[mystack->elementos]; // retorna elemento desempilhado.  

}

// -----------------------------------------------------

// FUNÇÃO IMPRIMEPILHA - para gerar o output da tarefa.  

// -----------------------------------------------------

void imprimepilha(pilha *mystack )

{      

if (mystack->elementos==0) // pilha vazia  

 {

  printf("Nao ha elementos na pilha.\n"); // pilha zerada, mensagem de erro

  return;         // retorna a main

 }

for (int i=0;i<mystack->elementos;i++)  // Estrutura de repetição, corre os elementos do vetor

 printf( "%d ", mystack->elemento1[i]); // imprime o numero, e segue um espaço " ".

   printf("\n");        // enter no final

return;          // retorna a main

}