I'm continuing to think about this priority queue stuff, now looking at
"meld", and wondering what would be the best way to approximate it with
what's in clojure right now ... core data structures and simple algorithms.

for example, I could populate two vectors O(n), sort them O(n(log(n))), and
implement the O(n) merge part of merge-sort.  Then popping things off the
front would easily be O(1).

I'd compare that with the practical runtime of the heap, which has a
theoretical runtime of O(n) for all the inserts, no time for any up front
sorting, and O(log(n)) for merging (or possibly O(1) time with more
coding).  Again the main work would be the O(log(n)) pops,

but I want to just compare the meld speeds right now.

sorted-sets aren't really right because of the uniqueness of elements, but I
could try that, too, doing a join/union of two sorted sets.

granted I haven't looked through contrib much ... I need to figure out how
to access/include it from my current evironment/IDE (clojure-dev right now)

Thanks for the help.

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To post to this group, send email to clojure@googlegroups.com
To unsubscribe from this group, send email to 
clojure+unsubscr...@googlegroups.com
For more options, visit this group at 
http://groups.google.com/group/clojure?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to