c語言使用隊列
⑴ c語言 隊列的操作
//定義隊列結構體
typedef struct Qnode
{
int data;
struct Qnode *next;
} Queue , *QueuePtr;
typedef struct
{
QueuePtr front;
QueuePtr rear;
} linkQnode;
//創建一個隊列
initQueue (linkQnode *q)
{
q -> front = q -> rear = (QueuePtr) malloc (sizeof (Queue));
if (!q -> front) exit (0);
q -> front -> next = NULL;
}
//入隊列
EnterQueue (linkQnode *q , int item)
{
QueuePtr p;
p = (QueuePtr) malloc (sizeof (Queue));
if (!p) exit (0);
p -> data = item;
p -> next = NULL;
q -> rear -> next = p;
q -> rear = p;
}
//出隊列
DelQueue (linkQnode *q , int *item)
{
QueuePtr p;
if (q -> front = q -> rear) return;
p = q -> front -> next;
*item = p -> data;
q -> front -> next = p -> next;
if (q -> rear == p)
q -> rear = q -> front;
free (p);
}
⑵ C語言隊列，鏈表分別怎麼用
隊列
#include <stdio.h>
#include <stdlib.h>
#define N 11
typedef int data_t;
typedef struct sequeue {
data_t data[N];
int front, rear;
}sequeue_t;
//創建隊列
sequeue_t *create_sequeue()
{
sequeue_t *sq = malloc(sizeof(sequeue_t));
sq->front = sq->rear = 0;
return sq;
}
//判斷空
int empty_sequeue(sequeue_t *sq)
{
return sq->front == sq->rear;
}
//判斷滿(sq->rear + 1) % N == sq->front
int full_sequeue(sequeue_t *sq)
{
return (sq->rear + 1)%N == sq->front ;
}
int push_sequeue(sequeue_t *sq, data_t *data)
{
if(full_sequeue(sq))
return -1;
sq->rear = (sq->rear + 1)%N ;
sq->data[sq->rear] = *data;
return 0 ;
}
int pop_sequeue(sequeue_t *sq, data_t *data)
{
if(empty_sequeue(sq))
return -1;
sq->front = (sq->front + 1)%N ;
*data = sq->data[sq->front] ;
return 0;
}
//清空sq->front = sq->rear;
int clear_sequeue(sequeue_t *sq)
{
sq->front = sq->rear;
return 0;
}
//銷毀
int detory_sequeue(sequeue_t *sq)
{
free(sq);
return 0;
}
int main(int argc, const char *argv[])
{
data_t data;
int i;
sequeue_t *sq = create_sequeue();
for(i = 0; i < 10; i++)
{
push_sequeue(sq, &i);
}
for(i = 0; i < 10; i++)
{
pop_sequeue(sq, &data);
printf("%d ", data);
}
putchar(10);
detory_sequeue(sq);
return 0;
}
鏈表
#include <stdio.h>
#include <stdlib.h>
typedef int data_t;
typedef struct linknode {
data_t data;
struct linknode *next;
}linknode_t, linklist_t;
//創建一個鏈表
//1. 在內存總開辟頭結點的空間malloc
//2. 將頭結點的next域置空NULL
//3. 返回創建並設置好的鏈表的首地址
linklist_t *create_linklist()
{
linklist_t *node;
node=(linklist_t *)malloc(sizeof(linklist_t));
node->next=NULL;
return node;
}
//判斷當前鏈表是否為空
int empty_linklist(linklist_t *ll)
{
return ll->next == NULL;
}
//求鏈表中當前有效元素的個數
int length_linklist(linklist_t *ll)
{
int i;
for(i=0;ll->next != NULL;i++)
ll=ll->next;
return i;
}
//獲得下標為index位置的元素，成功返回0，失敗返回-1
//1. 判斷index是否合法(部分判斷)
//2. 在保證ll->next 不為空的清空下，將ll的首地址向後移動index次
//3. 判斷ll->next 是否等於空，如果等於空，則返回-1，如果不為空，執行4.
//4. 當移動了index次之後，當前ll->next 的位置的節點就保存了我要獲得的
//數據
//5. *data = ll->next->data;
//6. 返回0
int get_linklist(linklist_t *ll, int index, data_t *data)
{
int i;
if(index < 0)
return -1;
while( ll->next != NULL && index > 0)
{
ll=ll->next;
index--;
}
if( ll->next == NULL)
return -1;
*data = ll->next->data;
return 0;
}
//使用頭插法插入一個元素
//1. 創建一個節點node
//2. 將要插入的數據保存到node
//3. 執行插入操作
//4. 返回0
int insert_linklist(linklist_t *ll, data_t *data)
{
linklist_t *node;
node=(linklist_t *)malloc(sizeof(linklist_t));
node->data=*data;
node->next=ll->next;
ll->next=node;
return 0;
}
//刪除鏈表中的一個節點:刪除頭結點的後一個位置(頭刪法)
//首先可以判斷當前鏈表是否為空，如果為空返回-1
//如果不為空則刪除頭結點的下一個位置的節點
//最後返回0
int delete_linklist(linklist_t *ll)
{
linklist_t *node;
if(ll->next == 0)
return -1;
node= ll->next;
ll->next =node->next;
free(node);
return 0;
}
//清空鏈表
//循環刪除鏈表的一個節點，然後判斷刪除函數的返回值是否為0
//如果為0，繼續刪除，如果為-1則停止循環
int clear_linklist(linklist_t *ll)
{
while(delete_linklist(ll) == 0);
return 0;
}
//銷毀鏈表
//1. 調用清空操作清空鏈表
//2. 刪除頭結點
//3. 返回0
int detory_linklist(linklist_t *ll)
{
free(ll);
return 0;
}
int main(void)
{
data_t data;
int i, length;
linklist_t *ll;
ll = create_linklist(); //創建一個鏈表
for(i = 0; i < 10; i++)
{
// i=i+65;
insert_linklist(ll, &i); //賦值 4 3 2 1 0
// i=i-65;
}
length = length_linklist(ll); //長度 輸出
printf("鏈表有 %d 個數 \n",length);
for(i = 0; i < length; i++) //輸出 鏈表內容
{
get_linklist(ll, i, &data);
printf("%d ", data);
}
putchar(10);
delete_linklist(ll); //刪除頭結點的後一個位置
length = length_linklist(ll); //長度 輸出
printf("刪除頭結點的後一個位置的鏈表\n");
for(i = 0; i < length; i++) //輸出 鏈表內容
{
get_linklist(ll, i, &data);
printf("%d ", data);
}
data = 692857680;
insert_linklist(ll, &data); //在頭節點後添加 1 個數
length = length_linklist(ll);
printf("\n在頭結點的後一個位置的添加我的QQ\n");
for(i = 0; i < length; i++)
{
get_linklist(ll, i, &data);
printf("%d ", data);
}
putchar(10);
clear_linklist(ll); //清空鏈表
length = length_linklist(ll);
printf("清空鏈表輸出\n");
for(i = 0; i < length; i++)
{
get_linklist(ll, i, &data);
printf("%d ", data);
}
detory_linklist(ll);
return 0;
}
⑶ C語言實現隊列的基本操作
structpQueue
{
ElemType*head;//指向開辟的空間的首地址
Elemtype*tail;
intlength;//(總容量)
intL_now;//(當前容量)
};
if(pQueue.L_now==pQueue.length)
{
每次申請空間都是+N
}
pQueue->tail=p;
⑷ C語言中使用隊列
如果你用vc，#include<deque>就好了，但是注意要加上using naemspace std；
我是當你用的c++的STL，STL中沒有真正的隊列和棧，他們都是通過對雙端隊列的改造得到的，所以包含的文件可能和你想的不一樣。而且這些頭文件都沒有.h結尾！很特別
如果你不是vc，當我沒說
⑸ c語言隊列操作
pq->rear->next
=
pnew這個代碼從隊列的尾部增加新節點，
然後pq->rear
=
pnew更新隊列尾部指針。隊列的數據結構形式就是由一個頭front指針，一個尾rear指針來表徵，items的設計是用空間換時間，涉及隊列大小的操作會非常方便。
隊列的特徵是先進先出，你給出的鏈式實現，其實就跟一個鏈表一樣，鏈表的添加刪除如果能理解了，隊列只是鏈表的元素增加/刪除
按先進先出特點的一種實現。
但對於隊列來說，實現方式不是重點，先進先出的性質才是重點，這在實際應用中很多，比如排隊叫號。
⑹ 數據結構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;
}
執行結果
⑺ C語言中，隊列是什麼意思，有什麼用途
隊列是一種特殊的線性表。
隊列一種可以實現「先進先出」的存儲結構，即「一端入，一端出」，隊首(front)出隊，隊尾(rear)入隊，若front指向隊首，則rear指向隊尾最後一個有效元素的下一個元素；若rear指向隊尾，則front指向隊首第一個有效元素的下一個元素。
隊列特殊之處在於它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作，和棧一樣，隊列是一種操作受限制的線性表。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。
(7)c語言使用隊列擴展閱讀
循環隊列各個參數的含義
1、隊列初始化front和rear的值都是零,初始化時隊列就是空的。
2、隊列非空front代表隊列的第一個元素rear代表了最後一個有效元素的下一個元素。
3、隊列空front和rear的值相等，但是不一定是零。
⑻ C語言實現優先隊列(priority queue)
堆排序是一個比較優秀的演算法,堆這種數據結構在現實生活中有很多的應用,比如堆可以作為一個優先隊列來使用,作為一個高效的優先隊列,它與堆的結構一樣,都有最大優先隊列,最小優先隊列.優先隊列priority queue 是一種用來維護一組元素構成的集合S的數據結構，每一個元素都有一個相關的值，稱為關鍵字（key）。
最大優先隊列包含以下操作：
將元素x插入到S的集合中，等價於 ；
返回S中最大元素；
返回並且刪除S中最大元含李素；
將元素x的關鍵字增加到key，要求 。
同樣的，最小優先隊列操作也包括： , , , 。只不過是對最小值進行操作。
在這里主要討論最大優先隊列，其應用很多，在共享計算機作業系統就是，類似於早期的unix主機，管理員root可以設置n個不同的用戶，以及各個用戶不同的操作許可權，從主機那裡接出多個終端，每個操作人員（程序員）在自己的工作終端 ，感覺像是自己擁有自己獨立的作業主機一樣，其實不是，通過一些任務調度來實現，其中就有任務等待執行相關隊列，並且有各個任務有著自己優先順序，以便確定調度執行具體任務，如果你學過操作系統相關知識，那麼應該對系統調度有所了解。
當一個作業被完成或者被中斷後，調度器會調用 來調用所有在隊列中等待任務中優先順序最高的任務執行，在新任務加入等待任務時會配稿調用 加入任務等待隊列，當某個任務等待時間過長時可通過 提高其優先順序培老孝，從而減少等待時間。
下面是具體實現C程序源碼：
#include <stdio.h>
#define NAGE_INFINIT -99999
#define parent(i) i/2
#define left(i) 2*i+1
#define right(i) 2*i+2
//get array of A first element
int heap_maximum(int A[]){ return A[0];}
/***********************************************
*
* function max_heapify();
*
* args
* A[] inttype save elements of heap
* i index of A
* heap_size real length of A
*
* ********************************************/
void max_heapify(int A[],int i,int heap_size){
int l,r,largest,temp;
l=left(i);
r=right(i);
if((l<=heap_size)&&(A[l]>A[i]))
largest=l;
else
largest=i;
if((r<=heap_size)&&(A[r]>A[largest]))
largest=r;
if(largest!=i){
temp=A[i];
A[i]=A[largest];
A[largest]=temp;
max_heapify(A,largest,heap_size);
}
}
/*********************************************
*
* function heap_extract_max()
*
* args
* A[] inttype save elements of heap
* heap_size inttype the real length of A
*
* return max the parent node value
*
* ******************************************/
int heap_extract_max(int A[],int heap_size){
int max;
if(heap_size<0)
return -1; //heap underflow
max=A[0]; //parent node the max value of element
A[0]=A[heap_size];
heap_size--;
/**************************************
* dajust binary heap(or tree) to make
* sure heap fo A true every times
*
* ************************************/
max_heapify(A,0,heap_size);
return max;
}
/***********************************************
*
* function heap_increase_key();
*
* args
* A[] inttype save elemnts of heap
* i index of A
* key inserted element
*
* *********************************************/
void heap_increase_key(int A[],int i,int key){
int temp;
if(key<A[i]){
printf("new key is smaller than current key\n");
return; //over programming
}
A[i]=key;
//p=parent(i);
while ((i>0)&&(A[parent(i)]<A[i])) {
temp=A[i];
A[i]=A[parent(i)];
A[parent(i)]=temp;
i=parent(i); //update index of A
//p=parent(i);
}
}
/***************************************************
*
* function max_heap_insert();
*
* args
* A[] inttype save elements of A
* key inserted element to A
* heap_size real length of A
*
* **************************************************/
void max_heap_insert(int A[],int key,int heap_size){
heap_size+=1;
A[heap_size]=NAGE_INFINIT;
heap_increase_key(A,heap_size,key);
}
int main()
{
int heap_max,max,i,key;
int A[11],Temp[11];
int heap_size=0;
char c;
while (1) {
scanf("%d",&A[heap_size]);
c=getchar();
if(c=='\n')
break;
heap_size++;
}
// A to Temp
for(i=0;i<=heap_size;i++)
Temp[i]=A[i];
//get heap maximum element
heap_max=heap_maximum(A);
printf("heap of A maximum element: %d\n",heap_max);
// Temp to A
for(i=0;i<=heap_size;i++)
A[i]=Temp[i];
/*--extract maximum element--*/
max=heap_extract_max(A,heap_size);
printf("extract element: %d \n",max);
printf("new heap of A after extract maximum node\n");
for(i=0;i<heap_size;i++)
printf("%d ",A[i]);
printf("\n"); //next line
// Temp to A
for(i=0;i<=heap_size;i++)
A[i]=Temp[i];
/*--increase from A[i] to key--*/
printf("input i key ");
scanf("%d %d",&i,&key);
heap_increase_key(A,i,key);
for(i=0;i<=heap_size;i++)
printf("%d ",A[i]);
printf("\n");
// Temp to A
for(i=0;i<=heap_size;i++)
A[i]=Temp[i];
/*--insert queueu--*/
key=0; //init key;
printf("input key: ");
scanf("%d",&key);
max_heap_insert(A,key,heap_size);
for(i=0;i<=heap_size+1;i++)
printf("%d ",A[i]);
printf("\n");
return 0;
}
/****************************************
*
* input 16 14 10 8 7 9 3 2 4 1
* i: 8
* key: 15
*
* output in function main()
* **************************************/
其運行結果如下圖：
歡迎留言交流，也感謝指正，一起進步。
⑼ 數據結構（使用C語言）隊列
對順序循環隊列，常規的設計方法是使用隊尾指針和隊頭指針，隊尾指針用於指出當前胡隊尾位置下標，隊頭指針用於指示當前隊頭位置下標。現要求：
（1）設計一個使用隊頭指針和計數器胡順序循環循環隊列抽象數據類型，其中包括：初始化，入隊列，出隊列，取隊頭元素肯判斷隊列是否非空；
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"conio.h"
#defineMAX80
typedefstruct
{
intdata[MAX];
intfront,rear;
intnum;
}SeQue;
SeQue*Init_SeQue()
{
SeQue*s;
s=newSeQue;
s->front=s->rear=MAX-1;
s->num=0;
returns;
}
intEmpty_SeQue(SeQue*s)
{
if(s->num==0)
return1;
else
return0;
}
intIn_SeQue(SeQue*s,intx)
{
if(s->num==MAX)
return0;
else
{
s->rear=(s->rear+1)%MAX;
s->data[s->rear]=x;
s->num++;
return1;
}
}
intOut_SeQue(SeQue*s,int*x)
{
if(Empty_SeQue(s))
return0;
else
{
s->front=(s->front+1)%MAX;
*x=s->data[s->front];
s->num--;
return1;
}
}
voidPrint_SeQue(SeQue*s)
{
inti,n;
i=(s->front+1)%MAX;
n=s->num;
while(n>0)
{printf("%d",s->data[i]);
i=(i+1)%MAX;
n--;
}
}
voidmain()
{
SeQue*s;
intk,flag,x;
s=Init_SeQue();
do{
printf("\");
printf("\t\t\t循環順序隊列");
printf("\t\t\t***********************");
printf("\t\t\t**1-入隊**");
printf("\t\t\t**2-出隊**");
printf("\t\t\t**3-判隊空**");
printf("\t\t\t**4-隊列顯示**");
printf("\t\t\t**0-返回**");
printf("\t\t\t***********************");
printf("\t\t\t請輸入菜單項(0-4):");
scanf("%d",&k);
switch(k)
{
case1:
printf("請輸入入隊元素:");
scanf("%d",&x);
flag=In_SeQue(s,x);
if(flag==0)
printf("隊滿不能入隊!按任意鍵返回..");
else
printf("元素已入隊!按任意鍵返回..");
getch();
system("cls");
break;
case2:
flag=Out_SeQue(s,&x);
if(flag==0)
printf("隊列空出隊失敗!按任意鍵返回..");
else
printf("隊列頭元素已出隊~!按任意鍵返回..");
getch();
system("cls");
break;
case3:
flag=Empty_SeQue(s);
if(flag==1)
printf("該隊列為空!按任意鍵返回..");
else
printf("該隊列不為空!按任意鍵返回..");
getch();
system("cls");
break;
case4:
printf("該隊列元素為:");
Print_SeQue(s);
printf("按任意鍵返回..");
getch();
system("cls");
break;
}
}while(k!=0);
}