精华内容
下载资源
问答
  • 11顺序队列假溢出

    2020-02-20 16:51:14
    名称:顺序队列假溢出 */ #include<stdlib.h> #include<stdio.h> struct SqQueue{ int *base;//空间基地址 int front,rear; }; #define SIZE 5 typedef int datatype; int main(void) ...
    
    ```c
    /*
    姓名:高万禄
    日期:2020/1/27
    名称:顺序队列假溢出
    */
    #include<stdlib.h>
    #include<stdio.h>
    struct SqQueue{
    	int *base;//空间基地址
    	int front,rear; 
    };
    #define SIZE 5
    typedef int datatype;
    int main(void)
    {
    	struct SqQueue Q;
    	Q.base=(int *)malloc(SIZE*sizeof(datatype));
    	if(Q.base==NULL)
    	return 0;
    	Q.rear=0;
    	Q.front=Q.rear;
    	/
    	//进队 
    	printf("进队\n");
    	while(1)
    	{
    		if(1!=scanf("%d",(Q.base+Q.rear)))
    		{
    			break;
    		}
    		getchar();
    		Q.rear++;
    		if(Q.rear==SIZE)// Q.rear超过允许最大值5,这种情况成为“假溢出” 
    		break;
    	}
    	//
    	//出队
    	printf("出队\n");
    	while(1)
    	{
    	printf("%d\n",*(Q.base+Q.front));
    	Q.front++;
    	if(Q.front==Q.rear)
    	break;	
    	}
    	return 0; 
    }
    
    
    
    展开全文
  • 循环队列可以很好的解决假溢出问题,不同于普通队列,在循环队列中,需将rear与front初始值都设置为0,rear指针指向队列中最后一个元素的下一个位置, 也正因如此,数组是否存满的判定条件也应做出改变, 在普通队列中,...

    循环队列可以很好的解决假溢出问题,不同于普通队列,在循环队列中,需将rear与front初始值都设置为0,rear指针指向队列中最后一个元素的下一个位置,
    也正因如此,数组是否存满的判定条件也应做出改变,
    在普通队列中,front==maxSize-1,即可认为数组已满,但是在循环队列中,由于在存放完数组最后一个有效位置后可以继续像数组中的0号位置进行存储,所以判断满的条件也会发生改变,—(rear+1)%maxSize == front.

    可以举个例子方便理解,假设一maxSize=5的数组,那么其有0 1 2 3 4 这几个位置,假设目前数组中有4个数值,即 0 1 2 3都存值了,那么rear应该为4 ,rear+1则为5 , 5%5=0=font ,则说明已经存满了,这里注意4号位置是无效位置,循环数组中必须空一个位置,否则判空和判满是同一表达式.

    队列中的有效数值个数为 (rear+maxSize-front)%maxSize

    判空则为rear==front
    下面给出代码

    import java.util.Arrays;
    import java.util.Scanner;
    
    public class TestQueue2 {
        public static void main(String[] args) {
            ArrayQueue2 arrayQueue2 = new ArrayQueue2();
            Scanner scanner = new Scanner(System.in);
            arrayQueue2.iniQueue(3);
            boolean flag = true;
            while (flag) {
                System.out.println("请输入要进行的操作" + "\n" + "(a)add:增加元素" + "\n" + "(g)get:取出元素" + "\n" + "(s)show:展示数组" + "\n" + "e(exit)");
                String key = scanner.next();
                switch (key) {
                    case "a":
                        System.out.println("请输入添加数字:");
                        int i = scanner.nextInt();
                        arrayQueue2.addQueue(i);
                        break;
                    case "g":
                        arrayQueue2.getQueue();
                        break;
                    case "s":
                        arrayQueue2.showQueue();
                        break;
                    case "e":
                        flag = false;
                        break;
    
                }
    
    
            }
        }
    }
    
    class ArrayQueue2 {
        public int[] arr;
        public int rear;
        public int front;
        public int maxSize;
    
        //初始化队列
        public void iniQueue(int length) {
            arr = new int[length];
            front = 0;
            rear = 0;
            maxSize = length;
        }
    
        public boolean isEmpty() {
            return (rear + maxSize - front) % maxSize == 0;//循环队列的关键是队列中元素的绝对位置并不固定,需要通过简单运算,确定元素位置.
        }
    
        public boolean isFull() {
            return getSize() == front;
        }
    
        public void addQueue(int element) {
            if (isFull()) {
                System.out.println("满了,添加不了");
                return;
            }
            arr[rear] = element;
            rear = (rear + 1) % maxSize;//通过取余防止数组越界
        }
    
        public int getQueue() {
            if (isEmpty()) {
                System.out.println("空的,取不了");
               //这里有一个问题 返回值怎么设置
            }
            int temp = arr[front];
            front = (front + 1) % maxSize;
            return temp;
        }
    
    
        public void showQueue() {
            if (isEmpty()) {
                System.out.println("空的,取不了");
                return;
            }
            for (int i = front; i < front + getSize(); i++) {
                System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
            }//这里i的实际取值也是值得注意的问题
        }
    
        public int getSize() {
            return (rear + maxSize - front) % maxSize;
        }
    }
    
    展开全文
  • 循环队列

    循环队列

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 顺序队列假溢出

    千次阅读 2021-01-16 20:48:43
    顺序队列假溢出 我们已经明白了队列这种基本数据结构,对于顺序队列而言,其存在已经足够解决大多时候的设计问题了,但是其依旧存在一些缺陷和不足,因为我们的入队和出队操作均是直接在其后面进行结点的链接和...

    顺序队列的假溢出

    我们已经明白了队列这种基本数据结构,对于顺序队列而言,其存在已经足够解决大多时候的设计问题了,但是其依旧存在一些缺陷和不足,因为我们的入队和出队操作均是直接在其后面进行结点的链接和删除,这就造成其使用空间不断向出队的那一边偏移,产生假溢出。

    什么是假溢出?打一个比方:

    4031.png
    (示例顺序队列)

    回顾一下队列的性质,首先我们有一个顺序队列,这个队列的大小为5,其已经包含了四个元素data1,data2,data3,data4,接着,我们对这个队列进行出队操作,出队2个元素,队列就变成了这个样子:

    4032.png

    目前看起来没有问题,那么我们接着再进行入队操作,我们入队2个元素,分别是data5和data6,此时我们已经发现问题了,尾指针移动到我们可以进行队列操作的范围之外去了,我们称呼作为队列用的存储区还没有满,但队列却发生了溢出,我们把这种现象称为"假溢出"。

    4033.png
    (出队产生假溢出)

    展开全文
  • 上一篇博文,我们提到在使用顺序队列时出现的假溢出问题,今天我们就来谈谈如何解决顺序队列假溢出问题。 循环队列 当进行动态创建队列的时候,也只不过是向后继续不断的申请内存空间,即时前面出队操作释放掉了...
  • 问题:什么是顺序队列假溢出? 从队首倒到队尾完全占用了分配的空间,是溢出。相反,队尾元素占用了分配的最后一个空间,队首元素还是占有的不是第一个分配的空间,相当于队列对外是满的,但是内部空间利用不充分...
  • 顺序队列假溢出: 按照
  • 顺序队列的“假溢出”是指因顺序队列进行大量的出队入队操作后,导致前部队列虽然有存储位点,但后续入队操作无法进行的溢出。它不同于真正意义上的溢出,这种陷阱可以通过一些方式来实现规避。 本场 Chat 为大家...
  • 要求顺序循环队列不损失一个空间全部能够得到有效利用,请采用设置标志位tag的方法解决“假溢出”问题,实现顺序循环队列算法。 考察循环队列入队和出队算法思想。设置标志位tag,初始时tag=0,当元素入队成功,令...
  • 使用链表实现队列,完美解决假溢出问题。
  • 文章目录队列:结构定义:结构操作:代码举例:循环队列:代码:栈:结构定义:结构操作代码举例:栈和队列的应用 队列: ​ 排队买票:先到先得,先进先出(first in first out,FIFO),队尾入队,队首出队 [外链...
  • 这个问题是从队列的基本形式上进行修改的: ...首先解释一下假溢出的现象:当队尾指针last=MaxSize - 1时,队列的前端可能还有许多 由于此前进行了删除操作而产生的空的位置。这样的情况,我们称为假溢出现
  • /*循环队列*/ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define MAX_QUEUE_CYCLE_SIZE 10 typedef struct queue_cycle{ int *base; //保存数组基地址 int f; int r; int queue_...
  • 循环队列-避免假溢出

    2017-03-24 13:53:00
    cout队列已满!"; return 1; } else { q->data[q->rear]=e; q->rear=q->rear+1; q->tag=1; return 1; } } int del(seq *q,int *e) { if(empty(*q)) { cout队列是空!"; return 0; } else { *e...
  • 队列是一种“先进先出”(FIFO)的数据结构,队列有两端,一边只进,一边只出,即:数据从尾部进入,从头部出来,先进去的就会先出来,就像我们平时食堂打饭排队一样,先去排的先打到饭,后去排的后打到饭。...
  • 在上篇《队列的C++实现》中已经介绍了一种假溢出的解决方案:当数据出队时,将数据整体向前移动,这样就会不会出现假溢出。 另一种方案是:将数组看成循环的,这样的话,即使尾端数据已经塞满,但是由于结构是循环...
  • 队列---顺序队列存储结构的不足(假溢出

    万次阅读 多人点赞 2015-10-21 16:38:11
    我们假设一个队列有n个元素,则顺序存储的队列需建立一个大于n的数组,并把队列的所有元素存储在数组的前n个单元,数组下标为0的一端即是队头。所谓的入队列操作,其实就是在队尾追加一个元素,不需要移动任何元素,...
  • 我们假设一个队列有n个元素,则顺序存储的队列需建立一个大于n的数组,并把队列的所有元素存储在数组的前n个单元,数组下标为0的一端即是队头。所谓的入队列操作,其实就是在队尾追加一个元素,不需要移动任何元素,...
  • 顺序队列因多次入队列和出队列操作后出现的有存储空间但不能进行入队列操作的溢出称为假溢出(因为入队和出队后,rear值和front值逐渐变大,最开始的位置为空但无法入队) 假溢出是由于队尾rear的值和队头front的值...
  • 队列的顺序存储结构和基本定义的实现 #include <stdio.h> #include <malloc.h> #define MaxSize 100 typedef char ElemType; typedef struct { ElemType data[MaxSize]; int front,rear; //队首...
  • * 用c语言实现顺序队列(存在假溢出现象,即队列中有空间却无法插入) */ #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct queue { //用来保存元素的数组 int *a; //...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,115
精华内容 3,646
关键字:

队列假溢出