精华内容
下载资源
问答
  • C语言实现数组队列
    2021-05-23 00:57:50

    复习C语言数组队列

    #include

    #include

    #define MAX 1000

    typedef struct Queues{

    int date[MAX];

    int front;

    int rear;

    }Queue;

    Queue queue;

    void CreatQueue(){

    queue.front = queue.rear = 0;

    }

    void PushQueue(int value){

    if((queue.rear+1)%MAX!=queue.front){

    queue.rear = (queue.rear+1)%MAX;

    queue.date[queue.rear] = value;

    }

    }

    int PopQueue(){

    if(queue.front!=queue.rear){

    int value = queue.date[queue.front];

    queue.front = (queue.front+1)%MAX;

    return value;

    }

    return 0;

    }

    int main()

    {

    int i;

    for(i = 1 ; i<=5 ; i++){

    PushQueue(i);

    }

    for(i = 1 ; i<=5 ; i++){

    printf("%d",PopQueue());

    }

    return 0;

    }

    原文:http://www.cnblogs.com/CloudStrife/p/7211823.html

    更多相关内容
  • 普通队列 1)将尾指针往后移:rear+1,当front==rear【空】 2)若尾指针rear小于队列的最大下标maxSize-1,则将数据存入rear所指的数中组元素中,否则无法存入数据。rear==maxSize-1[队列满] 环形队列 1)front变量的...
  • 文章目录自定义队列数组队列简述: 数组队列 简述: 队列本身是有序列表,若使用数组的结构来存储队列的数据,则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。 因为队列的输出、输入是分别从前后端来...

    自定义队列

    数组队列

    简述:

    队列本身是有序列表,若使用数组的结构来存储队列的数据,则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。
    因为队列的输出、输入是分别从前后端来处理,因此需要两个变量 front及 rear分别记录队列前后端的下标,front 会随着数据输出而改变,而 rear则是随着数据输入而改变,如图所示:

    在这里插入图片描述

    1. 自定义简单数组对列(有问题,不能重复使用)
    package com.njau.queue;
    
    import java.util.Scanner;
    
    /**
     * @author 张文军
     * @Description:arrayQueue数组队列
     * @Company:南京农业大学工学院
     * @version:1.0
     * @date 2019/8/249:06
     */
    public class ArrayQueue {
        int maxiSize;
        int front;
        int rear;
        int[] arr;
    
        public ArrayQueue(int maxiSize) {
            this.maxiSize = maxiSize;
            arr = new int[maxiSize];
            front = -1;
            rear = -1;
    
        }
    
        public Boolean isFull() {
            return rear == maxiSize - 1;
        }
    
        public boolean isEmpty() {
            return rear == front;
        }
    
        public void addQueue(int n) {
            if (isFull()) {
                System.out.println("queue hase full !");
                return;
            } else {
                arr[++rear] = n;
            }
        }
    
        public int getQueue() {
            if (isEmpty()) {
                throw new RuntimeException("queue is empty !");
            } else {
                return arr[++front];
            }
        }
    
        public void showQueue() {
            if (!isEmpty()) {
                for (int i = 0; i < arr.length; i++) {
                    System.out.printf("arr[%d] = %d\n", i, arr[i]);
                }
            } else {
                System.out.println("queue is empty !");
            }
        }
    
        public int getQueueHead() {
            if (isEmpty()) {
                throw new RuntimeException("queue is empty!");
            } else {
                return arr[front + 1];
            }
        }
    
    
    	/**
    	*  测试
    	*/
        public static void main(String[] args) {
            ArrayQueue queue = new ArrayQueue(3);
            Scanner scanner = new Scanner(System.in);
            Boolean loop = true;
            while (loop) {
                System.out.println("s 展示");
                System.out.println("a 添加");
                System.out.println("g 取数据");
                System.out.println("h 显示头数据");
                System.out.println("e 退出");
                char key = scanner.next().charAt(0);
                switch (key) {
                    case 's':
                        queue.showQueue();
                        break;
                    case 'a':
                        System.out.println("请输入数据:");
                        int i = scanner.nextInt();
                        queue.addQueue(i);
                        break;
                    case 'g':
                        try {
                            int queue1 = queue.getQueue();
                            System.out.println("取出的数据是:" + queue1);
                        } catch (Exception e) {
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'h':
                        try {
                            int queueHead = queue.getQueueHead();
                            System.out.println("头数据:" + queueHead);
                        } catch (Exception e) {
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'e':
                        loop = false;
                        break;
                    default:
                        break;
                }
            }
            System.out.println("exit !");
    
        }
    
    }
    

    数组环形队列

    上面简介和用数组简单实现了一下队列,但这种队列依然存在问题,问题就是用数组简单实现的队列会存在假溢出现象(即:在数据退出队列时,虽然数据未满,但是队列的 rear 已经是数组的大小,即显示已满。故不能继续插入数据 ),这样会极大的降低了数组的利用,所以,在这里我将会用数组实现一个环形队列,以解决这种问题。

    • 首先在这里,声明了一个容量大小为8的数组,并标出了索引0-7,然后使用front和 rear 分别来表示队列的,队首和队尾;在下图中,front 和 rear 的位置一开始都指向是了索引0的位置,这意味着当front == rear 的时候 队列为空 ,务必牢记这一点,以便区分后面介绍队列快满时的临界条件
      在这里插入图片描述

    • front:表示队列队首,始终指向队列中的第一个元素(当队列空时,front指向索引为0的位置)

    • rear :表示队列队尾,始终指向队列中的最后一个元素的下一个位置

    • 元素入队,维护rear 的位置,进行rear ++操作

    • 元素出队,维护front的位置,进行front++操作

    按照上面的front和rear的意思,对队列的维护即对是简单的++操作,即:入队就是将rear++,front不变,出队就是front++,rear不变。
    即如下图所示:
    在这里插入图片描述
    然而,如果再向后面添加,即当出现
    在这里插入图片描述
    即当rear指向数组的最后,而且队列也已经有元素出队时,应为rear不能再向后移动,所以虽然数组有空的空间,但却不能插入数据,此时就出现了数组假溢出现象。然而,如果rear的位置用(rear+1)% maxSize ,则就会避免出现这种情况,即我们将现在的数组看成是一个环,当rear=front=0时,数组为空,插入一条数据,rear = (rear+1 )%maxSize = 1%8= 1; 当队列上图情况时,即rear已经是移动到数组的最后一个位置,而且有数据已经出队时,这时插入数据时,rear = (rear+1 )% maxSize = (7+1)%8 = 0,即循环到了下一个位置。同理,front的位置决定也是:front= (front+1)%maxSize,在这种情况下,必须要牺牲一个数组空间来(用于方便判断),而且判断队列是否已满的条件是rear==(front+1)%maxSize,为空rear==front ==0;

    代码实现如下:

    package com.njau.queue;
    
    /**
     * @author 张文军
     * @Description:数组循环队列
     * @Company:南京农业大学工学院
     * @version:1.0
     * @date 2019/9/23:42
     */
    public class ArrayCycleQueue {
        /**
         * 数组大小
         */
        int maxiSize;
        /**
         * 指向队列的头元素
         */
        int front;
        /**
         * 指向队列的最后一个元素的下一个元素
         */
        int rear;
        /**
         * 数组
         */
        int[] arr;
    
        public ArrayCycleQueue(int maxiSize) {
            this.maxiSize = maxiSize;
            arr = new int[maxiSize];
            front = 0;
            rear = 0;
    
        }
    
        public Boolean isFull() {
            return front == (rear + 1) % maxiSize;
        }
    
        public boolean isEmpty() {
            return rear == front;
        }
    
        public void addQueue(int n) {
            if (isFull()) {
                System.out.println("queue is full !");
                return;
            } else {
                arr[rear] = n;
                rear = (rear + 1) % maxiSize;
            }
        }
    
        public int getQueue() {
            if (isEmpty()) {
                throw new RuntimeException("queue is empty !");
            } else {
                int popData = arr[front];
                front = (front + 1) % maxiSize;
                return popData;
            }
        }
    
        public void showQueue() {
            if (!isEmpty()) {
                for (int i = 0; i < arr.length; i++) {
                    System.out.printf("arr[%d] = %d\n", i, arr[i]);
                }
            } else {
                System.out.println("queue is empty !");
            }
        }
    
        public int getQueueHead() {
            if (isEmpty()) {
                throw new RuntimeException("queue is empty!");
            } else {
                return arr[front];
            }
        }
    
    }
    

    测试:

        public static void main(String[] args) {
            ArrayCycleQueue queue = new ArrayCycleQueue(3);
            Scanner scanner = new Scanner(System.in);
            Boolean loop = true;
            while (loop) {
                System.out.println("s 展示");
                System.out.println("a 添加");
                System.out.println("g 取数据");
                System.out.println("h 显示头数据");
                System.out.println("e 退出");
                char key = scanner.next().charAt(0);
                switch (key) {
                    case 's':
                        queue.showQueue();
                        break;
                    case 'a':
                        System.out.println("请输入数据:");
                        int i = scanner.nextInt();
                        queue.addQueue(i);
                        break;
                    case 'g':
                        try {
                            int queue1 = queue.getQueue();
                            System.out.println("取出的数据是:" + queue1);
                        } catch (Exception e) {
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'h':
                        try {
                            int queueHead = queue.getQueueHead();
                            System.out.println("头数据:" + queueHead);
                        } catch (Exception e) {
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'e':
                        loop = false;
                        break;
                    default:
                        break;
                }
            }
            System.out.println("exit !");
    
        }
    
    展开全文
  • 数组队列及循环队列

    2019-10-03 16:02:53
    java数据结构之----数组队列及循环队列 数据结构与算法学习的第二篇 什么时候需要用到队列 队列在实际开发过程中运用的非常广泛,由于我也是学习基础,还没有开发过什么项目,所以用到时候就知道了 什么是队列 ...

    java数据结构之----数组队列及循环队列

    数据结构与算法学习的第二篇

    什么时候需要用到队列

    队列在实际开发过程中运用的非常广泛,由于我也是学习基础,还没有开发过什么项目,所以用到时候就知道了

    什么是队列

    • 队列是一个有序列表,可以用数组或者链表来实现
    • 队列遵守先入先出的原则

    联系实际场景

    可以把一个队列的存入,读取数据的过程看成在银行里面排队办理业务,进银行,取号,叫号,办理业务,出银行这几个过程。

    具体图示

    在这里插入图片描述

    实现思路

    由上面的图示,可以知道数组队列需要以下几个属性来完成模拟队列的实现:

    基本属性

    • maxSize:表示队列的最大存储容量,也就是数组的大小
    • front:队头属性
    • rear:队尾属性
    • arrQueue:模拟队列的数组

    实现过程

    1. 队列的输入和输出是由队头和队尾属性控制的,因此由front和rear分别记录下队列的前后端下标
    2. 当front 的下标志值等于rear的下标值时,队列为空
    3. 当rear 的值等于 maxSize - 1时队列为满队列
    4. 加入数据时队尾的rear增加1
    5. 输出出队时队列的front减少1

    实现上述方法需要创建的方法

    • 判断队列是否是满队列的方法 isFull()
    • 判断队列是否为空队列的方法 isEmpty()
    • 增加数据的方法addQueue(),注意在增加数据时需要判断队列是否是满队列,是满队列的话数据增加不了
    • 获取队列数据的方法getQueue(),注意获取队列数据时需要判断队列是否为空队列,不然会产生错误
    • 显示队列中数据的方法 listQueue()
    • 获取队列队头数据的方法 getHead()

    代码实现

    
    		//测试队列  
    		ArrayQueue queue = new ArrayQueue(3);
    		char key = ' '; //用于接收用户输入
    		Scanner scanner = new Scanner(System.in);
    		
    		//制作一个菜单
    		boolean loop = true;
    		while(loop) {
    			System.out.println("s(show):显示队列");
    			System.out.println("e(exit):退出队列");
    			System.out.println("a(add):添加数据到队列中");
    			System.out.println("g(get):从队列中取出数据");
    			System.out.println("h(head):获取队列的头数据");
    			System.out.println();
    			
    			key = scanner.next().charAt(0); //表示接收用户输入的数据
    			switch (key) {
    			case 's': //展示队列中的数据
    				queue.listQueue();
    				break;
    			case 'e': //退出程序
    				scanner.close();
    				System.out.println("成功退出队列!");
    				break;
    			case 'a': //数据进队
    				System.out.println("请输入一个数据:");
    				int value = scanner.nextInt();
    				queue.addQueue(value);
    				break;
    			case 'g': //数据出队
    				try {
    					int res = queue.getQueue();
    					System.out.printf("取出的数据是:%d\n",res);
    					break;
    				} catch (Exception e) {
    					// TODO: handle exception
    					System.out.println(e.getMessage());
    				}
    			case 'h': //显示队头数据
    				try {
    					int res = queue.headShow();
    					System.out.printf("队头数据是:%d",res);
    					System.out.println();
    					break;
    				} catch (Exception e) {
    					// TODO: handle exception
    					System.out.println(e.getMessage());
    				}
    			default:
    				break;
    			}
    		}
    		
    		System.out.println("程序已退出");
    
    	} 
    
    }
    
    /**
     * 1.使用数组模拟对列——编写一个 ArrayQueue 类
     */
    class ArrayQueue{
    	private int maxSize; //用于表示数组的最大容量
    	private int front;  //队列的头指针
    	private int rear;	//队列的尾指针
    	private int []arrQueue; //用于存放数据的数组,模拟队列
    	
    	//用于创建对列的构造器
    	public ArrayQueue(int n) {  //给各个属性初始化
    		maxSize = n;
    		front = -1; //队头指向数组第一个位置的前一个
    		rear = -1;	//队尾指向数组的前一个位置
    		arrQueue = new int[n]; //设置数组队列的大小
    	}
    	
    	//判断队列是否满 
    	//队列满的条件是 rear = maxSize -1; 因为数组的下标是从零开始的
    	public boolean isFull() {
    		return rear == maxSize -1;
    	}
    	
    	//判断队列是否为空
    	//队列为空的条件是 front == rear
    	public boolean isEmpty() {
    		return front == rear;
    	}
    	
    	//增加数据到对列中
    	public void addQueue(int n) {
    		//增加数据时需要判断队列是否为满
    		//为满的话,数据根本增加不进去
    		if(isFull()) {
    			System.out.println("队列是满的,无法加入数据");
    			return;
    		}
    		
    		rear++; //添加数据时移动的队尾指针
    		arrQueue[rear] = n;
    		System.out.println("数据添加成功");
    	}
    	
    	//获取队列中的数据,也叫出队
    	public int getQueue() {
    		
    		//获取队列的数据时需要判断队列的是否为空
    		if(isEmpty()) {
    			throw new RuntimeException("队列为空,无法获取");
    		}
    		
    		front++;//数据出队时移动的是队头指针
    		return arrQueue[front];
    	}
    	
    	//显示队列中的数据
    	public void listQueue() {
    		
    		//显示队列中的数据时需要先判断队列是否为空,为空则显示不了
    		if(isEmpty()) {
    			System.out.println("队列为空");
    			return;
    		}
    		
    		for(int i=0; i<=maxSize-1; i++) {
    			System.out.printf("arr[%d] = %d", i,arrQueue[i]);
    			System.out.println();
    		}
    	}
    	
    	//显示队列头数据
    	public int headShow() {
    		
    		//显示队头数据也需要判断队列是否为空
    		if(isEmpty()) {
    			throw new RuntimeException("队列为空,无法显示");
    		}
    		
    		return arrQueue[front+1];
    

    这段代码实现后会发现,这个队列只能使用一次,当数组队列中的所有的位置都被使用过一次后,在将队列中的数据出队,新的数据无法添加到这个数组队列中,是因为,front和rear属性在执行方法时是单向移动,不能循环使用,所以当front移动到最后一个位置,rear也移动到最后一个位置后,虽然现实数组为空,但是添加不了数据,因为前面的空位rear去不了,后面又没有存储空间了,这就需要用到循环队列了。

    差异代码展现

    //判断是否为满
    	public boolean isFull() {
    		return (rear+1)%maxSize == front;
    	}
    	
    	//添加数据
    	public void addQueue(int n) {
    		//增加数据时需要判断队列是否为满
    		//为满的话,数据根本增加不进去
    		if(isFull()) {
    			System.out.println("队列是满的,无法加入数据");
    			return;
    		}
    		
    		//添加数据时不用再移动指向队尾的 rear
    		arrQueue[rear] = n;
    		//由于是循环队列所以 rear 可能会移动到数组的前面,
    		//单纯的 ++ 操作无法实现要求,可能还会越界 
    		rear = (rear + 1) % maxSize;
    		System.out.println("数据添加成功");
    	}
    
    	//数据出队
    	public int getQueue() {
    		
    		//获取队列的数据时需要判断队列的是否为空
    		if(isEmpty()) {
    			throw new RuntimeException("队列为空,无法获取");
    		}
    		
    		//数据出队时就是 front 所指向的数组,不用后移动
    		int value = arrQueue[front]; 
    		front = (front + 1) % maxSize;
    		return value;
    	}
    
    		//显示队列
    	public void listQueue() {
    		
    		//显示队列中的数据时需要先判断队列是否为空,为空则显示不了
    		if(isEmpty()) {
    			System.out.println("队列为空");
    			return;
    		}
    		
    		//显示队列时不能仅仅以 数组大小来作为终止条件
    		//需要知道 在队列数组中一共有多少个有效数据
    		//借助 获取有效数据函数
    		for(int i=front; i<front+size(); i++) {
    			System.out.printf("arr[%d] = %d", i%maxSize,arrQueue[i%maxSize]);
    			System.out.println();
    		}
    	}
    	
    	//获取有效数据个数
    	public int size() {
    		return (rear+maxSize-front) % maxSize;
    	}
    	
    

    循环数组队列和普通数组队列的不同处体现在这几个地方

    • 判断队列是否为满队列 (rear+1)%maxSize == front,通过这样可以计算 rear 移动到数组之前用过的位置的值
    • 添加数据时,通过下面的操作可以将 rear 移动到数组之前使用过的空间,重新来使用形成一个环。
    	arrQueue[rear] = n;
     	rear = (rear + 1) % maxSize;
    
    • 需要添加一个方法,就是获取有效数据个数,
    (rear+maxSize-front)%maxSize;
    

    视频学习链接:https://www.bilibili.com/video/av54029771/?p=11

    坚持者赢!!!

    展开全文
  • (数据结构)C语言实现数组队列

    千次阅读 2018-10-17 14:12:21
    为什么说是循环呢,因为出队列的时候,front在不断向rear靠近,已经出队列的元素占用的空间,没有什么变量去记录它,所以会对这部分空间造成浪费,此刻,如果rear再增加的话,数组的大小有限,明显是不够的,如果...

    参考1:https://blog.csdn.net/juanqinyang/article/details/51354293

    参考2:http://www.cnblogs.com/kaituorensheng/archive/2013/02/28/2937865.html

     这两篇文章都提到了循环利用,实现语句是:qu->rear = (qu->rear + 1) % SIZE; 和qu->front = (qu->front +1)% SIZE;

    为什么说是循环呢,因为出队列的时候,front在不断向rear靠近,已经出队列的元素占用的空间,没有什么变量去记录它,所以会对这部分空间造成浪费,此刻,如果rear再增加的话,数组的大小有限,明显是不够的,如果rear对数组大小取余,那么又对数组进行了利用,即循环利用。

    /***************************************************
    ##filename      : arrayqueue.c
    ##author        : GYZ                               
    ##e-mail        : 1746902011@qq.com                 
    ##create time   : 2018-10-17 11:19:21
    ##last modified : 2018-10-17 14:09:56
    ##description   : NA                                
    ***************************************************/
    #include <stdio.h>                                  
    #include <stdlib.h>                                 
    #include <string.h>                                 
    
    #define SIZE 20                                                    
        
    typedef struct Queue
    {
        int arr[SIZE];
        int front;
        int rear;
        int counter;
    } Queue;
    
    void initQueue(Queue *qu)
    {
        qu->front = 0;
        qu->rear = -1;
        qu->counter = 0;
        printf("init a queue successfully!\n");
    }
    
    void inQueue(Queue *qu,int ele)
    {
        if(qu->counter >= SIZE)
        {
            printf("the queue is full!\n");
        }
        else
        {
            qu->rear = (qu->rear + 1) % SIZE;
            qu->arr[qu->rear] = ele;
            qu->counter ++;
            printf("in queue an element %d\n",ele);
        }
    }                    
    
    void outQueue(Queue *qu)
    {
        if(0 == qu->counter)
        {
            printf("the queue is empty!\n");
        }
        else
        {
            int ele;
            ele = qu->arr[qu->front];
            printf("out queue is %d\n",ele);
            qu->front = (qu->front + 1) % SIZE;
            qu->counter --;
        }
    }
                
    int main(int argc,char *argv[])                     
    {                                                   
        Queue queue;
        initQueue(&queue);
        inQueue(&queue,1);
        inQueue(&queue,2);
        inQueue(&queue,3);
        inQueue(&queue,4);
        inQueue(&queue,5);
        inQueue(&queue,6);
        inQueue(&queue,7);
        inQueue(&queue,8);
    
        outQueue(&queue);                                     
        outQueue(&queue);                                     
        outQueue(&queue);                                     
        outQueue(&queue);                                     
        outQueue(&queue);                                     
        outQueue(&queue);                                     
        outQueue(&queue);                                     
        outQueue(&queue);           
                              
        outQueue(&queue); /*ninth*/                             
        return 0;                                   
    }                                                   
                                                        
                                                        
    
    
    

     

    展开全文
  • 数据结构实现(三):数组队列(C++版)1. 概念及基本框架2. 基本操作程序实现2.1 入队操作2.2 出队操作2.3 查找操作2.4 其他操作3. 算法复杂度分析3.1 入队操作3.2 出队操作3.3 查找操作4. 完整代码 1. 概念及基本...
  • 链表队列及其与数组队列的比较

    千次阅读 2018-05-13 15:17:14
    //添加元素是从列表尾部tail,删除元素从链表头部head public class LinkedListQueue&lt;E&gt; implements Queue&lt;E&gt; { private class Node{ ... public Node(E e, Node ne...
  • 队列是一种先入先出的数据结构(FIFO),只允许在前端(front)删除,在后端(rear)插入。容量为capacity大小的内存,只能存capacity-1的元素,其中rear的位置始终为空。 本文实现的队列,功能如下: 1 获取元素内容 ...
  • 实现环形数组队列

    千次阅读 2019-06-18 21:14:10
    看到一个很棒的环形数组队列实现方法,转载过来。 原网址:https://blog.csdn.net/xuanwolanxue/article/details/68925446 话不多说,上重点: 这里主要指的是队列的入队(enqueue)与出队(dequeue),...
  • 主要介绍了Java数组队列概念与用法,结合实例形式分析了Java数组队列相关概念、原理、用法及操作注意事项,需要的朋友可以参考下
  • python 数组队列

    千次阅读 2018-04-13 12:34:04
    xxt.pop(0) print('pop:',xxt) for data in xxt: print(data) 原文链接:https://blog.csdn.net/jacke121/article/details/84308068 数组队列实现: class MyList: test = [] def __init__(self, mylen=100): self....
  • 顺序存储(数组)和链式存储(链表),此博文描述的是数组的实现(后续更新链表实现)  代码实现 初始化队列:初始化一个size长度的队列队列的值都为0 判断队列是否已满:队列满,不可插入队列 判断队列是否为空...
  • 数据结构 - 数组队列 上一篇博客我们提到了数据结构中访问速度最快的数组,但是数组在使用时有一些限制 数组在定义的时候就必须定义存储的类型和大小,定义完成之后不能修改数据类型和大小,而我们在大多数实际...
  • 数组队列的实现

    2019-01-27 12:51:04
    1.什么是数组队列 要知道这个问题,首先我们要清楚数组有哪些特点。 数组的优点是显而易见的,但是数组有哪些缺点呢? 其中我认为最大的一个缺点就是数组大小固定,如果要存储的数据个数不确定的时候?就可能出现...
  • 数组队列实现

    2014-07-23 10:10:02
    学习数据结构过程中,亲自在VC++上编译通过的使用数组实现队列的源代码,与大家共享。
  • 数组队列(Array Queue)

    2020-02-16 12:44:07
    数组队列(Array Queue)
  • 各自完成插入 10万、20万 条随机数,然后再将这些随机数出队列 ; 测试代码 /** * 测试速度 */ public String testSpeed(Queue&amp;amp;lt;Integer&amp;amp;gt; queue, int num) { long start = ...
  • 静态数组队列(循环队列)基本操作

    千次阅读 2017-04-28 23:54:42
    /*静态数组队列(循环队列):C语言实现版*/ /*特点:队列大小固定,可以防止伪溢出发生*/ #include #include /*定义队列*/ #define MAX_Q_SIZE 5 /*最大队列长度+1 ,实际长度为4*/ typedef struct { int *base ; ...
  • 由于本章介绍的数据结构是队列,在队列的实现上会基于前面写的动态数组来实现,而队列又和栈不论是从特点上和操作上都有类似之处,所以在这里对这两种数据结构不了解的朋友,可以去看一下笔者前两篇文章介绍的数据...
  • 数组与数组队列

    2016-07-23 18:11:02
    数组与数组队列一、数组: 数组是有序的在定义时已经设定好大小,能存储多种数据类型,根据用途还可以分为n维数组。以下是数组的定义方式:一维数组1、数组类型[]数组名=new 数据类型[长度];2、数据类型 [] 数组名 =...
  • 一、概念 顾名思义,就是用数组(array)去...定义一个数组容量为4的数组队列。 2、入队 2.1、定义空队列 2.2、元素A入队 2.3、元素B入队 2.4、元素C入队 2.5、元素D入队 不难发现,队列满了,无法再添加了...
  • NULL 博文链接:https://128kj.iteye.com/blog/1665616
  • 数组实现队列

    2020-09-05 12:04:28
    数组实现有队列空,队列满。 数组实现队列 数组实现简单队列有头和尾“指针”。插入元素,队尾rear指针上移加1。移除元素,队头指针上移加1。 环绕处理(循环队列) 为了避免队列不满却不能插入数据项的情况,可以让...
  • 今天学习了队列,在这里记录一下。但是总觉得在代码实现上怪怪的.......后存入的要后取出 示意图:(使用数组模拟队列示意图) rear表示尾指针,front表示头指针,在初始化的时候,rear=front=-1(第一张图); 当有.
  • 数组队列的思路 队列本身是有序列表,若使用数组的结构来存储队列的数据,则队列数组的声明如下图,其中maxSize是该队列的最大容量。 因为队列输出,输入是分别从前后端来处理,因此需要两个变量front和rear分别...
  • 数组队列

    2017-07-22 16:01:54
    1.什么是队列 队列是一种线性结构,只能从一端插入从另一端删除,即“先进先出,后进后出”。...3.为什么要使用数组队列 笔者的上一篇文章讲到了数组,数组是所有数据结构中存储和读取速度最快的线性结
  • 队列:环形数组队列

    2018-11-18 22:00:06
    一个基本的环形数组队列的实现 #include&amp;amp;amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;amp;amp;gt; using namespace std; //环形数组队列 template&amp;amp;amp;amp;amp;amp;lt;class T&...
  • 队列Queue: 是一种线性的数据结构,底层可以有很多种实现方式,比如说数组,还有链表之类的,它限制了我们数据的插入和删除,只能从队尾插入(入队),队首删除(出队),先进先出...基本上数组队列的实现没什么难...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 434,862
精华内容 173,944
关键字:

数组队列