① 計算機c語言中 什麼是棧和隊列
地址就是~~~~
比如你申請一個變數int
a=1;
那麼它就自動在內存中申請了一個4位元組的地址給你使用~
你可以使用&a來查看地址~其實都是跟上面的一樣~不管怎麼樣申請了之後就需要釋放，但是c語言如果不是動態申請的~系統都會幫你自動優化哦~程序結束就會釋放~
② C語言中的棧和隊列有什麼共同點
棧（stack）又名堆棧，它是一種運算受限的線性表。其限制是僅允許在表的一端進行插入和刪除運算。這一端被稱為棧頂，相對地，把另一端稱為棧底。向一個棧插入新元素又稱作進棧、入棧或壓棧，它是把新元素放到棧頂元素的上面，使之成為新的棧頂元素；從一個棧刪除元素又稱作出棧或退棧，它是把棧頂元素刪除掉，使其相鄰的元素成為新的棧頂元素。
隊列是一種特殊的線性表，特殊之處在於它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作，和棧一樣，隊列是一種操作受限制的線性表。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。
都是端點操作，隊列是FIFO(first in first out)，棧是LIFO(last in first out)，指針的話隊列有兩個，棧只有一個top指針
以上是從數據結構角度來看，從操作系統角度來看，所有的數據結構都是對虛擬內存的操作，堆是堆，棧是棧，棧指的是C語言函數所使用的自動有函數回收的虛擬內存空間，而堆則有操作系統堆管理器來管理的那部分虛擬內存，從C語言角度來看，使用malloc函數動態分配的內存，就是堆內存。
③ C語言鏈表與隊列的問題
首先：鏈表與隊列都是數據結構的一種
一.
鏈表
1.定義
鏈表(Linked
list)是一種常見的基礎數據結構，是一種線性表，但是並不會按線性的順序存儲數據，而是在由一個個節點組成，每個節點（node）中儲存著數據變數（data）和指針變數（node
next），又有一個頭節點（head）連接下面的節點，而最後一個節點指向空（null）。可以在鏈表類中定義增加，刪除，插入，遍歷，修改等方法，故常用來儲存數據。
2.
優點
（1）.使用鏈表結構可以克服數組鏈表需要預先知道數據大小的缺點，鏈表結構可以充分利用計算機內存空間，實現靈活的內存動態管理。
（2）.數據的存取往往要在不同的排列順序中轉換，而鏈表是一種自我指示數據類型，因為它包含指向另一個相同類型的數據的指針（鏈接）。鏈表允許插入和移除表上任意位置上的節點，但是不允許隨機存取。
3.
缺點
鏈表失去了數組隨機讀取的優點，同時鏈表由於增加了結點的指針域，空間開銷比較大。
4.
類型
主要有單向鏈表，雙向鏈表以及循環鏈表。
5.
實例
6.
與數組（Array）的對比
鏈表的使用不需要知道數據的大小，而數組在創建時必須指明數組的大小。
鏈表沒有對應的下標，只有指向下一個數據的指針，而數組中每一個都有一個相對應的下標。
鏈表在內存中儲存的數據可以是不連續的，而數組儲存的數據占內存中連續的一段，用標識符標識。
二.
隊列
1.
定義
隊列是一種特殊的線性表，它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。隊列中沒有元素時，稱為空隊列。
在隊列這種數據結構中，最先插入的元素將是最先被刪除的元素；反之最後插入的元素將最後被刪除的元素，因此隊列又稱為「先進先出」（FIFO—first
in
first
out）的線性表。
④ C語言中，隊列是什麼意思，有什麼用途
隊列是一種特殊的線性表。
隊列一種可以實現「先進先出」的存儲結構，即「一端入，一端出」，隊首(front)出隊，隊尾(rear)入隊，若front指向隊首，則rear指向隊尾最後一個有效元素的下一個元素；若rear指向隊尾，則front指向隊首第一個有效元素的下一個元素。
隊列特殊之處在於它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作，和棧一樣，隊列是一種操作受限制的線性表。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。
(4)fifo隊列c語言擴展閱讀
循環隊列各個參數的含義
1、隊列初始化front和rear的值都是零,初始化時隊列就是空的。
2、隊列非空front代表隊列的第一個元素rear代表了最後一個有效元素的下一個元素。
3、隊列空front和rear的值相等，但是不一定是零。
⑤ C語言模擬FIFO演算法，隨機生成320條指令，有四塊物理塊，為什麼錯了
這可是hen寶貴的啊
#include
#include
#include
#include
#define Bsize 4
typedef struct BLOCK//聲明一種新類型——物理塊類型
{
int pagenum;//頁號
int accessed;//訪問欄位，其值表示多久未被訪問
}BLOCK;
int pc;//程序計數器，用來記錄指令的序號
int n;//缺頁計數器，用來記錄缺頁的次數
static int temp[320];//用來存儲320條隨機數
BLOCK block[Bsize]; //定義一大小為4的物理塊數組
//*************************************************************
void init( ); //程序初始化函數
int findExist(int curpage);//查找物理塊中是否有該頁面
int findSpace( );//查找是否有空閑物理塊
int findReplace( );//查找應予置換的頁面
void display ( );//顯示
void suijishu( );//產生320條隨機數,顯示並存儲到temp[320]
void pagestring( );//顯示調用的頁面隊列
void OPT( );//OPT演算法
void LRU( );// LRU演算法
void FIFO( );//FIFO演算法
//*************************************************************
void init( )
{
for(int i=0;i<Bsize;i++)
{
block[i].pagenum=-1;
block[i].accessed=0;
pc=n=0;
}
}
//-------------------------------------------------------------
int findExist(int curpage)
{
for(int i=0; i<Bsize; i++)
{
if(block[i].pagenum == curpage )
return i;//檢測到內存中有該頁面，返回block中的位置
}
return -1;
}
//-------------------------------------------------------------
int findSpace( )
{
for(int i=0; i<Bsize; i++)
{
if(block[i].pagenum == -1)
return i;//找到空閑的block，返回block中的位置
}
return -1;
}
//-------------------------------------------------------------
int findReplace( )
{
int pos = 0;
for(int i=0; i<Bsize; i++)
{
if(block[i].accessed >block[pos].accessed)
pos = i;//找到應予置換頁面，返回BLOCK中位置
}
return pos;
}
//-------------------------------------------------------------
void display( )
{
for(int i=0; i<Bsize; i++)
{
if(block[i].pagenum != -1)
{ printf(" %02d",block[i].pagenum);}
}
cout<<endl;
}
//-------------------------------------------------------------
void suijishu( )
{ int flag=0;
cin>>pc;
cout<<"******按照要求產生的320個隨機數：*******"<<endl;
for(int i=0;i<320;i++)
{
temp[i]=pc;
if(flag%2==0) pc=++pc%320;
if(flag==1) pc=rand( )% (pc-1);
if(flag==3) pc=pc+1+(rand( )%(320-(pc+1)));
flag=++flag%4;
printf(" %03d",temp[i]);
if((i+1)%10==0) cout<<endl;
}
}
//-------------------------------------------------------------
void pagestring( )
{
for(int i=0;i<320;i++)
{
printf(" %02d",temp[i]/10);
if((i+1)%10==0) cout<<endl;
}
}
//-------------------------------------------------------------
void OPT( )
{
int exist,space,position ;
int curpage;
for(int i=0;i<320;i++)
{
if(i%100==0) getch( );
pc=temp[i];
curpage=pc/10;
exist = findExist(curpage);
if(exist==-1)
{
space = findSpace ( );
if(space != -1)
{
block[space].pagenum = curpage;
display( );
n=n+1;
}
else
{
for(int k=0;k<Bsize;k++)
{
for(int j=i;j<320;j++)
{
if(block[k].pagenum!= temp[j]/10)
{
block[k].accessed = 1000;
}//將來不會用，設置為一個很大數
else
{
block[k].accessed = j;
break;
}
}
}
position = findReplace( );
block[position].pagenum = curpage;
display( );
n++;
}
}
}
cout<<"缺頁次數:"<<n<<endl;
cout<<"缺頁率:"<<(n/320.0)*100<<"%"<<endl;
}
//-------------------------------------------------------------
void LRU( )
{
int exist,space,position ;
int curpage;
for(int i=0;i<320;i++)
{
if(i%100==0) getch( );
pc=temp[i];
curpage=pc/10;
exist = findExist(curpage);
if(exist==-1)
{
space = findSpace( );
if(space != -1)
{
block[space].pagenum = curpage;
display( );
n=n+1;
}
else
{
position = findReplace( );
block[position].pagenum = curpage;
display( );
n++;
}
}
else block[exist].accessed = -1;//恢復存在的並剛訪問過的BLOCK中頁面accessed為-1
for(int j=0; j<4; j++)
{block[j].accessed++;}
}
cout<<"缺頁次數:"<<n<<endl;
cout<<"缺頁率:"<<(n/320.0)*100<<"%"<<endl;
}
//-------------------------------------------------------------
void FIFO( )
{
int exist,space,position ;
int curpage;
for(int i=0;i<320;i++)
{
if(i%100==0) getch( );
pc=temp[i];
curpage=pc/10;
exist = findExist(curpage);
if(exist==-1)
{
space = findSpace( );
if(space != -1)
{
block[space].pagenum = curpage;
display( );
n=n+1;
}
else
{
position = findReplace( );
block[position].pagenum = curpage;
display( );
n++;
block[position].accessed--;
}
}
for(int j=0; j<Bsize; j++)
block[j].accessed++;
}
cout<<"缺頁次數:"<<n<<endl;
cout<<"缺頁率:"<<(n/320.0)*100<<"%"<<endl;
}
//*************************************************************
void main( )
{
int select;
cout<<"請輸入第一條指令號(0~320)：";
suijishu( );
cout<<"*****對應的調用頁面隊列*******"<<endl;
pagestring( );
do
{
cout<<"****************************************"<<endl;
cout<<"------1:OPT 2:LRU 3:FIFO 4:退出-----"<<endl;
cout<<"****************************************"<<endl;
cout<<" 請選擇一種頁面置換演算法:";
cin>>select;
cout<<"****************************************"<<endl;
init( );
switch(select)
{
case 1:cout<<"最佳置換演算法OPT:"<<endl;
cout<<"*****************"<<endl;
OPT( );
break;
case 2:cout<<"最近最久未使用置換演算法LRU:"<<endl;
cout<<"**************************"<<endl;
LRU( );
break;
case 3:cout<<"先進先出置換演算法FIFO:"<<endl;
cout<<"*********************"<<endl;
FIFO( );
break;
default: ;
}
}while(select!=4);
}
你試試可以不，應該沒問題的
要注意這是用C++編寫的，你改一下就可以用了
⑥ 怎樣用C語言編寫簡單的FIFO置換演算法
#include "stdio.h"
#include "malloc.h"
#define OK 1
#define ERROR 0
#define NULL 0
#define status int
typedef int Elemtype;
/*這個定義的是隊列的元素的數據結構*/
typedef struct tailDATA{
Elemtype data;/*這個存放的是隊列元素的值*/
struct tailDATA *next;//指向下一個元素
}datatail,*map;
/*以下定義的是隊列頭的數據結構*/
typedef struct Tail{
/*說明:對隊列進行操作的時候,插入的時候是對front操作,刪除*/
Elemtype data;/*這個記載的是隊列的元素的個數*/
map front;/*這個是隊列的頭*/
map rear;/*這個是隊列的尾*/
}tail,*mappath;
/*以下定義的就是操作了,初始話的操作就不想做了,直接寫個插入和刪除等的一些的演算法就可以了*/
status inserttail(mappath &T,map P)
{/*這個函數的功能是將一個個已知的元素插入隊列中*/
if(T==NULL)
{
T=(mappath)malloc(sizeof(tail));
T->data=0;
T->front=NULL;
T->rear=NULL;
}
if(!P) return OK;
T->rear->next=P;
T->rear=P;
if(!(T->front)) T->front=P;
return OK;
}
status insertdatatail(mappath &T,int a)
{/*這個函數將一個元素插入隊列中,其實這個函數是沒有必要的,但是為了方便起見,還是寫了個*/
if(T==NULL)
{
T=(mappath)malloc(sizeof(tail));
T->data=0;
T->front=NULL;
T->rear=NULL;
map linshi=(map)malloc(sizeof(datatail));
linshi->data=a;
linshi->next=NULL;
T->front=linshi;
T->rear=linshi;
T->data=1;
return OK;
}
map linshi=(map)malloc(sizeof(datatail));
linshi->data=a;
linshi->next=NULL;
T->rear->next=linshi;
T->rear=linshi;
if(!(T->front)) T->front=linshi;
T->data++;
return OK;
}
status deltail(mappath &T)
{/*因為對隊列進行刪除操作的時候,基本上是沒有什麼條件,就是對front做一些相應的操作就可以了
,所以他的函數列表也就比較少了*/
if(!T) return ERROR;/*如果隊列本來就是空的,那麼就返回一個錯誤的信息*/
if(T->front==T->rear)
{/*如果隊列只有一個元素,就執行下面的操作,防止出現了錯誤*/
map linshi=T->front;
free(linshi);
T->data=0;
T->front=NULL;
T->rear=NULL;
return OK;
}
map linshi=T->front;
T->front=T->front->next;
T->data--;
free(linshi);
return OK;
}
status puttail(mappath T)
{/*這個是對一個已經存在的隊列進行輸出*/
if(!T) return ERROR;
printf("the tail'count is %d\n",T->data);
int count=T->data;map q=T->front;
for(int i=0;i<count;i++)
{
printf("%d ",q->data);
q=q->next;
}
return OK;
}
int main()
{
printf("hello,world!\n");
mappath q=NULL;int count1=0;int dataa=0;
printf("please input a number to the count of tail\n");
scanf("%d",&count1);
for(int i=0;i<count1;i++)
{
printf("please input a number to tail\n");
scanf("%d",&dataa);
insertdatatail(q,dataa);
}
puttail(q);
deltail(q);
puttail(q);
return 0;
}
⑦ C語言二級考試循環鏈表是循環隊列的鏈式存儲結構
循環隊列本身是一種順序存儲結構，而循環列表是一種鏈式存儲結構。兩者之間是平級關系。
線性鏈表是線性表的鏈式存儲結構，包括單鏈表，雙鏈表，循環鏈表等。
隊列的順序存儲結構一般採用循環隊列的形式。
循環隊列的操作是按數組取摸運算的，所以是順序存儲，而循環鏈表本身就是收尾相連的，所以循環鏈表不是循環隊列，兩種不同的存儲結構，雖然實現的功能是一樣的，實現循環兩種方式 順序存儲就是循環隊列，鏈式存儲就是循環鏈表。
(7)fifo隊列c語言擴展閱讀：
1、比順序存儲結構的存儲密度小(鏈式存儲結構中每個結點都由數據域與指針域兩部分組成，相比順序存儲結構增加了存儲空間)。
2、邏輯上相鄰的節點物理上不必相鄰。
3、插入、刪除靈活 (不必移動節點，只要改變節點中的指針)。
4、查找節點時鏈式存儲要比順序存儲慢。
5、每個節點是由數據域和指針域組成。
6、由於簇是隨機分配的，這也使數據刪除後覆蓋幾率降低，恢復可能提高。
⑧ C語言中使用隊列
如果你用vc，#include<deque>就好了，但是注意要加上using naemspace std；
我是當你用的c++的STL，STL中沒有真正的隊列和棧，他們都是通過對雙端隊列的改造得到的，所以包含的文件可能和你想的不一樣。而且這些頭文件都沒有.h結尾！很特別
如果你不是vc，當我沒說