How to implement queue and priority queue in Tcl? - data-structures

Question

I have to implement either queue or priority queue in Tcl without use of any library.
I have tried to write below code. Kindly help me to implement queue in better way in Tcl/Tk.
create node
// crearting node element of queue
proc createNode {name cost} {
namespace eval $name [subst {
variable cost $cost
variable this $name
}]
functions
proc ${name}::getCost {} {
variable cost
return $cost
}
return $name
}
delete queue
proc deQueue name {
#upvar 1 $name queue
set queue $name
set res [lindex $queue 0]
set queue [lrange $queue 1 end]; # remove the first element
set res; # return the value
}
queue insertion
proc enQueue {newNode name} {
#upvar 1 $name queue
set queue $name
set queue [concat $newNode $queue]
}
create queue
proc makeQueue {n g } {
set queue [list [createNode $n $g ]]
return $queue
}

Answer 1

A simple queue implementation:
proc enqueue {name item} {
upvar 1 $name queue
lappend queue $item
}
proc dequeue name {
upvar 1 $name queue
set queue [lassign $queue item]
return $item
}
% enqueue a foo
% set item [dequeue a]
A simple priority queue:
proc enpqueue {name prio item} {
upvar 1 $name queue
lappend queue [list $prio $item]
set queue [lsort -decreasing -integer -index 0 $queue]
}
proc depqueue name {
upvar 1 $name queue
set queue [lassign $queue prioitem]
return [lindex $prioitem 1]
}
% enpqueue a 10 foo
% enpqueue a 40 bar
% set item [depqueue a]
bar
The only thing you need for a queue or priority queue is a list and an add/remove interface.
If you want to store structured data in the queue, make the item either a tuple of data:
set item [list "Smith, John" 42 1500]
or a dictionary:
set item [list name "Smith, John" age 42 foo 1500]
Documentation:
lappend,
lassign,
lindex,
list,
lsort,
proc,
return,
set,
upvar

Answer 2

Queues are abstract data structures with two (key) operations: add and get (and an empty test is pretty common too). They're sufficiently complex internally that it's probably best to think in terms of using a TclOO object as their implementation:
oo::class create Queue {
variable q
constructor {} {
set q {}
}
method add {item} {
lappend q $item
return
}
method empty {} {
expr {[llength $q] == 0}
}
method get {} {
if {[my empty]} {
return -code error "queue is empty"
}
set q [lassign $q item]
return $item
}
}
Priority queues are like queues, except that they have a priority as well and sort by that priority. The trick to implementing them efficiently is not to sort on each add or get, but rather to only sort when necessary. (Or you can use an appropriate balanced tree, but they're quite complicated.)
oo::class create PriorityQueue {
variable q sorted
constructor {} {
set q {}
set sorted 1
}
method add {item priority} {
lappend q $item $priority
set sorted 0
return
}
method empty {} {
expr {[llength $q] == 0}
}
method get {} {
if {[my empty]} {
return -code error "queue is empty"
}
if {!$sorted} {
# You might want other options here, depending on what "priority" means
set q [lsort -stride 2 -index 1 -integer $q]
set sorted 1
}
set q [lassign $q item priority]
return $item
}
}
Using these data structures is fairly simple:
# Instantiate
set myq [PriorityQueue new]
# Add some values
$myq add "The quick brown fox" 12
$myq add "The lazy dog" 34
# Drain the queue
while {![$myq empty]} {
puts [$myq get]
}
# Get rid of it now we're done
$myq destroy