c語言棧隊列
『壹』 c語言棧和隊列問題：停車場停車問題
#ifndef__PLOT_H__#define__PLOT_H__#defineFALSE0#defineTRUE1#defineMONEY1//單價可以自己定義#defineMAX_STOP10#defineMAX_PAVE100//存放汽車牌號typedefstruct{
inttime1;//進入停車場時間
inttime2;//離開停車場時間
charplate[10];
//汽車牌照號碼，定義一個字元指針類型}Car;//停放棧typedefstruct{
CarStop[MAX_STOP-1];//各汽車信息的存儲空間
inttop;//用來指示棧頂位置的靜態指針}Stopping;//等候隊列typedefstruct{intcount;//用來指示隊中的數據個數
CarPave[MAX_PAVE-1];//各汽車信息的存儲空間
intfront,rear;//用來指示隊頭和隊尾位置的靜態指針}Pavement;//讓路棧typedefstruct{
CarHelp[MAX_STOP-1];//各汽車信息的存儲空間
inttop;//用來指示棧頂位置的靜態指針}Buffer;
Stoppings;
Pavementp;
Bufferb;
Carc;charC[10];voidstop_pave();//車停入便道voidcar_come();//車停入停車位voidstop_to_buff();//車進入讓路棧voidcar_leave();//車離開voidwelcome();//主界面函數voidDisplay();//顯示車輛信息#
源文件PLot.c
#include"PLot.h"#include<stdio.h>#include<time.h>//包含時間函數的頭文件#include<string.h>#include<stdlib.h>voidstop_to_pave()//車停入便道{//判斷隊滿
if(p.count>0&&(p.front==(p.rear+1)%MAX_PAVE))
{printf("便道已滿，請下次再來
");
}else
{strcpy(p.Pave[p.rear].plate,C);
p.rear=(p.rear+1)%MAX_PAVE;//隊尾指示器加1
p.count++;//計數器加1
printf("牌照為%s的汽車停入便道上的%d的位置
",C,p.rear);
}
}voidcar_come()//車停入停車位{printf("請輸入即將停車的車牌號:");//輸入車牌號
scanf("%s",&C);if(s.top>=MAX_STOP-1)//如果停車位已滿，停入便道
{
stop_to_pave();//停車位->便道函數
}else
{
s.top++;//停車位棧頂指針加1
time_tt1;longintt=time(&t1);//標記進入停車場的時間
char*t2;
t2=ctime(&t1);//獲取當前時間
c.time1=t;strcpy(s.Stop[s.top].plate,C);//將車牌號登記
printf("牌照為%s的汽車停入停車位的%d車位,當前時間:%s
",C,s.top+1,t2);
}return;
}voidstop_to_buff()//車進入讓路棧{//停車位棧壓入臨時棧，為需要出棧的車輛讓出道
while(s.top>=0)
{
if(0==strcmp(s.Stop[s.top--].plate,C))
{break;
}//讓出的車進入讓路棧
strcpy(b.Help[b.top++].plate,s.Stop[s.top+1].plate);printf("牌照為%s的汽車暫時退出停車位
",s.Stop[s.top+1].plate);
}
b.top--;//如果停車位中的車都讓了道，說明停車位中無車輛需要出行
if(s.top<-1)
{printf("停車位上無此車消息
");
}else
{printf("牌照為%s的汽車從停車場開走
",s.Stop[s.top+1].plate);
}//將讓路棧中的車輛信息壓入停車位棧
while(b.top>=0)
{strcpy(s.Stop[++s.top].plate,b.Help[b.top--].plate);printf("牌照為%s的汽車停回停車位%d車位
",b.Help[b.top+1].plate,s.top+1);
}//從便道中->停車位
while(s.top<MAX_STOP-1)
{if(0==p.count)//判斷隊列是否為空
{break;
}//不為空，將便道中優先順序高的車停入停車位
else
{strcpy(s.Stop[++s.top].plate,p.Pave[p.front].plate);printf("牌照為%s的汽車從便道中進入停車位的%d車位
",p.Pave[p.front].plate,s.top+1);
p.front=(p.front+1)%MAX_PAVE;
p.count--;
}
}
}voidcar_leave()//車離開{printf("請輸入即將離開的車牌號:
");scanf("%s",&C);if(s.top<0)//判斷停車位是否有車輛信息
{printf("車位已空，無車輛信息！
");
}else
{
stop_to_buff();
}
time_tt1;
longintt=time(&t1);
c.time2=t;//標記離開停車場的時間
char*t2;
t2=ctime(&t1);//獲取當前時間
printf("離開時間%s
需付%ld元
",t2,MONEY*(c.time2-c.time1)/10);
}voidDisplay()
{inti=s.top;if(-1==i)
{printf("停車場為空
");
}
time_tt1;longintt=time(&t1);//標記顯示時的時間
printf(" 車牌號 停放時間 當前所需支付金額
");while(i!=-1)
{
printf(" %s %d秒 %d元
",s.Stop[i].plate,t-c.time1,MONEY*(t-c.time1)/10);
i--;
}
}voidwelcome()
{printf(" *******************目前停車場狀況***********************
");printf(" 停車場共有%d個車位,當前停車場共有%d輛車,等候區共有%d輛車
",MAX_STOP,s.top+1,(p.rear+MAX_PAVE-p.front)
%MAX_PAVE);printf(" ********************************************************
");printf(" ---------------WelcometoourCarParking---------------
");
printf(" *1.Parking*
");
printf(" *2.leaving*
");
printf(" *3.situation*
");
printf(" *4.exit*
");
printf(" --------------------------------------------------------
");
}
主函數main.c
/**********************************************************
問題描述：停車場是一個能放n輛車的狹長通道，只有一個大門，
汽車按到達的先後次序停放。若車場滿了，車要在門外的便道上等候
，一旦有車走，則便道上第一輛車進入。當停車場中的車離開時，由
於通道窄，在它後面的車要先退出，待它走後依次進入。汽車離開
時按停放時間收費。
基本功能要求：
1）建立三個數據結構分別是：停放隊列，讓路棧，等候隊列
2）輸入數據模擬管理過程，數據（入或出，車號）。
***********************************************************/#include"PLot.h"intmain()
{//初始化
s.top=-1;
b.top=0;
p.rear=0;
p.count=0;
p.front=0;while(1)
{
system("clear");
welcome();inti,cho;
scanf("%d",&i);if(1==i)car_come();
if(2==i)car_leave();if(3==i)Display();if(4==i)break;
printf("返回請輸入1
");
scanf("%d",&cho);if(1==cho)
{continue;
}else
{
printf("您的輸入有誤，請重新輸入
");
scanf("%d",&cho);continue;
}
}return0;
}
『貳』 C語言棧及隊列問題
1、按鏈表的相反順序列印出鏈表中各節點的值
typedef struct _l
{
int data;
struct _l *next;
} link;
void func(link *p)
{
if(p!=NULL)
{
func(p->next);
printf("%d",p->data);
}
}
2、一個隊列管理的模擬系統
typedef struct _l
{
int data;
struct _l *next;
} link;
link *tail=NULL;
//1.隊列初始化
int init()
{
tail=(link *)malloc(sizeof(link));
if(tail!=NULL)
{
tail->next=tail;
return 1;
}
return 0;
}
//2.當鍵盤輸入一個正整數時，把它作為一個隊列元素入隊列
int insert(int n)
{
link *p;
p=(link *)malloc(sizeof(link));
if(p==NULL)
{
return 0;
}
p->data=n;
p->next=tail->next;
tail->next=p;
return 0;
}
//3.當鍵盤輸入一個負整數時，則隊頭元素出列
int delete()
{
link *p=tail,*q=p;
while(p->next!=tail)
{
q=p;p=p->next;
}
if(p==q)
{
return 0;//隊列空
}
else
{
q->next=p->next;
free(p);
return 1;
}
}
//4.當鍵盤輸入0時，退出系統
//5.每輸入一個整數，輸出經過隊列操作後隊列中的所有元素
void trans()
{
link *p=tail->next;
while(p!=tail)
{
printf("%d",p->data);
p=p->next;
}
}
int main()
{
int n;
init();
while(true)
{
scanf("%d",&n);
if(n==0)
{
break;
}
else if(n>0)
{
insert(n);
}
else
{
delete();
}
trans();
}
}
『叄』 c語言實現隊列和棧的方法
#define OVERFLOW -1
#define OK 1
#define ERROR 0
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define N 20
typedef char SElemType;
typedef int Status;typedef struct {
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;#include<stdio.h>
#include<stdlib.h>Status CreatStack(SqStack &S){
//創建棧
S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base)exit(OVERFLOW);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}//CreatStackStatus Push(SqStack &S,SElemType e){
//插入e為新的棧頂元素
if(S.top-S.base>=S.stacksize){//棧滿，追加存儲空間
S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!S.base)exit (OVERFLOW);//存儲空間分配失敗
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}//PushStatus Pop(SqStack &S ,SElemType &e){
//若棧不空，刪除棧頂元素，並用e返回其值
if(S.top==S.base) return ERROR;
e=*--S.top;
return OK;
}//Pop typedef char QElemType;
typedef struct QNode{
QElemType data;
struct QNode *next;
}QNode,*QNodePtr;typedef struct{
QNodePtr front;
QNodePtr rear;
}LinkQueue;Status CreatQueue(LinkQueue &Q){
//建立一個空的鏈式棧
Q.front=Q.rear=(QNodePtr)malloc(sizeof(QNode));
if(!Q.front)exit(OVERFLOW);
Q.front->next=NULL;
return OK;
}Status EnQueue(LinkQueue &Q,QElemType e){ QNodePtr p;
p=(QNodePtr)malloc(sizeof(QNode));
if(!p)exit(OVERFLOW);
p->data=e;p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return OK;
}Status DeQueue(LinkQueue &Q,QElemType &e){QNodePtr p;<br>if(Q.front==Q.rear) return ERROR;<br>p=Q.front->next; e=p->data;<br>Q.front->next=p->next;<br>if(Q.rear==p) Q.rear=Q.front;<br>free(p);<br>return OK;<br>}int stackPalindrom_Test()//判別輸入的字元串是否迴文序列,是則返回1,否則返回0
{
printf("棧練習，請輸入要判斷的字元串以#作為結束符，不要超過二十個字元\n");
SqStack S;
CreatStack(S);
char c;
SElemType a;
SElemType b[N];
int count = 0;
fgets( b, N, stdin );
while((b[count])!='#')
{
Push(S,b[count]); //進棧
count++;
}
int i = 0;
while(i < count)
{
Pop(S,a);
if(a!=b[i])
return ERROR;
i++;
}
return OK;}//stackPalindrom_Test int queuePalindrom_Test()//判別輸入的字元串是否迴文序列,是則返回1,否則返回0
{
printf("隊列練習，請輸入要判斷的字元串以#作為結束符，不要超過二十個字元\n");
LinkQueue Q;
CreatQueue(Q); char c;
SElemType a;
SElemType b[N];
int count = 0;
fgets( b, N, stdin );
while((b[count])!='#')
{
EnQueue(Q,b[count]);; //入列
count++;
} while(count-- > 0)
{
DeQueue(Q,a);
if(a!=b[count])
return ERROR;
}
return OK;
}//queuePalindrom_Test Status main(){ if(stackPalindrom_Test()==1)
printf("是迴文\n");
else printf("不是迴文\n"); if(queuePalindrom_Test()==1)
printf("是迴文\n");
else printf("不是迴文\n");
return OK;
}
『肆』 關於c語言數據結構棧與隊列的問題、、求幫助
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define PRIMAX 100000 //非優先順序模式下
typedef struct qnode
{
char data[10];
struct qnode *next;
int priority;//優先順序，0的優先順序最高，1次之，逐步優先順序遞減
} QNODE; /*鏈隊結點類型*/
QNODE *front,*rear;
void InitQueue()
{
front=(QNODE *)malloc(sizeof(QNODE));
rear=front;
front->next=NULL;
front->priority = 0;//lzl add
}
void AddQueue(char x[], int prioty)
{
if (prioty<0)
{
printf(" Priority is not right! ");
return ;
}
QNODE *p=NULL;
p=(QNODE *)malloc(sizeof(QNODE));
if(p==NULL)
{
printf("內存不足");
exit(1);
}
strcpy(p->data, x);
p->next=NULL;
p->priority = prioty;
//lzl Modify begin
if (front == rear || prioty==PRIMAX)//空隊列或非優先順序模式
{
rear->next = p;
rear = p;
return ;
}
if (front!=rear && rear->priority <= prioty)
{
rear->next = p;
rear = p;
}
else
{
if (p->priority<front->next->priority)
{
p->next = front->next;
front->next = p;
}
else
{
QNODE *temp = front;
while (temp != NULL && (temp->priority)>=(p->priority))
{
//實際上temp值是不會等於NULL
//因為前面已對尾部節點的優先順序做判斷
temp = temp->next;
}
p->next = temp->next;
temp->next = p;
}
}
//lzl Modify end
}
void HeadAddQueue(char x[])
{ //在隊頭插入
}
int DelQueue(char x[])
{
QNODE *p;
if (front==rear)
return 0; //隊空
p=front->next;
strcpy(x, p->data);
front->next=p->next;
if (p->next==NULL) //最後一個元素出隊
rear=front;
free(p);
return 1;
}
int QueueEmpty()
{
if(front==rear)
return 1; //隊空
else
return 0;
}
void DispQueue(int iAll)
{
QNODE *p=front->next;
int i=1;
printf(" ");
if (iAll==1)//輸出隊列中全部名稱
{
while (p!=NULL)
{
printf("第%d位 名字%s ",i,p->data);
p=p->next;
i++;
}
printf(" ");
}
else//單個客戶查找
{
char cName[10]={0};
printf(" 用戶名:");
scanf("%s",cName);
while (p!=NULL && strcmp(p->data,cName)!=0 )
{
p = p->next;
i++;
}
if (p == NULL)
{
printf(" 沒有找到該客戶");
}
else
{
printf(" 客戶信息:第%d位 名字%s",i,p->data);
}
}
}
void main()
{
char sel;
char name[10];
int priority=0;
char ch;
InitQueue(); //初始化隊
while (1)
{
printf(" 1:進入排隊");
printf(" 2:辦理業務");
printf(" 3:查看個體");
printf(" 4:查看全部");
printf(" 0:下班");
printf(" 請選擇:");
//_flushall();
fflush(stdin);
scanf("%c",&sel);
switch(sel)
{
case Ɔ':
if (!QueueEmpty()) //隊不空
printf("請排隊的客戶明天再來 ");
return;
case Ƈ':
printf("輸入客戶姓名: ");
scanf("%s",name);
_flushall();
printf("是否優先？（y/n）：");
scanf("%c",&ch);
if (ch=='Y'||ch=='y')
{
//讀入優先順序
printf("優先順序:");
scanf("%d",&priority);
AddQueue(name,priority); //入隊
}
else
{
AddQueue(name,PRIMAX);
}
break;
case ƈ':
if (!DelQueue(name)) //出隊
printf("沒有排隊的客戶 ");
else
printf("請客戶%s辦理 ",name);
break;
case Ɖ':
case Ɗ':
if (QueueEmpty()) //隊空
printf("沒有排隊的客戶 ");
else
{
printf("排隊者:");
//sel-Ɖ'值為0表示單個客戶查詢,值為1表示查詢全部
DispQueue(sel-Ɖ');
}
break;
default:
printf("選擇錯誤，請重新選擇。 ");
break;
}
}
}
『伍』 棧與隊列的應用（C語言）求解
#include "stdio.h"
#include "malloc.h"
typedef struct node1{
int *data;
int top;
void init(void);
void del(void);
int pop(int&);
void push(int&);
}s;
void node1::init(){
data=(int*)malloc(sizeof(int)*100);
top=0;
}
void node1::del(){
free(data);
top=0;
}
int node1::pop(int &e){
if(top==0)return 0;
e=data[--top];
return 1;
}
void node1::push(int &e){
if(top==100)return;
data[top++]=e;
}
typedef struct node2{
int *data;
int top;
int bottom;
void init(void);
void del(void);
int pop(int&);
void push(int&);
void format(s&);
}q;
void node2::init(){
data=(int*)malloc(sizeof(int)*100);
top=bottom=0;
}
void node2::del(){
free(data);
top=bottom=0;
}
int node2::pop(int &e){
if(top==bottom)return 0;
e=data[top++];
return 1;
}
void node2::push(int &e){
if(bottom==100)return;
data[bottom++]=e;
}
void node2::format(s &e){
int a;
while(e.pop(a)){
push(a);
}
}
int main(){
s b;q c;
int a;
b.init();c.init();
printf("輸入棧中的數,以0結尾\n");
while(1){
scanf("%d",&a);
if(a==0)break;
b.push(a);
}
c.format(b);
while(c.pop(a)){
printf("%d\n",a);
}
b.del();
c.del();
return 0;
}//b為棧,c為隊列,c.format(b)為轉換函數
『陸』 C語言中的棧、堆是什麼
C語言中的堆和棧都是一種數據項按序排列的數據結構。
棧就像裝數據的桶或箱子
我們先從大家比較熟悉的棧說起吧，它是一種具有後進先出性質的數據結構，也就是說後存放的先取，先存放的後取。
這就如同我們要取出放在箱子裡面底下的東西（放入的比較早的物體），我們首先要移開壓在它上面的物體（放入的比較晚的物體）。
堆像一棵倒過來的樹
而堆就不同了，堆是一種經過排序的樹形數據結構，每個結點都有一個值。
通常我們所說的堆的數據結構，是指二叉堆。堆的特點是根結點的值最小（或最大），且根結點的兩個子樹也是一個堆。
由於堆的這個特性，常用來實現優先隊列，堆的存取是隨意，這就如同我們在圖書館的書架上取書。
雖然書的擺放是有順序的，但是我們想取任意一本時不必像棧一樣，先取出前面所有的書，書架這種機制不同於箱子，我們可以直接取出我們想要的書。
(6)c語言棧隊列擴展閱讀：
關於堆和棧區別的比喻
使用棧就象我們去飯館里吃飯，只管點菜（發出申請）、付錢、和吃（使用），吃飽了就走，不必理會切菜、洗菜等准備工作和洗碗、刷鍋等掃尾工作，他的好處是快捷，但是自由度小。
使用堆就象是自己動手做喜歡吃的菜餚，比較麻煩，但是比較符合自己的口味，而且自由度大。
參考資料來源：網路-堆棧
『柒』 ，c語言，棧隊列問題，為什麼要兩個棧，分別是干什麼用的
想像空中有兩個水杯，水杯的口對著另一個水杯的口。【】 用左邊的這個中括弧組成的圖形形容下吧，左括弧是個水杯，即棧，右括弧也是個水杯，也是棧。如果你想要提取隊列中間的元素，是不是可以把隊列中間這個元素到隊首之間的所有元素壓入左棧中，而把隊列中間這個元素到隊尾之間的所有元素壓入右棧中，提取了這個元素後，再把右棧中元素壓到左棧恢復成和原先順序不變的隊列呢，想想是不是很方便。~\(≧▽≦)/~
其實這個也linux shell中，通過上下按鍵便能調出最近的命令使用記錄一樣的原理
『捌』 c語言堆棧和隊列
棧（stack）又名堆棧，它是一種運算受限的線性表。其限制是僅允許在表的一端進行插入和刪除運算。這一端被稱為棧頂，相對地，把另一端稱為棧底。向一個棧插入新元素又稱作進棧、入棧或壓棧，它是把新元素放到棧頂元素的上面，使之成為新的棧頂元素；從一個棧刪除元素又稱作出棧或退棧，它是把棧頂元素刪除掉，使其相鄰的元素成為新的棧頂元素。
隊列是一種特殊的線性表，特殊之處在於它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作，和棧一樣，隊列是一種操作受限制的線性表。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。
以上是從數據結構角度來看，從操作系統角度來看，所有的數據結構都是對虛擬內存的操作，堆是堆，棧是棧，棧指的是C語言函數所使用的自動有函數回收的虛擬內存空間，而堆則有操作系統堆管理器來管理的那部分虛擬內存，從C語言角度來看，使用malloc函數動態分配的內存，就是堆內存。
『玖』 C語言寫 棧隊列(先進先出的)
#include<stdio.h>
#include<malloc.h>typedef
struct
node
/*定義新類型結構體結點*/
{
int
data;/*數據成員可以是多個不同類型的數據*/
struct
node
*next;/*指針變數成員只能是一個*/
}NODE;/*節點結束*/typedef
struct
qnode
/*定義結點類型的變數名*/
{
NODE
*front;/*設定結點頭指針變數*/
NODE
*rear;/*
設定結點尾指針變數*/
}QNODE;
/*
鏈隊列的結點定義
*/
void
InitQueue(QNODE
*Q)/*定義指針Q*/
{
NODE
*p;/*定義指針p*/
p=(NODE
*)malloc(sizeof(NODE));/*分配結點位元組的容量*/
Q->front=p;
/*指定頭指針p*/
Q->front->next=NULL;/*建立空隊列*/
Q->rear=Q->front;/*改變Q的值*/
printf("The
init
is
complete!");}
void
*QueuePush(QNODE
*Q)
{
NODE
*p;
p=(NODE
*)malloc(sizeof(NODE));/*分配結點位元組的容量*/
printf("Please
input
a
number
:");/*請輸入一個數*/
scanf("%d",&p->data);/*給第一個結點賦值*/
p->next=NULL;/*指定尾結點*/
Q->rear->next=p;/*指定尾新結點p的地址*/
Q->rear=p;/*指定隊尾結束*/
printf("The
%d
has
been
pushed
into
the
Queue!",p->data);/*顯示數據成員*/
return
0;/*程序結束*/
}
void
*QueuePop(QNODE
*Q)
{
NODE
*p;/*定義結點指針*/
if(Q->front->next==NULL)
return
0;/*判斷對前是否為空，如果是就結束*/
p=Q->front->next;/*指向下以個成員*/
Q->front->next=p->next;/*依次向下循環*/
if(Q->rear==p)
Q->rear=Q->front;/*隊尾與對頭相同*/
printf("The
%d
has
been
pop
from
the
queue!
\n",p->data);/*顯示隊列成員*/
free(p);
return
0;
}
void
*PrintQueue(QNODE
*Q)
{
NODE
*p;/*定義鏈結點*/
p=Q->front->next;/*指定對頭*/
while(p!=NULL)/*如不為空*/
{
printf("%5d",p->data);/*顯示數據成員*/
p=p->next;/*指定第二個成員*/
}
return
0;
}
void
main()
{
QNODE
*T;
int
i=0;/*取值*/
printf("1.InitQueue
2.QueuePush
3.QueuePop
4.PrintQueue
5.Quit
\n");
while(i!=5)
{
printf("Please
choose
the
gongneng:");
scanf("%d",&i);
printf("\n");
switch(i)
{
case
1:
InitQueue(T);
printf("\n");
break;
case
2:
QueuePush(T);
printf("\n");
break;
case
3:
QueuePop(T);
printf("\n");
break;
case
4:
printf("The
queue's
numbers
are:");
PrintQueue(T);
printf("\n");
break;
case
5:
printf("\n");
break;}
}
}
『拾』 計算機c語言中 什麼是棧和隊列
棧(Stack)是僅限制在表的一端進行插入和刪除運算的線性表，稱插入、刪除這一端為棧頂，另一端稱為棧底。表中無元素時為空棧。棧 的修改是按後進先出的原則進行的，我們又稱棧為LIFO表(Last In First Out)。通常棧有順序棧和鏈棧兩種存儲結構。 棧的基本運算有六種： ·構造空棧：InitStack(S) ·判棧空: StackEmpty(S) ·判棧滿： StackFull(S) ·進棧： Push(S,x) ·退棧： Pop(S) ·取棧頂元素：StackTop(S) 在順序棧中有"上溢"和"下溢"的現象。 ·"上溢"是棧頂指針指出棧的外面是出錯狀態。 ·"下溢"可以表示棧為空棧,因此用來作為控制轉移的條件。 順序棧中的基本操作有六種：·構造空棧·判棧空·判棧滿·進棧·退棧·取棧頂元素 鏈棧則沒有上溢的限制，因此進棧不要判棧滿。鏈棧不需要在頭部附加頭結點，只要有鏈表的頭指針就可以了。 鏈棧中的基本操作有五種：·構造空棧·判棧空·進棧·退棧·取棧頂元素 隊列(Queue)是一種運算受限的線性表，插入在表的一端進行，而刪除在表的另一端進行，允許刪除的一端稱為隊頭(front)，允許插入的 一端稱為隊尾(rear) ,隊列的操作原則是先進先出的，又稱作FIFO表(First In First Out) 。隊列也有順序存儲和鏈式存儲兩種存儲結 構。 隊列的基本運算有六種： ·置空隊：InitQueue(Q) ·判隊空：QueueEmpty(Q) ·判隊滿：QueueFull(Q) ·入隊：EnQueue(Q,x) ·出隊：DeQueue(Q) ·取隊頭元素：QueueFront(Q) 順序隊列的"假上溢"現象：由於頭尾指針不斷前移，超出向量空間。這時整個向量空間及隊列是空的卻產生了"上溢"現象。 為了克服"假上溢"現象引入循環向量的概念，是把向量空間形成一個頭尾相接的環形，這時隊列稱循環隊列。 判定循環隊列是空還是滿，方法有三種： ·一種是另設一個布爾變數來判斷； ·第二種是少用一個元素空間，入隊時先測試（(rear+1)%m = front）? 滿：空； ·第三種就是用一個計數器記錄隊列中的元素的總數。 隊列的鏈式存儲結構稱為鏈隊列，一個鏈隊列就是一個操作受限的單鏈表。為了便於在表尾進行插入(入隊)的操作，在表尾增加一個尾指 針，一個鏈隊列就由一個頭指針和一個尾指針唯一地確定。鏈隊列不存在隊滿和上溢的問題。在鏈隊列的出隊演算法中，要注意當原隊中只 有一個結點時，出隊後要同進修改頭尾指針並使隊列變空。