//順序棧定義及實現
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
//函式結果狀態程式碼
#define  TRUE                 1
#define  FALSE                0
#define   OK                  1
#define  ERROR                0
#define  INFEASIBLE           -1
#define  OVERFLOW             -2
#define  STACK_INIT_SIZE      100
#define  STACKINCREMENT       10


typedef int Status;
typedef char SElemType;
typedef struct {
			SElemType*base;
			SElemType*top;
			int stacksize;
}Stack;
void CopySElemType(SElemType&s,SElemType e)
{
      s=e;
}
Status InitStack(Stack &S)
{
      //建立一個空棧；
      S.base=(SElemType*)malloc(sizeof(SElemType));
      if(!S.base)exit(OVERFLOW);
      S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;
}
Status DestroyStack(Stack&S)
{
      free(S.base);S.top=NULL;S.base=NULL;S.stacksize=0;return OK;
}
void ClearStack(Stack&S)
{
      S.top=S.base;S.stacksize=STACK_INIT_SIZE;
}
Status EmptyStack(Stack S)
{
      if(S.top-S.base)return FALSE;
      return OK;
}
Status Push(Stack &S,SElemType e)
{
      if(S.top-S.base==S.stacksize)
      {
            Stack SS;SS.top=(SElemType*)realloc(S.base,sizeof(S.stacksize+STACKINCREMENT));
            if(!SS.base)exit(OVERFLOW);
            free(S.base);S.base=SS.base;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;
      }
      CopySElemType(*S.top,e);S.top++;return OK;
}
Status Pop(Stack &S,SElemType &e)
{
      if(S.top==S.base)return ERROR;
      CopySElemType(e,*(S.top-1));--S.top;
      return OK;
}
Status GetTop(Stack S,SElemType&e)
{
      if(S.top==S.base)return FALSE;
      CopySElemType(e,*(S.top-1));return OK;
}
Status SetTop(Stack&S,SElemType e)
{
      if(EmptyStack(S))return FALSE;
      CopySElemType(*(S.top-1),e);return OK;
}
 

對於鏈式棧可以用如下的定義方式

 typedef struct SNode{  
      SElemType data;
      struct SNode *next;
 }SNode, *LinkStack;

具體實現，以後有時間再加！
2、佇列概念: 佇列類似線性表和棧,也是定義線上性結構上的ADT,與線性表和棧的區別在於，元素的插入和刪除分別在表的兩端進行。
類似日常生活中排隊,允許插入的一端為隊尾(rear),允許刪除端稱隊頭(front)
特性:First In First Out先進先出，如作業系統中的作業佇列和列印任務佇列、日常生活中各類排隊業務等均可用佇列模擬
佇列一般也有兩種儲存形式，鏈式佇列和順序佇列（迴圈佇列），這裡我只寫了鏈式佇列的，另一種以後補充。

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include"stack_sq.h"


#define  TRUE                 1
#define  FALSE                0
#define   OK                  1
#define  ERROR                0
#define  INFEASIBLE           -1
#define  OVERFLOW             -2


typedef int Status;
typedef char QElemType;
typedef struct QNode{
      QElemType data;
      struct QNode*next;
}QNode,*QueuePtr;
typedef struct{
      QueuePtr front;
      QueuePtr rear;
}LinkQueue;
Status InitQueue(LinkQueue&Q)
{
      Q.front=(QNode*)malloc(sizeof(QNode));
      if(!Q.front)exit(OVERFLOW);
      Q.rear=Q.front;Q.front->next=NULL;
      return OK;
}
Status DestroyQueue(LinkQueue&Q)
{
      QNode*p=Q.front->next;
      while(p)
      {
            Q.front->next=p->next;free(p);
            p=Q.front->next;
      }
      free(Q.front );Q.front=Q.rear=NULL;
      return OK;
}
Status ClearQueue(LinkQueue&Q)
{
      QueuePtr p=Q.front->next;
      while(p)
      {
            Q.front->next=p->next;
            free(p);p=Q.front->next;
      }
      Q.rear=Q.front;return OK;
}
Status EnQueue(LinkQueue&Q,QElemType e)
{
      QueuePtr p;p=(QNode*)malloc(sizeof(QNode));
      if(!p)exit(OVERFLOW);
      p->next=NULL;p->data=e;
      Q.rear->next=p;Q.rear=p;return OK;
}
Status DeQueue(LinkQueue&Q,QElemType&e)
{
      if(Q.rear==Q.front)return FALSE;
      QueuePtr p=Q.front->next;e=p->data;
      Q.front->next=p->next;
      if(p==Q.rear)Q.rear=Q.front;
      return OK;
}
 

下面是學習的時候做過的一個判斷是不是迴文的程式碼，一起附上吧。

#include"queue_L.h"


Status HuiWen(QElemType *p)
{
      LinkQueue Q;Stack S;SElemType se;QElemType qe;
      if(InitQueue(Q));if(InitStack(S));
      while(*p!='@'&&*p!='\n')
      {
            if(EnQueue(Q,*p));if(Push(S,*p));++p;
      }
      while(Pop(S,se)&&DeQueue(Q,qe))
      {
            if(se!=qe){printf("不是迴文。");return FALSE;}
      }
      printf("是迴文。");return OK;
}
int main()
{
      char s[100]="
 
[email protected]";
      if(HuiWen(s));
      return 0;
}

ps:雖然簡單，但也是我當年一個一個程式碼敲上去的，還望各位用心指教。