编程实现出队
这样的话应该符合你的要求：
#include<stdio.h>
voidadd(intqueue[],intx);
intTop(intqueue[]);
voiddel(intqueue[]);
intend=0;
intmain()
{
intn;
scanf("%d",&n);//将要入队列n个元素
intqueue[1000];
for(inti=1;i<=n;i++)//输入n个元素
{
add(queue,i);//将i加入队列
}
//验证加入队列的元素，将队列中的元素按照输入的顺序输出：
for(i=1;i<=n;i++)
{
printf("%d",Top(queue));//Top函数返回队头元素
del(queue);//删除队头元素
}
//验证输出已经出队列后的队列（数组）元素：
printf(" ");
for(i=1;i<=n;i++)
printf("%d",queue[i]);
printf(" ");
return0;
}
voidadd(intqueue[],intx)
{
queue[++end]=x;
}
intTop(intqueue[])
{
returnqueue[1];//注意，这里的函数始终returnqueue[1];这里是和将普通数组中的元素输出最大的不同之处。！！！！！！
}
voiddel(intqueue[])
{
for(inti=2;i<=end;i++)
{
queue[i-1]=queue[i];
}
queue[end]=0;//将删除后的地方置0
end--;
}
2. 试写出循环队列出队、入队的算法（用C语言给出主要部分即可）
#define Max 300
typedef struct
{
int tail,head;
int a[Max];
}queue;
void enqueue(int key,queue&q)
{
q.a[q.tail]=key;
q.tail=(q.tail+1)%Max;
}
int dequeue(queue&q)
{
int key;
key=q.a[q.head];
q.head=(q.head+1)%Max;
return key;
}
用了c++引用。。。。。。没有入队前的判断是否满了以及出队前判断是否为空，这个你应该懂的
3. 在循环队列中怎样实现入队和出队操作 数据结构 C语言
入队操作
功能：将元素 x 插入到Q的队尾。
算法：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;
}
出队操作
功能：删除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;
}
4. c语言实现出队入队，输入0表示出队，输入-1表示程序结束，其余整数表示入队，队列空或满，操作错误
#include<stdio.h>
#include<string.h>
#include<windows.h>
#defineMAX_STACK100
voidmain()
{
charchstr[100];
charstack[MAX_STACK];
intcur_pos=-1;
while(1)
{
system("cls");
printf("-----------------------队列操作------------------------- ");
printf("***0:POP***-1:GAMEOVER***1-9:PUSH ");
printf("Example: ");
printf("0[ENTER]-1[ENTER]1abcd[ENTER]或者2abcd[ENTER] ");
fflush(stdin);
gets(chstr);
if(chstr[0]=='-'&&chstr[1]=='1'&&strlen(chstr)==2)
break;
elseif(chstr[0]=='0'&&strlen(chstr)==1)
{
if(cur_pos==-1)
{
printf("%%error:stackempty,cannotpop! ");
continue;
}
cur_pos--;
printf("pop[%c]out ",stack[cur_pos+1]);
}
elseif(chstr[0]>='1'&&chstr[0]<='9')
{
intp=1;
while(chstr[p]!=0&&cur_pos<MAX_STACK)
{
cur_pos++;
stack[cur_pos]=chstr[p++];
printf("push[%c]in ",chstr[p-1]);
if(cur_pos==MAX_STACK-1&&chstr[p]!=0)
{
printf("%%error:cannnotpush[%c]:stackfull ",chstr[p]);
break;
}
}
}
else
printf("%%error:Unknowoperation! ");
}
}
5. 如何才能C语言编程实现出队与入队急！！！
#include <assert.h>
#include <iostream.h>
#ifndef POINTQUEUE
#define POINTQUEUE
template <class Type> class Queue; //前视声明
template <class Type>
class QueueNode
{
friend class Queue<Type>;
private:
Type data; //队列结点数据
QueueNode<Type> *link; //结点链指针
QueueNode(Type d=0,QueueNode *l=NULL):data(d),link(l){};
};
template <class Type>
class Queue
{
public:
Queue():rear(NULL),front(NULL),length(0){};
~Queue();
void EnQueue(const Type &item);
Type DeQueue();
Type GetFront();
void MakeEmpty(){ Distroy();front=rear=NULL; }
int Length(){ return length;}
bool IsEmpty()const { return front==NULL; }
private:
QueueNode<Type> *front, *rear; //队列指针
int length;
void Distroy();
};
template <class Type>
Queue<Type>::~Queue() //队列的析构函数
{
Distroy();
}
template <class Type>
void Queue<Type>::EnQueue(const Type &item) //将新元素item插入到队列的队尾
{
length++;
if(front==NULL)
front=rear=new QueueNode<Type>(item,NULL);
else
rear=rear->link=new QueueNode<Type>(item,NULL);
}
template <class Type>
Type Queue<Type>::DeQueue() //删去队头结点，并返回队头元素的值
{
assert(!IsEmpty()); //判队空的断言
length--;
QueueNode<Type> *p = front;
Type retvalue=p->data; //保存队头的值
front=front->link; //新队头
delete p;
return retvalue;
}
template <class Type>
Type Queue<Type>::GetFront() //若队不空，则函数返回队头元素的值
{
assert(!IsEmpty());
return front->data;
}
template <class Type>
void Queue<Type>::Distroy()
{
QueueNode<Type> *p;
while(front!=NULL) //逐个结点释放
{
p=front;
front=front->link;
delete p;
}
}
#endif
#include "pointqueue.h"
int main()
{
// Queue<int> qu(10);
Queue<int> qu;
int i;
for(i=0;i<10;i++)
qu.EnQueue(i*10-3);
cout<<qu.Length()<<endl;
for(i=0;i<10;i++)
cout<<qu.DeQueue()<<' ';
return 1;
}
6. 数据结构c语言版，出队入队及依次输出一个队列的操作。
#include<stdio.h>
#include<stdlib.h>
#defineElemTypeint
#defineStatusint
#defineOK1
#defineERROR0
typedefstructQNode{
ElemTypedata;
structQNode*next;
}QNode;
typedefstructLinkQueue{
QNode*front;
QNode*rear;
}LinkQueue;
StatusInitQueue(LinkQueue*q){//建立队列
q->front=q->rear=(QNode*)malloc(sizeof(QNode));
if(!q->front)
returnERROR;
q->front->next=NULL;
returnOK;
}
StatusEnQueue(LinkQueue*q,ElemTypee){//入队
QNode*p=(QNode*)malloc(sizeof(QNode));
if(!p)
returnERROR;
p->data=e;
p->next=NULL;
q->rear->next=p;//入队操作，从队尾(rear)进入
q->rear=p;
returnOK;
}
StatusDeQueue(LinkQueue*q,ElemType*e){//出队
QNode*p=(QNode*)malloc(sizeof(QNode));
if(!p)
returnERROR;
p=q->front->next;//q指向的是front指针的下一个位置，亦即队首元素
*e=p->data;
q->front->next=p->next;//出队操作后，front++
if(q->rear==p)//判断是否全部出队
q->rear=q->front;//如果全部出队，则将队列置为空
returnOK;
}
StatusPrintfQueue(LinkQueue*Q){
QNode*p;
for(p=Q->front->next;p!=NULL;p=p->next)
printf("%d ",p->data);
}
intmain(void)
{
inti,n;
ElemTypee,de;
LinkQueue*q=(LinkQueue*)malloc(sizeof(QNode));
if(!q)
returnERROR;
InitQueue(q);
printf("以下开始构造初始队列: ");
printf("请输入元素个数：");
scanf("%d",&n);
printf(" ");
for(i=0;i<n;++i){
printf("请输入第%d个元素：",i+1);
scanf("%d",&e);
EnQueue(q,e);
}
printf(" ");
printf("初始队列构造完毕！ ");
printf("初始队列： ");
PrintfQueue(q);
printf(" ");
printf("====================================================== ");
printf("以下开始执行入队操作: ");
printf("请输入需入队的元素个数：");
scanf("%d",&n);
printf(" ");
for(i=0;i<n;++i){
printf("请输入第%d个元素：",i+1);
scanf("%d",&e);
EnQueue(q,e);
}
printf(" ");
printf("入队%d个元素操作完毕！ ",n);
printf("此时队列: ");
PrintfQueue(q);
printf(" ");
printf("====================================================== ");
printf("以下开始执行出队操作: ");
printf("请输入需出队的元素个数：");
scanf("%d",&n);
printf(" ");
for(i=0;i<n;++i)
DeQueue(q,&de);
printf(" ");
printf("出队%d个元素操作完毕！ ",n);
printf("此时队列: ");
PrintfQueue(q);
printf(" ");
printf("====================================================== ");
free(q);
return0;
}
执行结果
7. 用c语言编写12345的入队，然后出队
#include "stdafx.h"
#include "stdio.h"
#include "malloc.h"
#define MAX 8
static int Queen[8][8];
static int a=1;
typedef struct
{
int *elem;
int top;
}ColStack;//栈：存放每一行放置皇后的列号
void InitQueen()
{
int i,j;
for(i = 0; i < 8; i++)
{
for(j = 0; j < 8; j++)
{
Queen[i][j] = 0;
}
}
}
int InitStack(ColStack &CS)//初始化栈
{
CS.elem = (int *)malloc(MAX*sizeof(int));
if(!CS.elem) return 0;
CS.top = -1;
return 1;
}
int Push(ColStack &CS, int e)//进栈
{
if(CS.top >= 8) return 0;
CS.top++;
CS.elem[CS.top] = e;
return 1;
}
int Pop(ColStack &CS, int &e)//退栈
{
if(CS.top == -1)return 0;
e = CS.elem[CS.top];
CS.top--;
return 1;
}
int Back(ColStack &CS,int &e)//回溯
{
Pop(CS,e);
Queen[CS.top+1][e] = 0;
if(e == 7 && CS.top == -1)
{
return 0;
}
if(e == 7 && CS.top != -1)
{
Back(CS,e);
}
return 1;
}
int OK(int i, int j)//检查(i,j)上能否放棋子
{
int k, m;
for(k = i; k >= 0; k--)//检查同列
{
if(Queen[k][j] == 1) return 0;
}
k = i; m = j;
while(k >= 0 && m >= 0)
{
if(Queen[k][m] == 1) return 0;
k--; m--;
}
k = i; m = j;
while(k >= 0 && m < 8)
{
if(Queen[k][m] == 1) return 0;
k--;m++;
}
return 1;
}
//进入本函数时，在8*8棋盘前i-1行已放置了互不攻
// 击的i-1个棋子。现从第 i 行起继续为后续棋子选择
// 满足约束条件的位置。当求得(i>8)的一个合法布局
// 时，输出之。
int queen(int i, ColStack &CS, int start)
{
int j, k,e;
if(i>=8)
{
printf("第%d种情况：\n",a);
for(j = 0; j < 8; j++)
{
for(k = 0; k < 8; k++)
{
if(Queen[j][k] == 0)
{
printf("# ");
}
else
{
printf("@ ");
}
}
printf("\n");
}
a++;
}else
{
for(j = start+1; j < 8; j++)
{
if(OK(i,j) == 1)
{
Queen[i][j]=1;
Push(CS,j);
queen(i+1,CS,-1);
return 1;
}
}
}
if(j == 8)
{
if(Back(CS,e) == 1)
{
queen(CS.top+1,CS,e);
}
if(Back(CS,e) == 0)
{
return 1;
}
}
}
int main()
{
InitQueen();
ColStack cs;
InitStack(cs);
queen(0,cs,-1);
return 0;
}
这是一个八皇后问题，是个典型的出队列、入队列问题