In the following table, the first column has groups of letters, and the letters of each group are arranged in alphabetical order. Each of these group of letters is the subject. The rest of the words in the row, are anagrams of the word (group of letters) in the first column cell. The rest of the words in the row are anagrams of one another. In fact all the words in a row are anagrams of one another, though the first word may not make sense.

acer:     acer      acre      care      race
abekr:    baker     brake     break     kebar
aceehrst: cheaters  hectares  rechates  recheats  teachers
aabcdkrw: backward  drawback
deeilnst: enlisted  lintseed  listened  tinseled
adehrst:  hardset   dearths   hardest   hatreds   threads   trashed
aelmny:   laymen    meanly    namely
amnopst:  postman   tampons   topsman
einoprst: proteins  pointers  porniest  repoints  tropines
aeehrstw: wreathes  weathers

Strategy

A function has to be written that returns a structure consisting of rows. The first element in the row is the subject or key for the rest of the row. All the elements in each row of the structure returned, are anagrams of one another. The first element in each row is detached from the rest of the elements in the row. In fact, the structure returned, is a hash table. 

For the program below, all the above words, except those in the first column, are considered as the dictionary. They are sent into the program in reverse order, beginning from weathers, then wreathes and then ending with acre and acre, in that order. They are sent as one array (one list). The output has to be the above table, with the first word in each row being the key of the returned hash table. The rest of the row is the corresponding list of anagrams. The key is the group of letters arranged alphabetically. 

In PY the hash table to use is the ordered map data structure. This will order the keys in ascending order. The hash table is returned with the keys as shown in the table above. Each list will not necessarily be arranged in ascending order, in order to reduce the total running time of the whole function.

The algorithm function will operate as follows:
- Get the first word from the input array. Sort it by letters and use the sorted copy as a key in the hash table. 
- Every word obtained from the input array (input list) is sorted first.
- It is then verified if the sorted group of letters (word) is already one of the keys in the hash table. If yes, the unsorted word is added to the list for its key. If no, the sorted word becomes a new key. In the algorithm function below, no time is used for this step (to search for a key).

The above algorithm continues until the end of the dictionary (end of input list).

from collections import defaultdict

def find_anagrams(words):
    ordered_mp = defaultdict(list)
    
    for word in words:
        sorted_string_key = "".join(sorted(word))
        # without searching for key,
        ordered_mp[sorted_string_key].append(word)
        
    return ordered_mp

#To call the function
words = [
    'weathers', 'wreathes', 'tropines', 'repoints', 'porniest', 'pointers',
    'proteins', 'topsman', 'tampons', 'postman', 'namely', 'meanly',
    'laymen', 'trashed', 'threads', 'hatreds', 'hardest', 'dearths',
    'hardset', 'tinseled', 'listened', 'lintseed', 'enlisted', 'backward',
    'drawback', 'teachers', 'recheats', 'rechates', 'hectares', 'cheaters',
    'kebar', 'break', 'brake', 'baker', 'race', 'care', 'acre', 'acer'
]

ht = find_anagrams(words)

for key, value_list in ht.items():
    print(f"{key}: ", end="")
    
    for word in value_list:
        print(f"{word} ", end="")
    print()

aabcdkrw: backward drawback 
abekr:    kebar    break    brake    baker 
aceehrst: teachers recheats rechates hectares cheaters 
acer:     race     care     acre     acer 
adehrst:  trashed  threads  hatreds  hardest  dearths  hardset 
aeehrstw: weathers wreathes 
aelmny:   namely   meanly   laymen 
amnopst:  topsman  tampons  postman 
deeilnst: tinseled listened lintseed enlisted 
einoprst: tropines repoints porniest pointers proteins 

        ordered_mp[sorted_string_key].append(word)