Dynamic list sorting in Tcl - sorting

Question

I want to do some sorting based on a dynamic list. Let me explain below
I am using tcl version 8.4 which i cannot change, have to use that
list1 = {{a b c} {c b c a} {b b a}} ..... 1st input data
List 1 is a tcl list that has 3 members which forms different types of sub lists in any order and this will even change everytime. For example next time, list 1 will be :
list1 = {{c} {b c a} {b c} {a c a c}} ..... 2nd input data (for next time consideration)
Now I want to sort them in such a way that if I use a loop around them or lsort or string compare or any other tcl command, the new tcl list should contain individual members based on a priority. just as we have ascending/descending.
Notice in that both cases the individual sub_lists length is increasing and decreasing and at the same time from a,b,c also keep on rotating.
In my case I want "a" to have highest priority, then "b" and then "c" (a->b->c)
So output after processing done for 1st iteration should be :
$> puts $new_list1
$> {a a a} # as out of 3 sublists a is present in them and it gets highest priority.
Similarly, output after processing done on 2nd iteration should be :
$> puts $new_list1
$> {c a b a} # as you can see that list1 1st element is c so it gets output as is, second sublist has b c and a so `a` gets outputted, 3rd sublist is b and c so `b` gets outputted
Let me know what your thoughts are.
Thanks in advance !

Answer 1

First, I'd look into is constructing that data structure in a way such that you wouldn't have to sort all the sublists—for example, use an algorithm as simple as binary search to linsert each element into a sorted index per sublist.
Second, I'd think about whether you need as much "optimization" as you might think you do. Often, the best solution (due to maintainability) is the most obvious thing: sort the sublists, then use a loop, like so:
# construct a new list of sorted sublists
foreach sublist $list {
lappend presorted_list [lsort $sublist]
}
# given a reference to a list of sorted lists, simultaneously build (1) a list of
# each sublist's first element and (2) a list of the each sublist's remaining
# elements, so that the former can be returned, and the latter can be set by
# reference for the next iteration (and will have omitted any empty sublists)
proc process_once {presorted_list_ref} {
upvar $presorted_list_ref presorted_list
foreach sublist $presorted_list {
if {[llength $sublist] > 0} {
lappend returning_list [lindex $sublist 0]
lappend remaining_list [lrange $sublist 1 end]
}
}
set presorted_list $remaining_list
return $returning_list
}
set iter_1 [process_once presorted_list]
set iter_2 [process_once presorted_list]
I don't think there is any better way to do this, if you cannot pre-process or construct your original list in a way to begin with sorted sublists. Unless beginning with sorted sublists, you cannot make a decision about which item in each sublist must be output, without examining all items—so you might as well sort once so you'll know to always take the first item per sublist, as I've coded above.
In loop form, if you don't need to retrieve one iteration at a time specifically,
foreach sublist $list {
lappend presorted_list [lsort $sublist]
}
while {[llength $presorted_list] > 0} {
foreach sublist $presorted_list {
if {[llength $sublist] > 0} {
lappend returning_list [lindex $sublist 0]
lappend remaining_list [lrange $sublist 1 end]
}
}
#
# do stuff with $returning_list
#
set presorted_list $remaining_list
}