Python 2, 84 80 78 76 bytes

lambda a:[''.join(sorted(a,key=lambda s:'.'in s or s+s)[::i])for i in[-1,1]]

Try it online!

_{-2 bytes, thanks to Arnauld}

05AB1E, 11 bytes

œJΣ'.¡ï}Á2£

Try it online!
or as a Test Suite

Explanation

 œ             # get permutations of input

  J            # join each

   Σ    }      # sort by

    '.¡        # splitting into [before decimal, after decimal]

       ï       # and converting each to int

         Á     # rotate the result right

          2£   # and take the first 2 values

JavaScript (ES6), 68 66 bytes

a=>[1,-1].map(n=>a.sort((a,b)=>[a%1||a]+b<[b%1||b]+a?n:-n).join``)

Try it online!

How?

We use the following test to compare two values in the input array:

[a % 1 || a] + b < [b % 1 || b] + a

The expression x % 1 || x returns the decimal part of $x$ if $x$ is a decimal number, or leaves $x$ unchanged otherwise.

The expression [x % 1 || x] + y coerces the above result to a string and concatenates it with the other value.

If there's a decimal number in the list, it must always be considered as the smallest value. By applying our conversion, a decimal number is turned into a string starting with "0.", which is lexicographically ordered before anything else.

Examples:

  a |   b | [a%1||a]+b | [b%1||b]+a

----+-----+------------+------------

  4 |   5 | "45"       | "54"

 10 |  11 | "1011"     | "1110"

  8 |  80 | "880"      | "808"

  7 | 9.5 | "79.5"     | "0.57"

Japt, 14 11 bytes

á m¬ñn é v2

Try it

1 byte saved thanks to Luis, please +1 his solution too.

á               :Permutations

  m             :Map

   ¬            :  Join

    ñ           :Sort by

     n          :  Converting each to a number

       é        :Rotate right

         v2     :Remove & return the first 2 elements

Japt, 14 11 10 bytes

á m¬ñn gJò

Try it online!

Jelly, 6 bytes

Œ!VṢ.ị

Try it online!

Explanation:

Œ!VṢ.ị Arguments: x

Œ!     Permutations of x

  V    Concatenate the representations of each permutation's elements and evaluate the result as Jelly code

   Ṣ   Sort

    .ị Get element at index 0.5, i.e. elements at indices 0 (last) and 1 (first)

Ruby, 56 45 bytes

->a{a.permutation.map{|p|p.join.to_f}.minmax}

Try it online!

-11 bytes, thanks Jordan

Pyth, 13 12 bytes

hM_BSvsM.p`M

Outputs in form [smallest, largest]. Try it online here, or verify all the test cases at once here.

hM_BSvsM.p`MQ   Implicit: Q=eval(input())

                Trailing Q inferred

          `MQ   Stringify all elements of Q

        .p      Generate all permutations of the above

      sM        Concatenate each permutation

     v          Evaluate each as a number

    S           Sort them

  _B            Pair the sorted list with its reverse

hM              Take the first element of each, implicit print

Edit: Saved a byte by taking stringification out of the mapping function. Previous version: hM_BSmvs`Md.p

Perl 6, 41 bytes

{.max,.min}o+<<*.permutations.map(*.join)

Try it online!

Alternatives:

{.max,.min}o+<<*.permutations.map:{.join}

{.max,.min}o{[map +*.join,.permutations]}

{.max,.min}o{+<<map *.join,.permutations}

Husk, 10 bytes

§,▼▲morṁsP

Try it online or verify all!

Explanation

§,▼▲m(rṁs)P  -- example input: [2,3,1.1]

          P  -- permutations: [[2,3,1.1],[3,2,1.1],[1.1,3,2],[3,1.1,2],[1.1,2,3],[2,1.1,3]]

    m(   )   -- map the following

                (example with [1.1,2,3])

       ṁs    -- | show each and join: "1.123"

      r      -- | read: 1.123

             -- : [231.1,321.1,1.132,31.12,1.123,21.13]

§,           -- fork and join as tuple

  ▼          -- | min: 1.123

   ▲         -- | max: 321.1

             -- : (1.123,321.1)