@nm Actually, one can obtain (almost) the same results in Mma: 

Series solutions from MatLab's ode::series (just for comparison): 

@Carl Love & @mmcdara Thanks. 

In my opinion, Mathematica's Apply is technically not identical with Maple's apply. Compare:

(* Mma *)
Construct[f, a, b, c];
(* Maple *)
apply(f, a, b, c):

 and 

(* Mma *)
Apply[f, {a, b, c}];
(* Maple *)
`?()`(f, [a, b, c]):

@Carl Love Well, maybe the better term is "ordered pair" rather than "rule" (let alone "function"). (A bijection is dispensable.)
Here is the result from Mathematica: 

@Christian Wolinski, @mmcdara, and @Carl Love 
Thanks. But if we add a new rule f＝g (which gives an additional cycle), the results will go wrong.

@lcz 

eval(reduce(uneval(SubstituteAll), [s, seq(uneval(L1[k], L2[k]), k = 1 .. length['shortname'](L1))]));
 = 
  "{ {0, 1}, {1, 2}, {1, 10}, {2, 3}, {3, 4}, {4, 5},

    {4, 9}, {5, 6}, {6, 7}, {7, 8},{8, 9}, {10, 11}, {11, 12},

    {11, 16}, {12, 13}, {13, 14}, {14, 15}, {15, 16}}"

@Carl Love Actually, as I mentioned before, sometimes such a list does perform a permutation, but in my opinion, we do not need to regard it as a permutation. 
Here we convert one cycles into (another) rules: 

cycles := [[g, d, c], [e, a], [f, d, c], [b]]:
use ListTools in rules := (combinat['randperm']@MakeUnique@curry(`?()`,`=`)~@FlattenOnce)([seq(Transpose([k,Rotate(k,1)]),k  in  cycles),[[a,b](*,[f,g]*)]]) end use: # a = b obfuscates the rules here.

Yet I have no idea how to reconvert rules back into cycles. 
Comparison: 
 

Download trivial.mw

@Carl Love Sorry, I don't know if such algorithms exist. This instance is adapted from the last example of MMA's Apply (which is more or less similar to Maple's `?()`). Unfortunately, the original function that occured in the help page only has limited functionalities. (So it is incorrect in general.)

@Carl Love Since a＝b cannot become or form a cycle (∵ b＝a is missing or lacking), the output should exclude [a, b].

@Carl Love Surely need not necessarily be a permutation; They are just a list of "ordered pairs". (However, sometimes such a list does perform a permutation.)

Remark. Something like this: the rules (instead of equalities) g＝d, c＝g, d＝c construct a cycle g→d→c→g, so the result includes [g, d, c] (and for the same reason, the result includes [f, d, c] as well).

@dharr & @acer Thanks. It appears that nothing returns when I just give simple bounds on variables: 
 

Download anExplicitEnumeration.mw

@Kitonum I find that to obtain the Sol, this is enough: 

identify(solve(eqs =~ 0.));
 = 
 /         14                1        1        1        1        
{ k[1] = - -- k[10] - k[9] - - k[7] + - k[4] + - k[8] - - k[5], k
 \         3                 3        3        3        3        

          155                   10        7        13     
  [2] = - --- k[10] - 11 k[9] - -- k[7] + - k[4] + -- k[8]
           3                    3         3        3      

     4       
   - - k[5], 
     3       

         44                  4        16        4        1       
  k[3] = -- k[10] + 3 k[9] + - k[7] - -- k[4] - - k[8] + - k[5], 
         3                   3        3         3        3       

  k[4] = k[4], k[5] = k[5], 

         122                  4        5        13        1       
  k[6] = --- k[10] + 8 k[9] + - k[7] + - k[4] - -- k[8] + - k[5], 
          3                   3        3        3         3       

                                                      \ 
  k[7] = k[7], k[8] = k[8], k[9] = k[9], k[10] = k[10] }
                                                      / 

As @acer says, using a finite working precision may lead to less correct answers, but this way is feasible after all. Thanks.

@dharr Sorry for late reply. I think that the third form (i.e., c) is more suitable for representing the generic solutions. Many thanks.

@dharr @Axel Vogt Thanks. Is it possible to convert it into the following more ”symmetric“ form? 

[RootOf(_Z^3 - 3*_Z^2 - 10*_Z - 1, index = 3), -4/5*RootOf(_Z^3 - 3*_Z^2 - 10*_Z - 1, index = 3)^2 + 19/5*RootOf(_Z^3 - 3*_Z^2 - 10*_Z - 1, index = 3) + 3/5, 1]:
 = 
[RootOf(_Z^3 - 3*_Z^2 - 10*_Z - 1, index = 3), RootOf(_Z^3 + 10*_Z^2 + 3*_Z - 1, index = 3), 1]:
 = 
[RootOf(_Z^3 - 4*_Z^2 + _Z + 1, index = 1)/RootOf(_Z^3 - 4*_Z^2 + _Z + 1, index = 3), RootOf(_Z^3 - 4*_Z^2 + _Z + 1, index = 2)/RootOf(_Z^3 - 4*_Z^2 + _Z + 1, index = 3), 1]:

@C_R @dharr Thanks for your proposals.