这段代码出了什么问题，我需要更改堆栈的顶部。 这是我的代码，我需要更改堆栈的顶部 另外，我需要更改我的函数 imprime 以从底部到顶部打印。
类似于 1015 20，在函数中pilha_imprime将打印 20 15 10。
我需要了解我是如何在C++中学习堆栈的，以及它是如何工作的。
#include<stdio.h>
#include<stdlib.h>
struct no {
float info;
struct no* prox;
};
typedef struct no No;
struct pilha {
No* prim;
};
pilha* pilha_cria (void){
pilha* p = (pilha*) malloc(sizeof(pilha));
p->prim = NULL;
return p;
}
/* função auxiliar: insere no início */
No* ins_ini (No* l, float v)
{
No* p = (No*) malloc(sizeof(No));
p->info = v;
p->prox = l;
return p;
}
/* função auxiliar: retira do início */
No* ret_ini (No* l)
{
No* p = l->prox;
free(l);
return p;
}
int vazia (pilha* p)
{
return (p->prim==NULL);
}
void pilha_push (pilha* p, float v)
{
p->prim = ins_ini(p->prim,v);
}
float pilha_pop (pilha* p)
{
float v;
if (vazia(p)) {
printf("Pilha vazia.n");
exit(1); /* aborta programa */
}
v = p->prim->info;
p->prim = ret_ini(p->prim);
return v;
}
void pilha_libera (pilha* p)
{
No* q = p->prim;
while (q!=NULL) {
No* t = q->prox;
free(q);
q = t;
}
free(p);
}
/* imprime: versão com lista */
void pilha_imprime (pilha* p)
{
No* q;
for (q=p->prim; q!=NULL; q=q->prox)
printf("%fn",q->info);
}
/* vai imprimir da base para o topo usando as funções já definidas e uma pilha auxiliar */
void imprime (pilha* p)
{
No* q;
for (q=p->prim; q!=NULL; q=q->prox)
printf("%fn",q->info);
}
void troca_topo(pilha* p)
{
if(vazia(p))
{
printf("nPilha Vazia!n");
return;
}
No* no_aux = (No*) malloc(sizeof(No)); // nó auxiliar.
No* tmp = tmp->prox; // ponteiro que aponta para o primeiro nó da pilha.
while(tmp->prox != NULL)// laco que percorre a pilha ate o ponteiro apontar para o ultimo nó.
tmp = tmp->prox;
// troca dos valores:
no_aux->info = tmp->info; // elemento do nó auxiliar recebe o elemento do ultimo nó.
tmp->info = (tmp->prox)->info; // o elemento do ultimo nó recebe o elemento do primeiro nó.
(tmp->prox)->info = no_aux->info; // o primeiro nó recebe o elemento armazenado no nó auxiliar(que era o ultimo elemento).
free(no_aux);// liberar a memoria do nó auxiliar.
}
int main(){
/* Implementação de pilha com lista encadeada */
pilha *p;
p = pilha_cria();
pilha_push(p,10);
pilha_push(p,15);
pilha_push(p,20);
pilha_push(p,25);
float v = pilha_pop(p);
printf("Imprime : %f n", v);
printf("n");
/* vai imprimir do topo para a base, percorrendo a lista encadeada */
pilha_imprime(p);
printf("n");
/* vai imprimir da base para o topo usando as funções já definidas e uma pilha auxiliar */
imprime(p);
printf("n");
/*vai executar a função troca_topo, que troca o valor do topo com aquele abaixo, usando somente as funções push e pop*/
// protótipo: void troca_topo(Pilha*p) - emite mensagem de erro para
// pilha vazia ou com menos de dois elementos.
troca_topo(p);
pilha_imprime(p);
pilha_libera(p);
system("PAUSE");
return 0;
}
有些函数更容易写递归，向后打印堆栈就是其中之一;
void imprime(No* no) {
if (no != NULL) {
imprime(no->prox);
printf("%0.2lfn", no->info);
}
}
/* vai imprimir da base para o topo usando uma funções já definidas*/
void imprime(pilha* p)
{
imprime(p->prim);
}
上下切换不需要malloc。内存已经分配完毕，您所要做的就是切换信息。而且您在分配值之前使用了变量tmp，从而导致奇怪的行为。
void troca_topo(pilha* p)
{
if(vazia(p))
{
printf("nPilha Vazia!n");
return;
}
No* tmp = p->prim; // ponteiro que aponta para o primeiro nó da pilha.
while(tmp->prox != NULL)// laco que percorre a pilha ate o ponteiro apontar para o ultimo nó.
tmp = tmp->prox;
// troca dos valores:
float aux = tmp->info; // elemento auxiliar recebe o elemento do ultimo nó.
tmp->info = p->prim->info; // o elemento do ultimo nó recebe o elemento do primeiro nó.
p->prim->info = aux; // o primeiro nó recebe o elemento armazenado no auxiliar(que era o ultimo elemento).
}