5.2k views

A circularly linked list is used to represent a Queue. A single variable $p$ is used to access the Queue. To which node should $p$ point such that both the operations $\text{enQueue}$ and $\text{deQueue}$ can be performed in constant time?

1. rear node
2. front node
3. not possible with a single pointer
4. node next to front
asked in DS | 5.2k views
+4
0
the condition should be given in question that the next of rear points to the front node because that will be the case only when the queue is full.

The pointer points to the Rear node.

EnQueue: Insert newNode after Rear, and make Rear point to the newly inserted node:

//struct node *newNode;
newNode->next = rear->next;
rear->next = newNode;
rear=newNode;

DeQueue: Delete the Front node, and make the second node the front node.

//rear->next points to the front node.
//front->next points to the second node.
struct node* front;
front = rear->next;
rear->next = front->next;
free(front);


selected by
+4

0
what does constant time means in the questn...?
0
@Dhalrya: Constant time means $\Theta(1)$ time
0
thank u Pragya...:)
0
@pragy.am nott getting this solution , can u plzz explain
0
Why we are using another front to delete previous front ? This code is much better I think...

temp = front ;

rear --> next = temp --> next;

front = rear --> next;

free (temp);
0
they were not metioned rear and front why are u taking rear and front????????????????????????????????????

i m in confusion
0
You can't use $front$ and $rear$ pointers. You only have to use pointer $p$. Although the answer *is* "rear node", your implementation of $enQueue()$ and $deQueue()$ is wrong.
0
@ pragy

how can you use front and rear bcoz A single variable p is used to access the Queue
0
@rajoramanoj  read the question  and explanations  (of pragya) again
0
Why are we using front pointer? Although it is possible but the question says single variable is used to access linked list .We should not create new variable.Please clarify
0
@Arjun Sir i think this is wrong explanation they have not mentioned any front and rear pointer in the question we can only make use of p pointer
0
@srestha dont u think he used additional pointers which were not mentioned in the question .. only one pointer should be used
0

If answer is rear node,then it is not possible with one pointer p.

0

@rahul

front is not extra created

just we need to free(front)

0
@Rahul Sharma But GATE asked to implement it with one node only.
0

@srestha I think here front and rear are just mentioned in the question to indicate which nodes are front(first node) and rear(last node) and they are not pointers. Although the answer remains same that P points to rear node.

0
$\rightarrow$ operator uses with pointer
0
Yes, but in question it isn't mentioned that front and rear are pointers.
+1

Oh my, this questions seems to have attracted a lot of confusion!

The pointer points to the Rear node.

EnQueue: Insert newNode after Rear, and make Rear point to the newly inserted node:

//struct node *newNode;
newNode->next = p->next;
p->next = newNode;
rear=newNode;

DeQueue: Delete the Front node, and make the second node the front node.

rear->next = rear->next->next;

0

what does constant time means in the questn...?

0
simply we are not traversing queue thats why we not using extra time . we are performing both the opration in constant time. like O(1)
+1
This is not deletion. Memory is not de allocated
0
Yup. Hence not possible with a single pointer p.
0

P should point to Last node(rear), so as to perform enqueue in constant time.

To perform dequeue operation, since it is circular linked list, rear node will point front. Therefor dequeue can be performed as below:

temp= p->next->next//stores the address of node next to front node.

Delete (p->next)// delete current front node

p->next= temp// update the rear node to point to new front node.

Thus dequeue can also be perform in constant time.

edited

enqueue is possible with 1 pointer but for dequeue we have to take 1 more pointer bcoz if dequeue compulsory we have to free the memory also which is not possible with only 1 pointer.if modify then we can do whatever we want but in dequeue free the memory also.

@ arjun sir plz verify
0

Bikram sir plz verify this ans

0
@Arjun sir what he said is correct answer should be C if we take use of front and rear whats the use of giving temporary pointer P even without it we can do
0
i was also thinking the same. answer should be c.
I think there is no front or rear pointer here only p pointer so enQueue() and deQueue operation should be this

1.) newNode-->next=p-->next-->next;

2.) p-->next-->next=NULL;

3.) free(p-->next);

4.) p-->next=newNode;
+1
@One

yes u r right they were not mentioned about rear and front pointers they only give us pointer P

Now the  case if p points to front:

Enqueue:

1.save the data of the node pointed by p in a temp variable.

2.copy the data of new node to the node p is pointing to.

3.copy the data of the temp variable to the new node created

4.make newnode->next=p->next point to the new node

5.make p->next=newnode

6.make p=p->next

Dequeue:

1.copy the data of the node in p->next to p.

2.make p->next=p->next->next
0
@Arjun sir : please check this

1
2