精华内容
下载资源
问答
  • 数据结构中循环队列基本操作,分享一下,欢迎大家批评指正!
  • 数据结构(C语言)-循环队列基本操作

    千次阅读 2020-10-19 23:52:58
    文章首发于 2020-10-15 知乎文章:数据结构(C语言)-循环队列基本操作 作者:落雨湿红尘(也是我o) 01.队列介绍 队列是一种先进先出(first in first out,FIFO)的线性表,是一种常用的数据结构。 它只允许在表的...

    文章首发于 2020-10-15 知乎文章:数据结构(C语言)-循环队列基本操作

    作者:落雨湿红尘(也是我o)

     

    导语

     

    队列是一种先进先出(first in first out,FIFO)的线性表,是一种常用的数据结构。

    它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。队列中没有元素时,称为空队列。

                                                                                                        图1 队列

     

    队列有很多种,按照存储结构划分,有链式队列,循环队列,单向队列,双端队列。实现队列的方式也有很多种,如基于链式存储结构的链接队列(又称链队列),基于顺序存储结构的队列。

    本文介绍基于数组(一种顺序存储结构)的循环队列的实现和一些基本操作,并用代码的形式讲解

     

    一些概念

     

    队列的顺序存储结构和顺序栈类似

    在队列的顺序存储结构中,除了用一组地址连续的存储单元依次存放从队列头到队列尾的元素之外,还需要设置头尾两个指针front和rear,分别指示队列头元素及队尾元素的位置

    我们规定

    • 初始化建立空队列时,令front=rear=0
    • 每当插入新的队尾元素时,“尾指针增1”
    • 每当删除队头元素时,“头指针增1”
    • 在非空队列中,头指针始终指向队列头元素,尾指针始终指向队列尾元素的下一个位置

                                           图2 队列的顺序存储结构

     

    在入队和出队的操作中,头尾指针只增加不减小,致使被删除元素的空间永远无法重新利用,因此,尽管队列中实际的元素个数远远小于向量空间的规模,但也可能由于尾指针巳超出向量空间的上界而不能做入队操作,该现象称为假溢出

    解决办法:将顺序队列臆造为一个环状的空间,称之为循环队列

     

    循环队列

    循环队列的结构如下图所示

                                       

                                                                                       图2 循环队列

     

    以下代码,实现了一个可以保存学生学号(最长12位的字符串)循环队列,基于数组这种顺序存储结构,,实现了它的初始化,出队,入队,队列销毁的操作

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #define OK 1
    #define NO 0
    #define MAXSIZE 100
    
    //循环队列结构
    typedef struct LoopQueue{
    	char* base[MAXSIZE];//数据域由一个char*数组构成
    	int front;//队头索引,指向队列第一个数据所在位置
    	int rear; //队尾索引,指向队列最后一个数据后一个位置
    }LoopQueue; 
    
    //循环队列初始化。该循环队列基于数组,因此一旦声明一个LoopQueue变量
    //其内部的base数组空间便自动分配,不需要自己分配
    //只需初始化队头和队尾索引
    int initLQueue(LoopQueue *Q){
    	Q->front = Q->rear =0;
    	return OK; 
    }
    
    //返回长度
    int getLenth(LoopQueue *Q) {
    	return (Q->rear - Q->front + MAXSIZE)%MAXSIZE;
    }
    
    //插入元素
    int insertLQueue(LoopQueue *Q){
    	
            //这里牺牲掉了一个储存位置,用rear+1来和队头索引相比较以判断是否为满,
            //是为了和队列判空条件相区分
           //判断队列是否 满,如果已满,返回NO
    	if((Q->rear+1)%MAXSIZE == Q->front) return NO;
    	char * stuId = (char*)malloc(sizeof(12));
    	scanf("%s",stuId) ;
    	Q->base[Q->rear] = stuId;
    	Q->rear = (Q->rear+1)%MAXSIZE; 
    	return  OK;
    } 
    
    //元素出队
    char* outLQueue(LoopQueue *Q){
    	//判断队列是否为空 
    	if(Q->rear ==Q->front) return NULL;
    	char * data_return = Q->base[Q->front];
    	Q->front = (Q->front+1)%MAXSIZE; 
    	return data_return; 
    } 
    
    //销毁队列,也是由于该循环队列基于数组,不需要分配内存
    //只需重置队头和队尾索引即可
    int destroyLQueue(LoopQueue *Q){
    	Q->front = Q->rear=0; 
    	return OK; 
    }
     
    int main(){
    	
    	// 初始化队列 	
    	LoopQueue Q;
    
    	//定义一个选择变量 
    	int choice;
    	
    	//元素插入个数 
    	int num; 
    	
    	//出队返回值
    	char* back; 
    	do{	
    		printf("===========循环队列操作==========\n");
    		printf("1.初始化循环队列\n");
    		printf("2.元素入队\n");
    		printf("3.元素出队\n");
    		printf("4.销毁队列\n");
    		printf("0.退出\n");
    		printf("=====================\n");
    		printf("请输入您的选择:");
    		scanf("%d",&choice);
    			switch(choice){
    				case 1:
    					initLQueue(&Q)?printf("------------\n -->> 循环队列初始化成功\n------------\n"):printf("------------\n -->> 循环队列初始化失败\n------------\n");
    					break;
    				case 2:
    					
    				printf("请输入插入元素个数:");
    				scanf("%d",&num);
    				int i;
        			for(i=0;i<num;i++){	
    					printf(" 请输入第%d个学生的学号:",i+1);			  								      
    					if(!insertLQueue(&Q))printf("------------\n-->> 第%d元素入队失败\n",i+1);
    				} 
    				
    					break;
    				case 3:
    					back = outLQueue(&Q);
    					back? printf("------------\n 元素: %s 出队,还剩%d个元素\n",back,getLenth(&Q)):printf("------------\n队列为空,无法出队!\n"); 
    	                free(back);	//回收内存,防止内存泄露(感谢评论区朋友提醒)			
    					break;
    				case 4:
    					destroyLQueue(&Q)?printf("------------\n队列销毁成功!\n"):printf("------------\n队列销毁失败!\n");
    					break;
    				case 0:
    					printf("\n-->> 退出\n"); 
    					exit(0);
    					break;	
    				default:
    				 break; 
    			}
    	}while(choice);
    	
    	
    }

     

    以上代码经过调试,我自认为没有问题(鄙人才疏学浅,欢迎指正)

    如果读者朋友们有疑问和更正,欢迎评论区补充和探讨

    展开全文
  • 主要的功能:1)循环队列的初始化 2)求循环队列的长度 3)循环队列的插入删除操作 4) 判断循环队列是否为空,是否已经满了 5)遍历循环队列 杨辉三角形
  • C++ 链队列和循环队列基本操作

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

    一:目的

    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即可
    展开全文
  • 循环队列其实是为了解决顺序栈的假溢出。设队列大小是M。 这里特别提出一点就是计算队列长度 (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE; 此处说明原因,因为此处为循环队列。.../* 循环队列基本操...

    在这里插入图片描述
    循环队列其实是为了解决顺序栈的假溢出。设队列大小是M。
    在这里插入图片描述
    这里特别提出一点就是计算队列长度
    (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
    此处说明原因,因为此处为循环队列。
    因为循环队列中,当Q.rear的值小于Q.front时,他们的差是负数要加上队列最大长度才是队列的长度,而如果他们的差大于0再加上最大长度时求余可以得到队列的长度。

    /* 循环队列基本操作 */
    
    #include <iostream>
    #include <fstream>
    using namespace std;
    
    #define MAXQSIZE 1000
    #define OK 1
    #define ERROR 0
    #define OVERFLOW -1
    
    typedef char QElemType;
    typedef char SElemType;
    typedef int Status;
    
    typedef struct {
    	// 初始化动态分配内存空间
    	QElemType *base;
    	int front;		// 队头指针
    	int rear;		// 队尾指针
    }SqQueue;
    
    // 初始化循环队列
    Status Init_Queue(SqQueue &Q) {		// 构造一个空队列Q
    	Q.base = new QElemType[MAXQSIZE];
    	if (!Q.base)
    		exit(OVERFLOW);			// 存储空间分配失败
    	Q.front = Q.rear = 0;		// 队头指针队尾指针设置为0,队列是为空
    
    	return OK;
    }
    
    // 求循环队列的长度
    int Calc_QueueLength(SqQueue Q) { // 返回Q的元素个数,即队列的长度
    	return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
    }
    
    // 获取循环队列的人头元素
    SElemType GetHead_Queue(SqQueue Q) {  // 返回Q的队头元素,不修改队头指针
    	if (Q.front != Q.rear)		// 非空
    		return Q.base[Q.front];		// 返回队头元素的值,队头指针不变
    }
    
    //  入队
    Status Entry_Queue(SqQueue &Q, QElemType e) {	// 插入元素e为Q这个队列队尾的元素
    	if ((Q.rear + 1) % MAXQSIZE == Q.front)		// 尾队指针在循环意义上加1后等于头指针,表明队列已经满
    		return ERROR;
    	Q.base[Q.rear] = e;		// 新元素值e插入队尾
    	Q.rear = (Q.rear + 1) % MAXQSIZE;		// 队尾指针加1
    
    	return OK;
    }
    
    //  出队 
    Status Output_Queue(SqQueue &Q, QElemType &e) {  // 删除Q队列的头元素,用e返回要删除元素的值 
    	if (Q.rear == Q.front)		// 队列为空
    		return ERROR;
    	e = Q.base[Q.front];		// 保存队头元素 
    	Q.front = (Q.front + 1) % MAXQSIZE;		// 队头指针加1
    
    	return OK;
    
    }
    
    int main()
    {
    	int choose, flag = 0;
    	SqQueue Q;
    	QElemType e, j;
    
    	cout << " 1.初始化队列  2.入队  3.读取队列头元素  4.出队  0.退出\n\n" << endl;
    	choose = -1;
    	while (choose != 0)
    	{
    		cout << "请选择队列的操作项[0-4]:";
    		cin >> choose;
    		switch (choose) {
    		case 1:
    			if (Init_Queue(Q)) {
    				flag = 1;
    				cout << "循环队列初始化成功." << endl << endl;
    			}
    			else
    			{
    				cout << "循环队列初始化失败." << endl << endl;
    			}
    			break;
    			
    		case 2:
    		{
    			fstream file;
    			file.open("CycleQNode.txt");
    			if (!file)
    			{
    				cout << "打开文件失败." << endl << endl << endl;
    				return  ERROR;
    			}
    
    			if (flag) {
    				flag = 1;
    				cout << "队列入队元素依次为:\n";
    				while (!file.eof()) {
    					file >> j;
    					if (file.fail())
    					{
    						break;
    					}
    					else
    					{
    						Entry_Queue(Q, j);
    						cout << j << "  ";
    					}
    				}
    				cout << endl << endl;
    			}
    			else
    				cout << "队列未创建成功,请重新检测." << endl << endl;
    			file.close();			
    		}
    			break;
    
    		case 3:
    			if (flag != -1 && flag != 0)
    				cout << "队列头部元素为:\n" << GetHead_Queue(Q) << endl << endl;
    			else
    				cout << "队列中无此数据元素,请重新检测." << endl << endl;
    			break;
    			
    		case 4:
    			cout << "队列依次弹出的数据元素为:" << endl;
    			while (Output_Queue(Q, e)) {
    				flag = -1;
    				cout << e << "  ";
    			}
    			cout << endl << endl;
    			break;
    		}
    	}
    
    	return 0;
    }
    
    展开全文
  • 循环队列基本操作的实现(Java)

    千次阅读 2018-01-26 19:16:36
    循环队列解决了,队列“假溢出”现象,提高了空间的利用效率。队列有两个指针域front和rear。 队列主要有以下操作: (1)空队列时front=rear;入队列时,把数据放到rear所指的位置,然后rear向下移动一个 (2)...

    循环队列解决了,队列“假溢出”现象,提高了空间的利用效率。队列有两个指针域front和rear。
    队列主要有以下操作:
    (1)空队列时front=rear;入队列时,把数据放到rear所指的位置,然后rear向下移动一个
    (2)当rear在向下移动一个就和front指向同一块区域(即rear+1=front)时,队列就已经装满了
    (3)出队列时,获取并返回front所指的区域所存的数据,front向下移动一个,当front和rear指向同一块区域(即front=rear)时,队列为空
    例如:
    这里写图片描述
    这里写图片描述
    (f)图中p进入队列之后,队列已满,则s和t就进入队列失败。

    接下来看代码
    先封装一个queue类

    package com.lqf.queue;
    
    import java.util.Arrays;
    
    public class Queue {
        int front;
        int rear;
        char arr[];
        public int getFront() {
            return front;
        }
        public void setFront(int front) {
            this.front = front;
        }
        public int getRear() {
            return rear;
        }
        public void setRear(int rear) {
            this.rear = rear;
        }
        public char[] getArr() {
            return arr;
        }
        public void setArr(char[] arr) {
            this.arr = arr;
        }
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + Arrays.hashCode(arr);
            result = prime * result + front;
            result = prime * result + rear;
            return result;
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Queue other = (Queue) obj;
            if (!Arrays.equals(arr, other.arr))
                return false;
            if (front != other.front)
                return false;
            if (rear != other.rear)
                return false;
            return true;
        }
        public Queue(int front, int rear, char[] arr) {
            super();
            this.front = front;
            this.rear = rear;
            this.arr = arr;
        }
        public Queue() {
            super();
        }
        @Override
        public String toString() {
            return "Queue [front=" + front + ", rear=" + rear + ", arr=" + Arrays.toString(arr) + "]";
        }
    
    }
    

    再建立一个操作类

    public class Op {
        private static int n = 5;
    
        // 遍历
        public int traverse(Queue q) {
            int count = 0;
    
            if (q.front != q.rear) {//栈中有元素
                int p = q.front;// 循环变量
                while (p % n != q.rear) {//从队首遍历到队尾
                    p = (p + 1) % n;
                    count++;
                }
            }
    
            return count;
        }
    
        // 获取队首元素
        public char getHead(Queue q) {
            char e = 0;
    
            if ((q.front + 1) % n != q.rear) {//栈中还有元素
                e = q.arr[q.front];
                System.out.println("success.");
            } else {//栈空
                System.out.println("the queue is empty.");
            }
    
            return e;
        }
    
        // 出队列并返回队首元素
        public char dequeue(Queue q) {
            char e = 0;
    
            if (q.front != q.rear) {//栈中还有元素
                e = q.arr[q.front];
                q.front = (q.front + 1) % n;//front向下移动一个
                System.out.println("success.");
            } else {//栈空
                System.out.println("the queue is empty.");
            }
    
            return e;
        }
    
        // 入队列
        public void enqueue(Queue q) {
            if ((q.rear + 1) % n != q.front) {//栈中还有空间
                System.out.print("please enter the data:");
                Scanner sc = new Scanner(System.in);
    
                q.arr[q.rear] = sc.next().charAt(0);
                q.rear = (q.rear + 1) % n;//rear向下走一个
                System.out.println("success.");
            } else {//栈满
                System.out.println("the queue is full.");
            }
        }
    
        // 初始化
        public void initialize(Queue q) {
            q.arr = new char[n];//初始化数据域
            q.front = q.rear = 0;
            System.out.println("success.");
        }
    
    }
    

    对方法进行测试

    public class Test {
    
        public static void main(String[] args) {
            int a;// 操作码
            Queue Q = new Queue();
            Op op = new Op();
    
            Scanner sc = new Scanner(System.in);
            System.out.println("1.initialize");
            System.out.println("2.enqueue");
            System.out.println("3.dequeue");
            System.out.println("5.traverse");
            while (true) {
                System.out.print("please enter operation code:");
                a = sc.nextInt();
                switch (a) {
                case 1:
                    op.initialize(Q);
                    break;
                case 2:
                    op.enqueue(Q);
                    break;
                case 3:
                    char b = op.dequeue(Q);
                    System.out.println(b);
                    break;
                case 4:
                    char c = op.getHead(Q);
                    System.out.println(c);
                    break;
                case 5:
                    int count = op.traverse(Q);
                    System.out.println(count);
                    break;
                default:
                    System.out.println("error.");
                    break;
                }
            }
        }
    
    }

    空间为n,只能存n-1个数据
    这里以最开始的例子为例,运行一下程序(注:程序中的空间个数n=5,比图中的空间少一个)
    这里写图片描述
    这里写图片描述

    展开全文
  • 实现循环队列,适合数据结构的小白~
  • 1.任意输入队列长度和队列中的元素值,构造一个顺序循环队列,对其进行清空、插入新元素、返回队头元素以及删除队头元素操作。 2.约瑟夫环的实现:设有n个人围坐在圆桌周围,现从某个位置 i 上的人开始报数,数到 ...
  • 循环队列基本操作

    2018-03-24 15:53:46
    文章类型为学习笔记,都是基本操作......直接上代码......#include&lt;stdio.h&gt; #include&lt;malloc.h&gt; /*队列的最大长度*/ #define MAX_QUEUE_SIZE 6 /*循环队列类型*/ typedef struct { ...
  • 使用c++模板类方式实现循环队列,可存储任意类型对象长度数据,按照所需长度进行出栈获取数据,加入互斥锁可多线程使用。
  • 循环队列基本操作和简单实现

    千次阅读 多人点赞 2020-01-14 15:12:23
    文章目录一、循环队列 一、循环队列 队列的顺序表示和实现 队列的顺序表示-用一维数组base[MAXQSIZE] #define MAXQSIZE 100 //最大队列长 typedef struct{ Qelem *base; //初始化的动态分配存储空间 int ...
  • 循环队列基本操作C语言详解

    千次阅读 2020-03-24 14:54:56
    循环队列:把头尾相接的顺序存储结构称为循环队列
  • 循环队列基本操作

    千次阅读 多人点赞 2019-01-25 16:42:04
    为了解决顺序队列假溢出的问题,我们采用的方案是少用一个元素空间,此时...一、循环队列的定义: #include&amp;amp;lt;stdio.h&amp;amp;gt; #include&amp;amp;lt;stdlib.h&amp;amp;gt; #includ...
  • 熟悉循环队列的存储结构,并且熟悉掌握循环队列的初始化、入队、出队、获取队头元素以及获取队的长度等基本操作。 二、实验内容 实现循环队列基本操作: 1)构造空的顺序栈(顺序循环队列) 2)将五个元素入栈(队...
  • 代码实现: #include<stdio.h> #include<stdlib.h> #define MAXQSIZE 100 #define OVERFLOW -2 #define FALSE 0 #define OK 1 typedef int Status; typedef float QElemType;...//创建空队列 Status In
  • 存储在其中的队列称为循环队列(Circular Queue)。这种循环队列可以以单链表的方式来在实际编程应用中来实现。 循环队列中,由于入队时尾指针向前追赶头指针;出队时头指针向前追赶尾指针,造成队空和队满时头尾...
  • 与栈不同 队列基本原则: 先入先出 后入后出 约定一个下标(rear)指向当前入队元素要插入的下标 即最后一个入队元素下标的下一位 即 如果要加入新的元素x 执行elem[s->rear]=x 一个下标(front)指向最先出队的...
  • 循环队列基本操作-C语言

    万次阅读 多人点赞 2019-06-24 11:54:45
    循环队列基本操作一、循环队列二、循环队列的理解 一、循环队列 为充分利用向量空间,克服上述“假溢出”现象的方法是:将为队列分配的向量空间看成为一个首尾相接的圆环,并称这种队列为循环队列(Circular Queue)...
  • 本文总结整理了严蔚敏老师数据结构的9种循环队列基本操作,包括队列的初始化、入队、出队、判空、求队长等。
  • 实现循环队列基本操作: #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;iostream&gt; using namespace std; #define MAXQSIZE 100 #define OK 1 #define ERROR 0 #...
  • 循环队列基本操作C/C++代码实现

    千次阅读 2020-06-03 18:27:51
    循环队列的结构: 在非空队列中,头指针始终指向队列头元素,而尾指针始终指向队列尾元素的下一个位置,阴影部分表示队列: 另外通过取模,头指针和尾指针就可以在顺序表空间内以头尾衔接的方式 ”循环" 移动。...
  • Q): 初始化队列Q QueueEmpty(): 判断队列是否为空 EnQueue(e): 将元素e放入队尾 DeQueue(e): 移走队头元素,由e带回该元素的值 GetFront(): 获取队头元素的值,但不从队列中移走该元素 Length(): 计算并返回...
  • 循环队列基本操作(C语言)

    千次阅读 2019-09-04 20:56:03
    要点:循环队列在创建时就要规定有多少块连续的存储单元。在队尾添加元素,在队头删除元素。以front和rear标志队头队尾,初始时front和rear都为0,入队rear加一,出队front加一。且rear的位置指向队尾元素的下一个...
  • 实现循环队列基本操作

    千次阅读 2017-04-21 12:34:36
    //因为是循环队列所以得模它的容量 } } void Pop() { if(!Empty())//队列不空 { _count--; _front = (_front+1)%_capacity; } } T& Front() { return _pData[_front]; } const T& Front()...
  • 循环队列基本操作和实现循环队列基本操作和实现
  • 循环队列
  • 循环队列基本操作的c算法实现做了详细的编写,运行通过,里面还附有验证程序,保证算法的正确性。里面有的是动态申请空间的结构,克服了浪费空间的缺点。
  • 顺序循环队列基本操作

    万次阅读 2017-10-17 15:35:59
    顺序循环队列是一种常见数据结构,所以今天我特地整理了一下,后面还会补上链表队列的实现,见我的博客数据结构栏目 1.先上几个头文件部分,里面是一些基本的定义 #include //source.h #include using ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 175,507
精华内容 70,202
关键字:

循环队列的基本操作