链栈的代码实现

        链栈是指采用链式存储结构实现的栈。通常链栈用单链表来表示，链栈的节点结构与单链表的结构相同，在此用Node表示。Node中的elem表示数据元素（数据域），next表示指向下一节点（直接后继）的指针。头节点中的数据域表示链栈最大可用容量。

        以下就是链栈的不同代码实现:

        C语言（LinkedStack）：

#ifndef LINKEDSTACK_H_INCLUDED
#define LINKEDSTACK_H_INCLUDED
#define TRUE 1
#define FALSE -1
typedef int ElemType;
typedef struct Node
{
    ElemType elem;
    struct Node *next;
}StackNode,*LinkedStack;
int InitStack(LinkedStack *S,int length)
{

    (*S)=(StackNode*)malloc(sizeof(StackNode));
    if((*S)!=NULL)
    {
        (*S)->next=NULL;
        (*S)->elem=length;
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}
void DestroyStack(LinkedStack *S)
{
    StackNode *p=(*S);
    while((*S)!=NULL)
    {
        p=(*S);
        (*S)=p->next;
        free(p);
        p=NULL;
    }
}
void ClearStack(LinkedStack *S)
{
    StackNode *p=(*S)->next;
    while((*S)->next!=NULL)
    {
        p=(*S)->next;
        (*S)->next=p->next;
        free(p);
        p=NULL;
    }
}
int StackEmpty(LinkedStack *S)
{
    if((*S)->next==NULL)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}
int StackLength(LinkedStack *S)
{
    StackNode *p=(*S);
    int i=0;
    while(i<(*S)->elem&&p->next!=NULL)
    {
        i++;
        p=p->next;
    }
    return i;
}
ElemType GetTop(LinkedStack *S)
{
    if((*S)->next!=NULL)
    {
        return (*S)->next->elem;
    }
    else
    {
        return FALSE;
    }
}
int Push(LinkedStack *S,ElemType elem)
{
    if(StackLength(S)==(*S)->elem)
    {
        return FALSE;
    }
    else
    {
        StackNode *s;
        s=(StackNode*)malloc(sizeof(StackNode));
        s->elem=elem;
        s->next=(*S)->next;
        (*S)->next=s;
        return TRUE;
    }
}
ElemType Pop(LinkedStack *S)
{
    if((*S)->next==NULL)
    {
        return FALSE;
    }
    else
    {
        StackNode *p=(*S)->next;
        (*S)->next=p->next;
        ElemType tmp=p->elem;
        free(p);
        p=NULL;
        return tmp;
    }
}
void StackTraverse(LinkedStack *S)
{
    StackNode *p=(*S)->next;
    while(p!=NULL)
    {
        printf("%d\t",p->elem);
        p=p->next;
    }
    printf("\n");
}
#endif // LINKEDSTACK_H_INCLUDED
	

        Java语言：

package DataStructure.LinearList;
public class StackBySingleLinkedList {
    protected Object elem;
    protected StackBySingleLinkedList next;
    public StackBySingleLinkedList(Object elem)
    {
        this.elem=elem;
    }
    public StackBySingleLinkedList(){}
}

package DataStructure.LinearList;
public class LinkedStack{
    private StackBySingleLinkedList stack;
    public void InitStack()
    {
        this.stack=new StackBySingleLinkedList();
        this.stack.next=null;
    }
    public Boolean DestoryStack()
    {
        ClearStack();
        this.stack.elem=null;
        this.stack.next=null;
        this.stack=null;
        return true;
    }
    public Boolean ClearStack()
    {
        int i=this.StackLength();
        int j=0;
        while (j<i)
        {
            this.Pop();
            j++;
        }
        return true;
    }
    public Boolean StackEmpty()
    {
        if (this.stack.next!=null)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    public int StackLength()
    {
        int i=0;
        StackBySingleLinkedList temp=this.stack;
        while (temp.next!=null)
        {
            temp=temp.next;
            i++;
        }
        return i;
    }
    public Object GetTop()
    {
        return this.stack.elem;
    }
    public Boolean Push(Object elem)
    {
        StackBySingleLinkedList top=new StackBySingleLinkedList(elem);
        top.next=this.stack;
        this.stack=top;
        return true;
    }
    public Object Pop()
    {
        if (this.StackLength()==0)
        {
            return -1;
        }
        StackBySingleLinkedList bottom=this.stack.next;
        Object Get=this.stack.elem;
        this.stack=bottom;
        return Get;
    }
    public void StackTraverse()
    {
        StackBySingleLinkedList temp=stack;
        int i=0;
        while(i<this.StackLength())
        {
            System.out.print(temp.elem+"\t");
            temp=temp.next;
            i++;
        }
        System.out.println("");
    }
}