Question

我通过数组实现创建了一个线性队列数据结构。

在线性队列中，数据结构元素从前面插入并从后面删除通常，当后部元素位于数组的最后一个索引处时，我们会显示溢出消息，即使前面有多个元素可以容纳更多元素。

为此，我找到了一个解决方案，每次执行删除操作时，我通过循环操作将每个元素移动一个位置。

但是当我在互联网上搜索线性队列的数组实现时，甚至没有一个解决方案实现这种方法。即使在geeksforgeeks，他们也没有使用过这种方法。由于这种方法很明显，为什么没有任何标准解决方案应用它。

是否会增加程序的时间复杂度？

#include<stdio.h>
#include<stdlib.h>
//the MAX is defined for array size
#define MAX 5
int q[MAX];
//here r indicates the index of last element in queue
int r=-1;
//function to insert element in queue
void insert();
//function to delete an element from queue
int delet();
//function to delete all the elements from the queue
void traverse();
int main()
{
    int choice;
    int value;
    printf("in 1\n");
    while(1)
    {
        printf("1. To insert an element to queue\n");
        printf("2. To delete an element from queue\n");
        printf("3. To delete all the elements from queue\n");
        printf("4. To Exit\n");
        printf("enter choice\n");
        scanf("%d",&choice);
        switch(choice)
        {
            case 1:insert();
                   break;
            case 2:value=delet();
                   value==-1?printf("queue is empty\n"):printf("the  
                   deleted element is %d\n",value);
                   break;
            case 3:traverse();
                   break;
            case 4:exit(0);
            default:printf("Enter a valid choice\n");
         }
    }
}
void insert()
{
    int item;
    //this is the condition for overflow
    if(r==MAX-1)
        printf("queue is full\n");
    else
    {
        printf("Enter item other than -1\n");
        scanf("%d",&item);
        r=r+1;
        q[r]=item;
    }
}
int delet()
{
    int temp,i;
    if(r==-1)
        return -1;
    else
    {
        temp = q[0];
        for(i=0;i<r;i++)
            q[i]=q[i+1];
        r=r-1;
        return temp;
    }
}
void traverse()
{
    int i;
    for(i=0;i<=r;i++)
        printf("%d\n",q[i]);
}

Answer 1

您的方法存在的问题是需要大量处理才能将所有内容都移动一个。在delet函数中，您有以下代码：

{
    temp = q[0];
    for(i=0;i<r;i++)
        q[i]=q[i+1];
    r=r-1;
    return temp;
}

现在，假设队列中有一百万个项目。从队列中删除项目时，必须将999,999个项目向上移动一个位置。从计算机的角度来看，这需要很长时间。

就算法复杂性而言，从循环队列中删除是O（1）操作：无论队列中有多少项，它都需要相同的时间。您的删除方法是O（n）操作：删除项目需要的时间与队列中的项目数成比例。

从功能上讲，您的实施没有任何问题。但从性能角度来看，您的实现将比循环队列慢得多。使用小型测试程序时，您不会注意到这一点，但是当您开始向队列中添加数千或数百万个内容时，您的代码可能会慢得多：比循环队列慢几千倍。

数组实现的线性队列

1 个答案: