❶ 求一個隊列的簡單例子(c語言的)
二叉樹的層次遍歷！用隊來實現的！
#include <stdio.h>
#include <stdlib.h>
/************************************************************************/
/* 常量定義 */
/************************************************************************/
#define Status int
#define TElemType char
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR -1
#define OVERFLOW -1
#define MAX_LEN 30
typedef struct BTNode
{
TElemType data;
struct BTNode *lchild;
struct BTNode *rchild;
}BiTNode, *BiTree;
/************************************************************************/
/* 操作結果: 構造空二叉樹T */
/************************************************************************/
void InitBiTree(BiTree *T)
{
// 產生樹根結點，並使T指向此樹根結點
*T = (BiTree)malloc(sizeof(BiTNode));
// 存儲分配失敗
if( ! *T ) exit(OVERFLOW);
// 二叉樹T左右指針域為空
(*T)->lchild = NULL;
(*T)->rchild = NULL;
}
/************************************************************************/
/* 操作結果：構造二叉樹 */
/************************************************************************/
Status CreateBiTree(BiTree *T)
{
char ch;
printf("輸入節點, 空樹以#代替:");
scanf("\n%c", &ch);
if(ch == '#') *T = NULL;
else
{
InitBiTree(&(*T));
(*T)->data = ch; //生成根
CreateBiTree(&(*T)->lchild);//構造左子樹
CreateBiTree(&(*T)->rchild);//構造右子樹
}
return OK;
}
/************************************************************************/
/* 操作結果：層次序遍歷T，對每一個結點調用函數visit列印結點 */
/************************************************************************/
Status LevelOrderTraverse(BiTree T, void (*visit)(TElemType e))
{
BiTree Q[MAX_LEN], p;
int front = 0, rear = 0;
if(T == NULL) return OK;
//根結點不為空入隊
rear = (rear + 1) % MAX_LEN ; //隊尾指針後移
Q[rear] = T;
//當隊不為空
while( front != rear)
{
//樹結點出隊
front = (front + 1) % MAX_LEN;
p = Q[front];
//列印結點
visit(p->data);
//左子樹不為空入隊
if(p->lchild != NULL)
{
rear = (rear + 1) % MAX_LEN;
Q[rear] = p->lchild;
}
//右子樹不為空入隊
if(p->rchild != NULL)
{
rear = (rear + 1) % MAX_LEN;
Q[rear] = p->rchild;
}
}
return OK;
}
/************************************************************************/
/* 列印結點data域 */
/************************************************************************/
void print(TElemType e)
{
printf("%c ", e);
}
/************************************************************************/
/* 主函數 */
/************************************************************************/
void main()
{
BiTree T;
//創建樹
CreateBiTree(&T);
printf("\nLevelOrder:\t");
LevelOrderTraverse(T, print);
printf("\n");
getchar();
}
❷ C語言 求隊列的簡單例子
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<iostream.h>
#define TURE 1
#define FALSE 0
#define OVERFLOW 0
#define OK 1
#define ERROR 0
#define MAXQSIZE 100
typedef int qelemtype;
typedef int status;
typedef struct{
qelemtype *base;
int front;
int rear;
}sqqueue;
status initqueue(sqqueue &q){
q.base=(qelemtype*)malloc(MAXQSIZE*sizeof(qelemtype));
if(!q.base)exit(OVERFLOW);
q.front=q.rear=0;
return OK;
}//構造一個空隊列
void visit(int &y){
y=2*y;
cout<<y<<" ";
}
status destroyqueue(sqqueue &q){
while(q.front){
q.rear=q.front;
free(q.base);
q.front=q.rear;
}
return OK;
}//銷毀隊列
status clearqueue(sqqueue &q){
q.front=q.rear=0;
return OK;
}//清空隊列
status queueempty(sqqueue q){
if(q.front==q.rear)
return TURE;
return FALSE;
}//若隊列為空,返回TURE,否則返回FALSE.
status queuelength(sqqueue q){
return(q.rear-q.front+MAXQSIZE)%MAXQSIZE;
}//返回隊列元素個數,即為隊列長度
status gethead(sqqueue q,qelemtype &e){
if(q.front==q.rear)return ERROR;
e=q.base[q.front];
cout<<e<<endl;
return OK;
}//若隊列不空,則用e返回隊列的頭元素,並返回OK
status enqueue(sqqueue &q,qelemtype e){
if((q.rear+1)%MAXQSIZE==q.front)return ERROR;
q.base[q.rear]=e;
q.rear=(q.rear+1)%MAXQSIZE;
return OK;
}//插入元素e為q的新的隊尾元素
status dequeue(sqqueue &q,qelemtype &e){
if(q.front==q.rear)return ERROR;
e=q.base[q.front];
q.front=(q.front+1)%MAXQSIZE;
return OK;
}//若隊列不空,則刪除q的隊頭元素,用e返回其值,並返回OK.
status queuetraverse(sqqueue q,void(*visit)(int &p)){
int i=1,p,a;
a=q.front;
p=q.base[a];
while(i<=(q.rear-q.front+MAXQSIZE)%MAXQSIZE)
{
visit(p);
a++;
i++;
};
return OK;}
//從隊頭到隊尾依次對隊列調用函數visit().
void main(){
sqqueue q;
int a,b,e,i,j,k;
initqueue(q);
cout<<"初始化後隊頭地址:"<<q.base<<endl;
cout<<"新建隊列!"<<endl;
cout<<"當前隊列是否為空:"<<queueempty(q)<<endl;
cout<<"定義隊列長度:"<<endl;
cin>>a;
cout<<"分別輸入隊列的各個元素,按ENTER"<<endl;
for(k=1;k<=a;k++){
cin>>j;
i=enqueue(q,j);}
cout<<"現隊列元素:"<<endl;
for(b=1;b<=a;b++)
cout<<q.base[b-1]<<endl;
cout<<"當前隊列長度:"<<queuelength(q)<<endl;
cout<<"當前隊頭元素:"<<endl;
gethead(q,e);
cout<<"刪除當前頭元素!返回其值"<<endl;
dequeue(q,i);
cout<<i<<endl;
cout<<"調用函數後隊列變為:";
queuetraverse(q,visit);
cout<<endl;
cout<<"清空隊列!"<<clearqueue(q)<<endl;
cout<<"銷毀隊列!"<<destroyqueue(q)<<endl;
}
❸ C語言中棧和隊列實現表達式求值的實例
問題是你要什麼樣的表達式啊，，表達式很多啊。。。
以及，，遞歸也是棧的一種實現形式吧。。
逆波蘭表達式
提交網頁鏈接
逆波蘭表達式是一種把運算符前置的算術表達式(又叫前綴表達式)，例如普通的表達式2 + 3的逆波蘭表示法為+ 2 3。逆波蘭表達式的優點是運算符之間不必有優先順序關系，也不必用括弧改變運算次序，例如(2 + 3) * 4的逆波蘭表示法為* + 2 3 4。本題求解逆波蘭表達式的值，其中運算符包括+ - * /四個。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
chara[3010];
doubletrans(){//floatisbugs
scanf("%s",a);
if(strlen(a)==1){
if(a[0]=='+')returntrans()+trans();
if(a[0]=='-')returntrans()-trans();
if(a[0]=='*')returntrans()*trans();
if(a[0]=='/')returntrans()/trans();
}else{
returnatof(a);
}
}
intmain(){
printf("%f ",trans());
return0;
}
❹ c語言隊列操作
pq->rear->next
=
pnew這個代碼從隊列的尾部增加新節點，
然後pq->rear
=
pnew更新隊列尾部指針。隊列的數據結構形式就是由一個頭front指針，一個尾rear指針來表徵，items的設計是用空間換時間，涉及隊列大小的操作會非常方便。
隊列的特徵是先進先出，你給出的鏈式實現，其實就跟一個鏈表一樣，鏈表的添加刪除如果能理解了，隊列只是鏈表的元素增加/刪除
按先進先出特點的一種實現。
但對於隊列來說，實現方式不是重點，先進先出的性質才是重點，這在實際應用中很多，比如排隊叫號。
❺ C語言中使用隊列
如果你用vc，#include<deque>就好了，但是注意要加上using naemspace std；
我是當你用的c++的STL，STL中沒有真正的隊列和棧，他們都是通過對雙端隊列的改造得到的，所以包含的文件可能和你想的不一樣。而且這些頭文件都沒有.h結尾！很特別
如果你不是vc，當我沒說
❻ 棧與隊列的應用（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語言的隊列如何實現和表示
我能想到的有兩種方法（假設隊列元素都是int）
一，用鏈表的方法
struct A
{
int n;
struct A *a;
} *p,*head,*rear;
head=rear=NULL；/*頭指針，尾指針*/
添加元素：p=(struct A*)malloc(sizeof(struct A));......給新元素賦值.....;rear->a=p;rear=p;
當然添加第一個元素的時候要給head賦值。
刪除元素：p=head;head=head->a;free(p);
用的是單向鏈表，當然也可以用雙向鏈表，不過刪除，添加元素的過程要麻煩點。
二，利用數組，當然也可以開辟動態儲存空間
int a[N]，*head,*rear; N就是個常數
head=rear=a;
添加元素：scanf("%d",rear-a==N?rear=a:++rear);
刪除元素：head-a==N?head=a:head++;
當然要檢查隊列是否溢出，可以設變數n=0;
每次添加元素n++
每次刪除元素n--
當n<0後n>N數據溢出
❽ 用C語言編寫隊列程序
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define TRUE 1
#define FALSE 0
#define NULL 0
#define OK 1
#define OVERFLOW 0
#define ERROR 0
typedef int QElemType;
typedef int Status;
typedef struct QNode
{
QElemType data;
QNode *next;
}*QueuePtr;
struct LinkQueue
{
QueuePtr front,rear;//隊頭，隊尾指針
};
//函數列表
void InitQueue(LinkQueue &Q)
{//初始化一個隊列
Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
if(!Q.front)//生成頭結點失敗
exit(OVERFLOW);
Q.front->next=NULL;
}
void DestoryQueue(LinkQueue &Q)
{ //銷毀隊列
while(Q.front)
{
Q.rear=Q.front->next;//Q.rear指向Q.front的下一個結點
free(Q.front);//釋放Q.front所指結點
Q.front=Q.rear;//Q.front指向Q.front的下一個結點
}
}
void ClearQueue(LinkQueue &Q)
{ //將隊列清為空
DestoryQueue(Q);//銷毀隊列
InitQueue(Q);//重新構造隊列
}
Status QueueEmpty(LinkQueue Q)
{ //判斷隊列是否為空
if(Q.front->next==NULL)
return TRUE;
else return FALSE;
}
int QueueLength(LinkQueue Q)
{ //求隊列的長度
int i=0;//計數器清0
QueuePtr p=Q.front;//p指向結點
while(Q.rear!=p)//p所指向的不是尾結點
{
i++;//計數器加1
p=p->next;
}
return i;
}
Status GetHead(LinkQueue Q,QElemType &e)
{ //若隊列不空，則用e返回隊頭元素
QueuePtr p;
if(Q.front==Q.rear) return ERROR;
p=Q.front->next;//p指向隊頭結點
e=p->data;//將隊頭元素的值賦給e
return OK;
}
void EnQueue(LinkQueue &Q,QElemType e)
{ //插入元素e為隊列Q的新的隊尾元素
QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
//動態生成新結點
if(!p)
exit(OVERFLOW);
p->data=e;//將e的值賦給新結點
p->next=NULL;//新結點的指針為空
Q.rear->next=p;//原隊尾結點的指針域為指向新結點
Q.rear=p;//尾指針指向新結點
}
Status DeQueue(LinkQueue &Q,QElemType &e)
{ //若隊列不為空，刪除Q的隊頭元素，用e返回其值
QueuePtr p;
if(Q.front==Q.rear)//隊列為空
return ERROR;
p=Q.front->next;//p指向隊頭結點
e=p->data;//隊頭元素賦給e
Q.front->next=p->next;//頭結點指向下一個結點
if(Q.rear==p)//如果刪除的隊尾結點
Q.rear=Q.front;//修改隊尾指針指向頭結點
free(p);
return OK;
}
void QueueTraverse(LinkQueue Q,void(*visit)(QElemType))
{ //對隊頭到隊尾依次對隊列中每個元素調用函數visit()
QueuePtr p;
p=Q.front->next;
while(p)
{
visit(p->data);//對p所指元素調用visit()
p=p->next;
}
printf("\n");
}
void print(QElemType e)
{
printf("%2d",e);
}
void main()
{
int i,k;
QElemType d;
LinkQueue q;
InitQueue(q);//構造一個空棧
for(i=1;i<=5;i++)
{
EnQueue(q,i);
}
printf("棧的元素為:");
QueueTraverse(q,print);
k=QueueEmpty(q);
printf("判斷棧是否為空,k=%d(1:為空9;0:不為空)\n",k);
printf("將隊頭元素賦給d\n");
k=GetHead(q,d);
printf("隊頭元素為d=%d\n",d);
printf("刪除隊頭元素:\n");
DeQueue(q,d);
k=GetHead(q,d);
printf("刪除後新的隊頭元素為d=%d\n",d);
printf("此時隊列的長度為%d\n",QueueLength(q));
ClearQueue(q);//清空隊列
printf("清空隊列後q.front=%u,q.rear=%u,q.front->next=%u\n",q.front,q.rear,q.front->next);
DestoryQueue(q);
printf("銷毀隊列後,q.front=%u,q.rear=%u\n",q.front,q.rear);
❾ C語言實現隊列的基本操作
structpQueue
{
ElemType*head;//指向開辟的空間的首地址
Elemtype*tail;
intlength;//(總容量)
intL_now;//(當前容量)
};
if(pQueue.L_now==pQueue.length)
{
每次申請空間都是+N
}
pQueue->tail=p;
❿ C語言中，隊列是什麼意思，有什麼用途
隊列是一種特殊的線性表。
隊列一種可以實現「先進先出」的存儲結構，即「一端入，一端出」，隊首(front)出隊，隊尾(rear)入隊，若front指向隊首，則rear指向隊尾最後一個有效元素的下一個元素；若rear指向隊尾，則front指向隊首第一個有效元素的下一個元素。
隊列特殊之處在於它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作，和棧一樣，隊列是一種操作受限制的線性表。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。
(10)c語言隊列的應用實例擴展閱讀
循環隊列各個參數的含義
1、隊列初始化front和rear的值都是零,初始化時隊列就是空的。
2、隊列非空front代表隊列的第一個元素rear代表了最後一個有效元素的下一個元素。
3、隊列空front和rear的值相等，但是不一定是零。