Python 2, 47 bytes

lambda l:l.sort(key=len)or l[1::2][::-1]+l[::2]

Try it online!

Jelly, 9 8 bytes

LÞŒœm"-Ẏ

Try it online!

LÞŒœṚ;¥/

is also 8 bytes.

Thanks to @EriktheOutgolfer and @JonathanAllan for both offering golfs to save a byte.

C# (Visual C# Interactive Compiler), 89 bytes

n=>(n=n.OrderBy(x=>x.Length)).Where((a,b)=>b%2>0).Reverse().Concat(n.Where((a,b)=>b%2<1))

Try it online!

K (oK), 24 bytes

Solution:

x(<#:'x)(|&~w),&w:2!!#x:

Try it online!

Explanation:

Generate the 6 4 2 0 1 3 5 sequence, use that to index into the ascending lengths of input, and use that to index into the original array:

x(<#:'x)(|&~w),&w:2!!#x: / the solution

                      x: / save input as x

                     #   / count (#) of x

                    !    / range 0 to ...

                  2!     / modulo 2

                w:       / save as w

               &         / indices where true

              ,          / join with

        (    )           / do this together

           ~w            / not (~) w

          &              / indices where true

         |               / reverse

 (     )                 / do this together

   #:'x                  / count (#:) of each (') x

  <                      / indices to sort ascending

x                        / index into x

R, 63 48 bytes

function(L)c(rev(o<-L[order(nchar(L))]),o)[!0:1]

Try it online!

Sort by string lengths, then combine the reversed list with the sorted list, finally, take every 2nd element, starting at 1-based index 1.

J, 12 bytes

,~`,/@:#&> 

Try it online!

We sort it down first.

Then we reduce the list form right to left, but alternating which side we put the new element on. Done.

PHP, 144 bytes

function($a){usort($a,function($b,$c){return strlen($b)-strlen($c);});$e=;foreach($a as$d)[array_unshift,array_push][++$i%2]($e,$d);return$e;}

Try it online!

Sadly, PHP just doesn't have a lot of syntactic sugar to make this shorter. Submitting it anyway!

APL+WIN, 31 38 bytes

See Adams comment

⊃n[(⍳⍴n)~a],⌽n[a←2×⍳⌊.5×⍴n←n[⍒∊⍴¨n←⎕]]

Try it online Courtesy of Dyalog Classic!

Prompts for a nested vector of strings

PowerShell, 66 bytes

1..($a=$args|sort l*).count|?{$_%2}|%{$a[-$_];$x=,$a[-++$_]+$x};$x

Try it online!

Takes input via splatting, which manifests on TIO as separate command-line arguments. sorts on the length, stores that into $a, and constructs a range from 1 up to the count of input strings. We then pull out only the odd ones ?{$_%2} and feed those into a loop |%{...}. Each iteration, we put the "last", then the "third from last", and so on onto the pipeline with $a[-$_]. Separately, we also accumulate into $x the "second from last", "fourth from last", etc. Out of the loop and the pipeline is flushed (so those elements are output) and then we output $x. In both instances, the default output gives us newlines between items automatically.

Ruby, 51 bytes

->l{r=1;l.sort_by!(&:size).map{l[r-=2]||(l*2)[~r]}}

Try it online!

Japt, 8 bytes

ñÊó g0_w

-3 bytes thanks to Shaggy!

Try it

Javascript 79 bytes

Takes input as an array of strings, outputs an arrow-sorted array of strings.

f=s=>s.sort((a,b)=>a.length-b.length).reduce((m,x,i)=>i%2?[...m,x]:[x,...m],)

Explanation

f = s =>                             // take input as an array of strings s

  s.sort((a,b)=>a.length-b.length)   // sort input by string length

  .reduce(                           // reduce

    (m,x,i)=>i%2?[...m,x]:[x,...m],  // if index is even, stick string x at the end of the memo

                                     // array, else at the beginning

                                   // memo initialized to empty array

  )

Retina, 26 bytes

N$`

$.&

*,2,^A`.+

,2,G`.+

Try it online! Explanation:

N$`

$.&

Sort the lines in ascending order of length ($.& returns the length of the line).

*,2,^A`.+

Temporarily delete alternate lines and output the remaining lines in reverse order.

,2,G`.+

Keep the only lines that were temporarily deleted and output them.

Gaia, 10 bytes

el∫v:v+2%ụ

Try it online!

e		| eval as Gaia code (list of strings)

 l∫		| ∫ort by lengths (ascending)

   v:v		| reverse, dup, reverse

      +		| concatenate lists

       2%	| take every other element

         ụ	| join by newlines and output

C (gcc), 136 bytes

S(a,b)char**a,**b;{a=strlen(*b)-strlen(*a);}f(l,s,o,t,i,b,e)char**s,**o,*t;{qsort(s,l,8,S);e=l-1;for(i=b=0;i-l;++i)o[i%2?b++:e--]=s[i];}

Try it online!

The function f is the solution. It takes the number of strings, the strings themselves, and the output buffer as arguments (plus four more used internally).

MATLAB, 92 bytes

function f(y);[B,I]=sort(cellfun(@(x)length(x),y));disp({y{I(end:-2:1)},y{I(1:2:end)}}');end

Takes input as cell array of strings, outputs column of strings (not sure if that's legal)

> s = {'qweq qwe qw','qweqw','12132132131231231','asdasdasda','qwe','w'};

> f(s);

> 

> function f(y);[B,I]=sort(cellfun(@(x)length(x),y));disp({y{I(end:-2:1)},y{I(1:2:end)}}');end

> 

> >> 

>     '12132132131231231'

>     'asdasdasda'

>     'qwe'

>     'w'

>     'qweqw'

>     'qweq qwe qw'

T-SQL, 99 bytes

Input is a table

DECLARE @ table(a varchar(80))

INSERT @ values

('sheriffOfNottingham'),('kingRichard'),('maidMarian'),

('bow'),('arrows'),('princeJohn'),('sherwoodForest')



SELECT a FROM(SELECT*,row_number()over(order by

len(a))r,sum(1)over()c FROM @)x

ORDER BY abs(c/2-r)

Try it online

PowerShell, 49 bytes

$args|sort l*|sort{$_.Length*($global:x=-$x*2+1)}

Try it online!

The double distillation.

Javascript 95 Bytes

s=>s.sort((x,y)=>x.length-y.length).reduce((a,e,i)=>{i%2?a.push(e):a.unshift(e);return a;},);