从尾到头打印链表中每个节点的值（采用栈实现）

看到这个题目，我们就会想到可以用栈来实现这个目的，因为栈的特性是先进后出，那么从头到尾遍历这个链表，遍历一个结点便将此结点入栈，知道遍历完成，将栈中元素一一输出即可，代码如下：

<span style="font-size:18px;">#include<stdio.h>
#include<malloc.h>
#define MAXSIZE 20

//链表定义
typedef struct listnode
{
 int data;
 struct  listnode *next;
}listnode,*linklist;

//栈的定义
typedef struct 
{
   linklist data[MAXSIZE];
   int top;
}seqstack;


//尾插法创建链表
linklist creat_listnode()
{
   int x;
   linklist r,s;
   linklist head=(linklist)malloc(sizeof(listnode));
   head->next=NULL;
   head->data=0;
   r=head;   //r->next也为空
   scanf("%d",&x);
   while(x!=-1)
   {
      s=(linklist)malloc(sizeof(listnode));
      s->data=x;
	  s->next=r->next;  //让新插入的结点next域为空
	  r->next=s;       
	  r=s;             
	  scanf("%d",&x);
   }
 //  r->next=NULL;
   return head;
}


//置空栈，建立栈空间
seqstack *init()
{
   seqstack *s;
   s=malloc(sizeof(seqstack));
   s->top=-1;
   return s;
}

//判栈空
int empty(seqstack *s)
{
  if(s->top==-1)  return 1;
  else return 0;
}

//入栈
int push(seqstack *s,linklist x)
{
  if(s->top==MAXSIZE-1)  return 0;
  else
  {
    s->top++;
	s->data[s->top]=x;
	return 1;
  }
}

//出栈
int pop(seqstack *s)
{

  if(s->top==-1)  return 0;
  else{
     //s->data[s->top];
	 s->top--;
	 return 1;
  }
}
//取栈顶元素
linklist top(seqstack *s)
{
  if(s->top==-1)  return 0;
  else
  {
     return (s->data[s->top]);
  }  
}

//从尾到头输出链表
void printlist(listnode *head)
{
  seqstack *s;
  linklist p=head->next;
  s=init();
 // printf("%d\t",s->top);
  while(p!=NULL)
  {
    push(s,p);
	p=p->next;
  }
 
  while(!empty(s))
  {
    p=top(s);
    printf("%d\t",p->data);
    pop(s);
	
  }
  printf("\n");
}


int main()
{
  listnode *head;
  listnode *phead;
  head=creat_listnode();
  phead=head->next;
  while(phead!=NULL)
  {
    printf("%d\t",phead->data);
	phead=phead->next;
  }
  printf("\n");
  printlist(head);
  return 0;
}</span>

既然想到了用栈来实现这个函数，而递归本质上就是栈，所以我们也可以用递归来实现，但是当链表非常长的时候，就会导致函数调用的层级很深，从而导致函数调用栈溢出，所以显示用栈比递归实现的代码鲁棒性更好一些。