Queue/Usage: Difference between revisions

{{task|Data Structures}}{{Data structure}}

[[File:Fifo.gif|frame|right|Illustration of FIFO behavior]]

 

Operations:

 

=={{header|Ada}}==

with Ada.Text_Io; use Ada.Text_Io;

Pop (Queue, Value);

Put_Line ("Is_Empty " & Boolean'Image (Is_Empty (Queue)));

Sample output:

<pre>Is_Empty TRUE</pre>

 

=={{header|AutoHotkey}}==

 

=={{header|C}}==

See [[FIFO]] for the needed code.

#include <stdlib.h>

#include <stdbool.h>

 

fprintf(stderr, "FIFO list %s\n",

 

exit(0);

 

=={{header|C++}}==

Note that with C++'s standard queue, accessing the first element of the queue and removing it are two separate operations, <tt>front()</tt> and <tt>pop()</tt>.

#include <cassert> // for run time assertions

 

q.pop();

assert( q.empty() );

 

Note that the container used to store the queue elements can be specified explicitly; to use a linked linst instead of a deque (the latter is the default), just replace the definition of <tt>q</tt> to

 

(and add <tt>#include <list></tt>, of course). Also note that the containers can be used directly; in that case <tt>push</tt> and <tt>pop</tt> have to be replaced by <tt>push_back</tt> and <tt>pop_front</tt>.

 

=={{header|Clojure}}==

Using the implementation from [[FIFO]]:

 

(enqueue q 1)

(dequeue q) ; 3

 

Or use a java implementation:

 

(.add q 1)

(.remove q) ; 3

 

 

 

Using the implementation from [[FIFO]].

 

(enqueue 38 queue)

(assert (not (queue-empty-p queue)))

(assert (eql 38 (dequeue queue)))

(assert (eql 23 (dequeue queue)))

 

=={{header|E}}==

Using the implementation from [[FIFO]].

 

require(escape empty { reader.dequeue(empty); false } catch _ { true })

writer.enqueue(1)

require(reader.dequeue(throw) == 2)

require(reader.dequeue(throw) == 3)

 

E also has queues in the standard library such as <code>&lt;import:org.erights.e.examples.concurrency.makeQueue></code>, but they are designed for concurrency purposes and do not report emptiness but rather return a promise for the next element.

 

=={{header|Erlang}}==

All functions, from the shell:

{fifo,[],[]}

2> fifo:empty(Q).

8> fifo:pop(fifo:new()).

** exception error: 'empty fifo'

 

Crashing is the normal expected behavior in Erlang: let it crash, a supervisor will take responsibility of restarting processes, or the caller will take care of it. Only program for the successful cases.

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

 

type fifo_node

integer :: datum

end do

 

 

=={{header|Haskell}}==

 

Prelude> :l fifo.hs

[1 of 1] Compiling Main ( fifo.hs, interpreted )

*Main> v''''

Nothing

 

=={{header|J}}==

This is an interactive J session:

 

isEmpty__queue ''

1

7

isEmpty__queue ''

 

Using function-level FIFO queue implementation from [[FIFO#J|FIFO]]

 

This is an interactive J session:

1

first_named_state =: push 9 onto make_empty _

7

is_empty pop pop pop this_state

 

=={{header|Java}}==

{{works with|Java|1.5+}}

LinkedList can always be used as a queue or stack, but not in conjunction with the Stack object provided by Java. To use a LinkedList as a stack, use the <tt>push</tt> and <tt>pop</tt> methods. A LinkedList can also be used as a double-ended queue (deque); LinkedList has implemented the Deque interface since Java 1.6+.

import java.util.Queue;

...

System.out.println(queue.remove()); // 1

System.out.println(queue); // [2, 3]

 

You can also use "offer" and "poll" methods instead of "add" and "remove", respectively. They indicate errors with the return value instead of throwing an exception.

 

{{works with|Java|1.4}}

...

LinkedList queue = new LinkedList();

System.out.println(queue.removeFirst()); // 1

System.out.println(queue); // [2, 3]

 

=={{header|JavaScript}}==

JavaScript arrays can be used as FIFOs.

print(f.length);

f.push(1,2); // can take multiple arguments

print(f.shift())

print(f.length == 0);

 

outputs:

true

undefined</pre>

 

=={{header|Logo}}==

UCB Logo comes with a protocol for treating lists as queues.

 

print empty? :fifo ; true

queue "fifo 1

print dequeue "fifo ; 1

show :fifo ; [2 3]

 

=={{header|OCaml}}==

val q : '_a Queue.t = <abstr>

# Queue.is_empty q;;

- : int = 4

# Queue.is_empty q;;

 

=={{header|Oz}}==

[Queue] = {Link ['x-oz://system/adt/Queue.ozf']}

MyQueue = {Queue.new}

{Show {MyQueue.get}} %% foo

{Show {MyQueue.get}} %% bar

 

=={{header|Perl}}==

Perl has built-in support to these operations:

 

push @queue, (1..5); # enqueue numbers from 1 to 5

print $n while($n = shift @queue); # dequeue all

print "\n";

Output:

2345

 

=={{header|PicoLisp}}==

Using the implementation from [[FIFO]]:

(println (fifo 'Queue)) # Retrieve an internal symbol 'abc'

(println (fifo 'Queue)) # Retrieve a transient symbol "abc"

(println (fifo 'Queue)) # and a list (abc)

Output:

<pre>1

(a b c)

NIL</pre>

 

=={{header|Python}}==

my_queue = Queue.Queue()

my_queue.put("foo")

print my_queue.get() # foo

print my_queue.get() # bar

 

=={{header|REBOL}}==

See [[FIFO#REBOL]] for implementation. Example repeated here for completeness.

 

 

q: make fifo []

while [not q/empty][print [" " q/pop]]

print rejoin ["Queue is " either q/empty [""]["not "] "empty."]

 

Output:

Queue is empty.

Trying to pop an empty queue yields: none</pre>

 

=={{header|Ruby}}==

 

=={{header|Tcl}}==

See [[FIFO#Tcl|FIFO]] for operation implementations:

empty Q ;# ==> 1 (true)

push Q foo

peek Q ;# ==> foo

pop Q ;# ==> foo