精华内容
下载资源
问答
  • 队列基本操作

    万次阅读 多人点赞 2018-08-28 21:59:36
    假溢出:顺序队列因多次入队列和出队列操作后出现的尚有存储空间但不能进行入队列操作的溢出。 真溢出:顺序队列的最大存储空间已经存满二又要求进行入队列操作所引起的溢出。 3.循环队列 循环队列如何...

    1.队列的概念
    只允许在一端插入数据操作,在另一端进行删除数据操作的特殊线性表;进行插入操作的一端称为队尾(入队列),进行删除操作的一端称为队头(出队列);队列具有先进先出(FIFO)的特性。


    2.顺序队列
    (1)队头不动,出队列时队头后的所有元素向前移动
    这里写图片描述
    缺陷:操作是如果出队列比较多,要搬移大量元素。

    (2)队头移动,出队列时队头向后移动一个位置
    这里写图片描述
    如果还有新元素进行入队列容易造成假溢出。

    • 假溢出:顺序队列因多次入队列和出队列操作后出现的尚有存储空间但不能进行入队列操作的溢出。
    • 真溢出:顺序队列的最大存储空间已经存满二又要求进行入队列操作所引起的溢出。

    3.循环队列
    这里写图片描述
    循环队列如何进行判空和满操作:

    • 少用一个存储单元
    • 设置一个标记flag;
      初始值 flag = 0;入队列:flag = 1; 出队列:flag = 0;
      队列为空时:(front == rear && flag == 0)
      队列为满时:(front == rear && flag == 1)
    • 设置一个计数器

    4.链式队列
    链式队列:特殊的单链表,只在单链表上进行头删尾插的操作
    ***【1.定义一个队列结构体】***】

    • 由于是链式队列,所以先定义一个存放数据域和指针域的结构体
    • 队列结构体中定义一个队头指针和队尾指针
    typedef int QElemType;
    //typedef struct BTNode* QElemType;
    typedef struct QNode
    {
    	QElemType data;
    	struct QNode *_pNext;
    }QNode;
    
    typedef struct LQueue
    {
    	QNode *pFront;
    	QNode *pRear;
    }LQueue;
    

    【2.创建新结点】

    //创建新结点
    static QNode *BuyLQNode(QElemType data)
    {
    	QNode *pLQNode = (QNode *)malloc(sizeof(QNode));
    	if (NULL == pLQNode)
    	{
    		printf("申请空间失败!\n");
    		assert(pLQNode);
    	}
    	pLQNode->data = data;
    	pLQNode->_pNext = NULL;
    
    	return pLQNode;
    }
    

    【3.初始化队列】

    • 让队列的队头,队尾分别指向空
    void LQueueInit(LQueue *q)
    {
    	assert(q);
    	q->pFront = q->pRear = NULL;
    }
    

    【4.入队列】
    这里写图片描述

    • 判断队中是否有元素
    • 找到队尾元素
    • 让新入队的元素链在原先队列的队尾上,更新新的队尾
    void LQueuePush(LQueue *q, QElemType data)
    {
    	assert(q);
    	if (NULL == q->pFront)
    	{
    		q->pFront = q->pRear = BuyLQNode(data);
    		return;
    	}
    	q->pRear->_pNext = BuyLQNode(data);
    	q->pRear = q->pRear->_pNext;
    }
    

    【5.出队列】
    这里写图片描述

    • 这里的出队列采用是让队头元素不断后移,刷新队头元素,这样优化时间效率
    void LQueuePop(LQueue *q)
    {
    	assert(q);
    	QNode *pDel;
    	if (NULL == q->pFront)
    	{
    		return;
    	}
    
    	if (q->pFront == q->pRear)
    	{
    		q->pRear = NULL;
    	}
    
    	pDel = q->pFront;
    	q->pFront = q->pFront->_pNext;
    	free(pDel);
    }
    

    【6.返回队头元素】

    • 直接返回队头元素
    QElemType LQueueTop(LQueue *q)
    {
    	assert(q);
    	return q->pFront->data;
    }
    

    【7.返回队尾元素】

    • 直接返回队尾元素
    QElemType LQueueBack(LQueue *q)
    {
    	assert(q);
    	return q->pRear->data;
    }
    

    【8.计算队列长度】

    • 定义一个变量count
    • 将队列从头到尾遍历,每访问一个元素count加1一下
    • 最后count的值就是队列长度
    int LQueueSize(LQueue *q)
    {
    	int count = 0;
    	QNode *pCur;
    	assert(q);
    	pCur = q->pFront;
    	while (pCur)
    	{
    		pCur = pCur->_pNext;
    		count++;
    	}
    	return count;
    }
    

    【9.队列判空操作】

    int LQueueEmpty(LQueue *q)
    {
    	return NULL == q->pFront;
    }
    

    5.完整代码块

    /*****************************************/
    //LQueue.h
    
    typedef int QElemType;
    //typedef struct BTNode* QElemType;
    typedef struct QNode
    {
    	QElemType data;
    	struct QNode *_pNext;
    }QNode;
    
    typedef struct LQueue
    {
    	QNode *pFront;
    	QNode *pRear;
    }LQueue;
    
    
    //初始化
    void LQueueInit(LQueue *q);
    
    //入队列
    void LQueuePush(LQueue *q, QElemType data);
    
    //出队列
    void LQueuePop(LQueue *q);
    
    //返回队头元素
    QElemType LQueueTop(LQueue *q);
    
    //返回返回队列长度
    int LQueueSize(LQueue *q);
    
    //队列是否为空
    int LQueueEmpty(LQueue *q);
    
    
    /************************************************/
    //LQueue.c
    
    #include <stdlib.h>
    #include <assert.h>
    #include <stdio.h>
    
    //创建新结点
    static QNode *BuyLQNode(QElemType data)
    {
    	QNode *pLQNode = (QNode *)malloc(sizeof(QNode));
    	if (NULL == pLQNode)
    	{
    		printf("申请空间失败!\n");
    		assert(pLQNode);
    	}
    	pLQNode->data = data;
    	pLQNode->_pNext = NULL;
    
    	return pLQNode;
    }
    
    //初始化
    void LQueueInit(LQueue *q)
    {
    	assert(q);
    	q->pFront = q->pRear = NULL;
    }
    
    //入队列
    void LQueuePush(LQueue *q, QElemType data)
    {
    	assert(q);
    	if (NULL == q->pFront)
    	{
    		q->pFront = q->pRear = BuyLQNode(data);
    		return;
    	}
    	q->pRear->_pNext = BuyLQNode(data);
    	q->pRear = q->pRear->_pNext;
    }
    
    //出队列
    void LQueuePop(LQueue *q)
    {
    	assert(q);
    	QNode *pDel;
    	if (NULL == q->pFront)
    	{
    		return;
    	}
    
    	if (q->pFront == q->pRear)
    	{
    		q->pRear = NULL;
    	}
    
    	pDel = q->pFront;
    	q->pFront = q->pFront->_pNext;
    	free(pDel);
    }
    
    //返回队头元素
    QElemType LQueueTop(LQueue *q)
    {
    	assert(q);
    	return q->pFront->data;
    }
    
    //返回队尾元素
    QElemType LQueueBack(LQueue *q)
    {
    	assert(q);
    	return q->pRear->data;
    }
    
    //返回返回队列长度
    int LQueueSize(LQueue *q)
    {
    	int count = 0;
    	QNode *pCur;
    	assert(q);
    	pCur = q->pFront;
    	while (pCur)
    	{
    		pCur = pCur->_pNext;
    		count++;
    	}
    	return count;
    }
    
    //队列是否为空
    int LQueueEmpty(LQueue *q)
    {
    	return NULL == q->pFront;
    }
    

    展开全文
  • 【数据结构严蔚敏】 第三章 队列基本操作C语言 队列基本操作与栈类似,区别是删除元素时根据先进先出原则(FIFO),下面给出链队列的基本操作。 代码部分 1.基本结构定义 typedef int QElemType; //元素类型 ...

    【数据结构严蔚敏】 第三章 队列基本操作C语言

    队列基本操作与栈类似,区别是删除元素时根据先进先出原则(FIFO),下面给出链队列的基本操作。

    代码部分

    1.基本结构定义

    typedef int QElemType;	//元素类型
    typedef int Status;		
    typedef struct QNode {
    	QElemType data;
    	struct QNode *next;
    }QNode,*QueuePtr;
    
    typedef	struct {
    	QueuePtr front;	//对头指针
    	QueuePtr rear;	//队尾指针
    }LinkQueue;
    

    2.基本操作函数声明 LinkQueue.h

    //构造一个空队列
    Status InitQueue(LinkQueue &Q);
    
    //销毁队列Q,Q不再存在
    Status DetroyQueue(LinkQueue &Q);
    
    //将Q清为空队列
    Status ClearQueue(LinkQueue &Q);
    
    //若Q为空队列,则返回TRUE,否则返回FLASE
    Status QueueEmpty(LinkQueue Q);
    
    //返回Q的元素个数
    int QueueLenth(LinkQueue Q);
    
    //若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR
    Status GetHead(LinkQueue Q, QElemType &e);
    
    //插入元素e为Q的新的队尾元素
    Status EnQueue(LinkQueue &Q, QElemType e);
    
    //若队列不空,则删除Q的队头元素,用e返回其值,并返回OK
    Status DeQueue(LinkQueue &Q, QElemType &e);
    
    //对队列所有元素依次进行visit()操作
    Status QueueTraverse(LinkQueue Q, Status(*visit)(QueuePtr));
    

    3.基本操作函数定义 LinkQueue.c

    #include "LinkQueue.h"
    
    Status InitQueue(LinkQueue & Q)
    {
    	//构造一个空队列Q
    	Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
    	if (!Q.front)exit(OVERFLOW);
    	Q.front->next = NULL;
    	return OK;
    }
    
    Status DetroyQueue(LinkQueue & Q)
    {
    	//销毁一个队列
    	while (Q.front) {
    		Q.rear = Q.front->next;
    		free(Q.front);
    		Q.front = Q.rear;
    	}
    	return OK;
    }
    
    Status ClearQueue(LinkQueue & Q)
    {	//清除一个队列
    	while (Q.front->next) {
    		Q.rear = Q.front->next;
    		free(Q.front);
    		Q.front = Q.rear;
    	}
    	Q.front->next = NULL;
    	return OK;
    }
    
    Status QueueEmpty(LinkQueue Q)
    {	//判断队列是否为空
    	if (Q.front == Q.rear) return TRUE; 
    	return FALSE;
    }
    
    int QueueLenth(LinkQueue Q)
    {	//返回队列长度	
    	QueuePtr p;
    	p = Q.front;
    	int i=0;
    	while (!(p==Q.rear)) {
    		i++;
    		p = p->next;
    	}
    	return i;
    }
    
    Status GetHead(LinkQueue Q, QElemType & e)
    {
    	//
    	if (Q.front == Q.rear)return ERROR;
    	e = Q.front->next->data;
    	return OK;
    }
    
    Status EnQueue(LinkQueue & Q, QElemType e)
    {	//插入元素e为Q的新的队尾元素
    	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
    	if (!p)return ERROR;
    	p->next = NULL;
    	p->data = e;
    	Q.rear->next = p;
    	Q.rear = p;
    	return OK;
    }
    
    Status DeQueue(LinkQueue & Q, QElemType & e)
    {//若队列不空,则删除Q的队头元素,用e返回其值,并返回OK
    	if (Q.front == Q.rear)return ERROR;
    	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));   //此处为何要给p申请空间?
    	p = Q.front->next;								//Q.front->next已经申请过内存空间
    	e = p->data;									//p = Q.front->next之后
    	Q.front->next = p->next;						//free(p)free的是哪一块?
    	if (Q.rear == p)Q.rear = Q.front;
    	free(p);
    	return OK;
    }
    
    Status QueueTraverse(LinkQueue Q, Status(*visit)(QueuePtr))
    {
    	QueuePtr p;
    	p = Q.front;
    	while (p->next)
    	{
    		p = p->next;
    		if (!(visit(p)))return ERROR;
    	}
    	return OK;
    }
    

    4.测试

    #include"LinkQueue.h"
    int visit(QueuePtr p) {
    	//visit函数用来输出队列
    	cout << p->data<<" ";
    	return OK;
    }
    int main() {
    	LinkQueue Q;
    	InitQueue(Q);
    	cout << "空队列初始化成功" << endl;
    	cout << "在队列中依次插入五个元素" << endl;
    	QElemType e;
    	for (int i = 0; i < 5; i++)
    	{
    		cin >> e;
    		EnQueue(Q, e);
    	}
    	cout << "输出整个队列" << endl;
    	QueueTraverse(Q,visit);
    	DeQueue(Q, e);
    	cout << endl;
    	cout << "删除队头元素,输出整个队列" << endl;
    	QueueTraverse(Q, visit);
    	cout << endl<<"清空队列" << endl;
    	ClearQueue(Q);
    	cout << "输出整个队列" << endl;
    	QueueTraverse(Q, visit);
    	cout << endl << "销毁队列,结束" << endl;
    	DetroyQueue(Q);
    	system("pause");
    	return 0;
    }
    

    结果:
    在这里插入图片描述

    展开全文
  • C++ 链队列和循环队列基本操作

    千次阅读 2017-12-21 11:23:43
    1. 用C++实现链队列基本操作 2. 用C++实现循环队列基本操作 二:链队列的实现 1. 定义数据结构和类,书写在Queue.h中 # include using namespace std; typedef int ElemType; typedef struct...

    一:目的

    1. 用C++实现链队列的基本操作

    2. 用C++实现循环队列的基本操作


    二:链队列的实现

    1. 定义数据结构和类,书写在Queue.h中
    # include <iostream>
    using namespace std;
    
    typedef int ElemType;
    
    typedef struct QNode
    {
    	ElemType data;
    	QNode *next;
    
    }QNode, *QueuePtr;      //节点
    
    //单链队列
    typedef struct
    {
    	QueuePtr front;     //队头指针
    	QueuePtr rear;		//队尾指针
    }LinkQueue;
    
    
     class MyLinkQueue
     {
     public:
    	 void InitQueue();		//初始化队列
    	 void DestroyQueue();		//销毁队列
    	 void ClearQueue();		//清空队列
    	 bool QueueEmpty();		//队列是否为空
    	 int QueueLength();		//队列长度
    	 void Enqueue(ElemType val);	//在队尾插入数据
    	 void DeQueue(ElemType & val);	//删除队头
    	 void Print();			//从头到尾打印
    
     private:
    	 LinkQueue q;
     };
    

    2. 具体实现代码在Queue.cpp中
    #include "Queue.h"
    
    //初始化队列
    void MyLinkQueue::InitQueue()
    {
    	q.front = q.rear = (QueuePtr)malloc(sizeof(QNode));
    	if(!q.front)
    	{
    		//如果分配失败
    		cout <<"初始化失败"<<endl;
    		return;
    	}
    	q.front->next = NULL;
    }	
    
    //销毁队列
    void MyLinkQueue::DestroyQueue()
    {
    	while(q.front)
    	{
    		q.rear = q.front->next;
    		free(q.front);
    		q.front = q.rear;
    	}
    }
    //在队尾插入数据
    void MyLinkQueue::Enqueue(ElemType val)
    {
    	QueuePtr ptr = (QueuePtr)malloc(sizeof(QNode));
    	if(!ptr)
    	{
    		//如果分配失败
    		cout << "节点分配失败" << endl;
    		return;
    	}
    	ptr->data = val;
    	ptr->next = NULL;
    	q.rear->next = ptr;
    	q.rear = ptr;
    }
    //删除队头,并返回当前队头的值
    void MyLinkQueue::DeQueue(ElemType & val)
    {
    	if(q.front == q.rear)
    	{
    		val = -1;
    		return;
    	}
        QueuePtr p;
        val = q.front->next->data;
        if(q.front->next == q.rear){//队列只有一个元素
            p = q.rear;
            q.rear = q.front;
            q.front->next = NULL;
        }else{
            p = q.front->next;
            q.front->next = p->next;
            p->next = NULL;
        }    
        free(p);
    }
    
    //打印
    void MyLinkQueue::Print()
    {
    	if(q.front == q.rear)
    	{
    		cout<< "队列为空" << endl;
    		return;
    	}
    	QueuePtr ptr = q.front->next;
    	while(ptr!=q.rear)
    	{
    		cout<<ptr->data<<endl;
    		ptr = ptr->next;
    	}
    	cout<<ptr->data<<endl;
    }
    
    //清空队列
    void MyLinkQueue::ClearQueue()
    {
    	DestroyQueue();
    	InitQueue();
    }
    
    
    //队列是否为空
    bool MyLinkQueue::QueueEmpty()
    {
    	if(q.front == q.rear)
    		return true;
    	else
    		return false;
    }
    //队列长度
    int MyLinkQueue:: QueueLength()
    {
    	if(q.front == q.rear)
    		return 0;
    	QueuePtr ptr = q.front;
    	int index = 0;
    	do
    	{
    		index++;
    		ptr = ptr->next;
    	}while(ptr!=q.rear);
    	return index;
    }
    3.简单测试如下
    	MyLinkQueue q;
    	bool flag = q.QueueEmpty();
    	q.InitQueue();
    	q.Enqueue(1);
    	q.Enqueue(2);
    	q.Enqueue(3);
    	q.Enqueue(4);
    	q.Enqueue(5);
    	q.Enqueue(6);
    	q.Enqueue(7);
    	int len = q.QueueLength();
    	q.Print();
    	int val;
    	q.DeQueue(val);
    	q.DeQueue(val);
    	cout <<"取出两个队头后"<<endl;
    	q.Print();
    	q.ClearQueue();
    	q.Print();
    	q.Enqueue(1);
    	q.Enqueue(2);
    	q.Enqueue(3);
    	q.Enqueue(4);
    	q.Print();

    三:循环队列的实现

    1. 定义数据结构和类,书写在Queue.h中

    # include <iostream>
    using namespace std;
    
    #define MAX_QUEUE_SIZE 100
    typedef int ElemType;
    
    typedef struct QNode
    {
    	ElemType data;
    	QNode *next;
    
    }QNode, *QueuePtr;      //节点
    
    //循环队列
     typedef struct{
    	ElemType *base;
    	int front;
    	int rear;
    }SqQueue;
    
    class CircularQueue
     {
     public:
    	 void InitQueue();			//初始化队列
    	 void DestroyQueue();		//销毁队列
    	 void ClearQueue();			//清空队列
    	 bool QueueEmpty();			//队列是否为空
    	 int QueueLength();			//队列长度
    	 void Enqueue(ElemType val);	//在队尾插入数据
    	 void DeQueue(ElemType & val);	//删除队头
    	 void Print();					//从头到尾打印
    
     private:
    	 SqQueue q;
     };
    
    
    2.具体实现在Circular_Queue.cpp中
    #include "Queue.h"
    
    //初始化队列
    void CircularQueue::InitQueue()
    {
    	q.base = (ElemType *)malloc(sizeof(ElemType) * MAX_QUEUE_SIZE);
    	if(!q.base)
    	{
    		//如果分配失败
    		cout <<"初始化失败"<<endl;
    		return;
    	}
    	q.front = q.rear = 0;
    }	
    
    //销毁队列
    void CircularQueue::DestroyQueue()
    {
    	free (q.base);
    	q.front = q.rear = 0;
    }
    //在队尾插入数据
    void CircularQueue::Enqueue(ElemType val)
    {
    	if((q.rear + 1)%MAX_QUEUE_SIZE == q.front)
    	{
    		cout << "队列已满!" << endl;
    		return;
    	}
    	q.base[q.rear] = val;
    	q.rear = (q.rear+1)%MAX_QUEUE_SIZE;
    	return;
    }
    //删除队头,并返回当前队头的值
    void CircularQueue::DeQueue(ElemType & val)
    {
    	if(q.front == q.rear)
    	{
    		cout<<"队列为空!"<<endl;
    		return;
    	}
    	val = q.base[q.front];
    	q.front = (q.front+1)%MAX_QUEUE_SIZE;
    	return;
    }
    
    //打印
    void CircularQueue::Print()
    {
    	if(q.front == q.rear)
    	{
    		cout<< "队列为空" << endl;
    		return;
    	}
    	for(int i = q.front; i < q.rear;i++)
    		cout<< q.base[i]<<endl;
    	return;
    }
    
    //清空队列
    void CircularQueue::ClearQueue()
    {
    	DestroyQueue();
    	InitQueue();
    }
    
    
    //队列是否为空
    bool CircularQueue::QueueEmpty()
    {
    	if(q.front == q.rear)
    		return true;
    	else
    		return false;
    }
    //队列长度
    int CircularQueue:: QueueLength()
    {
    	return (q.rear - q.front + MAX_QUEUE_SIZE) % MAX_QUEUE_SIZE;
    }
    3. 测试同上,只需要将MyLinkQueue改为CircularQueue即可
    展开全文
  • 优先队列基本操作

    2018-09-13 08:41:53
    一.优先队列概念 了解完队列之后我们来了解一种特殊的队列--优先队列 优先队列是一种特殊的队列,相较于队列它的特殊也是功能最强大之...优先队列声明的基本格式是: priority_queue&lt;结构类型&gt; 队...

    一.优先队列概念

    了解完队列之后我们来了解一种特殊的队列--优先队列

    优先队列是一种特殊的队列,相较于队列它的特殊也是功能最强大之处在于能自动排序。

    二.优先队列的头文件

    #include<queue>

    using namespace std; //命名空间不是头文件

    三.优先队列的声明

    优先队列声明的基本格式是: 
    priority_queue<结构类型> 队列名;

    例:

    
     
    1.  
      priority_queue <int> p; 
       
      priority_queue <double>  p;
      

      然而最常用的是以下几种

    2. priority_queue <node> p;
      //node是一个结构体
      //结构体里重载了‘<’小于符号
      priority_queue <int,vector<int>,greater<int> > p;
      //不需要#include<vector>头文件
      //注意后面两个“>”不要写在一起,“>>”是右移运算符
      priority_queue <int,vector<int>,less<int> >p;
      

      四.优先队列的基本操作

      与队列的操作基本一致

      例.queue<int> q;

      1.入队 q.push();

      2.出队 q.pop();

      3.求队列中元素个数 q.size();

      4.判断度列是否为空 q.empty();若为空返回true,否则返回false

      5.获得首元素 q.top();

      6.返回q的第一个元素  q.top();

      7.返回q的末尾元素 q.back();

      五.优先队列的排序

      默认的优先队列 priority_queue <int> q;排序是由大到小的,代码为证

      
       
    3.  
      #include<stdio.h>
      #include<queue>
      using namespace std;
      int main()
      {
          priority_queue<int> q;
          int num[5]={19,2,4,3,6};
          for(int i=0;i<5;i++)
              q.push(num[i]);
          for(int i=0;i<5;i++)
          {
              int temp=q.top();
              printf("%d ",temp);
              q.pop();
          }
          return 0;
      }
      

      默认的优先队列(结构体,重载小于)

    4. #include<stdio.h>
      #include<queue>
      using namespace std;
      struct node
      {
          int x,y;
          bool operator < (const node & a) const
          {
              return x<a.x;
          }
      }s;
      priority_queue <node> q;
      int main()
      {
          printf("读入:\n");
          for(int i=0;i<5;i++)
          {
             scanf("%d%d",&s.x,&s.y);
             q.push(s);
          }
          printf("输出:\n");
          while(!q.empty())
          {
              node temp=q.top();
              printf("(%d,%d) ",temp.x,temp.y);
              q.pop();
          }
          return 0;
      }
      

      接下来是less和greater优先队列

      以int为例,先声明:

    由此可见

    less是从大到小,greater是从小到大

    展开全文
  • 栈与队列基本操作的编程实现 二、实验要求 栈和队列基本操作的编程实现,掌握栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现,也可以进一步编程实现实用的功能等操作,具体编程存储结构要求是顺序存储...
  • 队列基本操作总结

    千次阅读 2018-08-13 20:39:11
    定义数据结构 ...//定义队列结点类型 typedef struct QueueNode { struct QueueNode* _next; DataType _data; }QueueNode; //定义队列类型 typedef struct Queue { QueueNode* front;//队头 QueueNo...
  • 首先了解一下队列队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行...
  • 队列与栈的结构类似,但不同的是队列的出队操作是在队首元素进行的删除操作基本原则是先进先出。
  • Python实现队列基本操作

    千次阅读 2019-08-09 11:23:32
    class Queue: #初始化队列 def __init__(self): self.items=[] #加入队列 def enqueue(self,item): self.items.append(item) #出队列 def dequeue(self): return self.items....
  • 循环队列:把头尾相接的顺序存储结构称为循环队列
  • 循环队列
  • 静态队列、循环队列基本操作

    千次阅读 2012-08-02 22:43:33
    //静态队列,循环队列 typedef struct Queue{ int * base; int front;//队首 int rear;//队尾 int len;//队列长度 }QUEUE,*PQUEUE; void init(PQUEUE);//初始化 void in(PQUEUE);//入队 void out(PQUEUE,...
  • 循环队列基本操作

    千次阅读 2011-05-15 22:20:00
    #include<stdio.h>//循环队列的存储结构 #include<stdlib.h><br />#define OVERFLOW -2 #define maxqsize 100 typedef int QElemType; typedef struct {  QElemType *base;  ...
  • c语言队列基本操作代码

    千次阅读 2014-03-22 22:15:26
    为了打印binary tree,要使用队列,所以先写个程序测试下 #include #include typedef struct _node { int value; struct _node *next; }Node; typedef struct _Queue { Node *head; Node *tail; }Queue; ...
  • 存储在其中的队列称为循环队列(Circular Queue)。这种循环队列可以以单链表的方式来在实际编程应用中来实现。 循环队列中,由于入队时尾指针向前追赶头指针;出队时头指针向前追赶尾指针,造成队空和队满时头尾...
  • 队列基本操作实现(c语言)

    千次阅读 2018-12-18 09:31:34
    if(q->rear==p)//如果队列只有一个元素,变成空队列 { q->rear=q->front; } *e=p->data; return 1; } return 0; } //获取队头元素 int getQueueHead(linkQueue q) { if(q->rear!=q->front) { linkQNode...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 424,768
精华内容 169,907
关键字:

队列的基本操作