Python 2, 47 bytes

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

Try it online!

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.

Javascript 77 bytes

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

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

Explanation

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
 )

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

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.

Ruby, 51 bytes

->lr=1;l.sort_by!(&:size).mapl[r-=2]

Try it online!

05AB1E, 6 5 bytes

Saved 1 byte thanks to Kevin Cruijssen

I/O is a list of strings.

Link is modified for newline separated I/O for easier testing.

éι`Rì

Try it online!

Explanation

é # sort by length ascending
 ι # uninterleave into 2 parts, both sorted ascending
 ` # push the 2 parts separately to the stack
 R # reverse the second part
 ì # and append it to the first

J, 11 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.

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.

PHP, 144 141 bytes

function($a)usort($a,function($b,$c)return strlen($b)-strlen($c););$e=[];foreach($a as$d)(array_.[unshift,push][++$i%2])($e,$d);return$e;

Try it online!

-3 bytes thanks to @Ismael Miguel!

MATLAB, 87 bytes

function f(y);[B,I]=sort(cellfun(@(x)length(x),y));yflip(I(1:2:end)),yI(2:2: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)
> >> 
> ans =
> 
> 6×1 cell array
> 
> 'qweq qwe qw' 
> 'qweqw' 
> 'qwe' 
> '1234' 
> 'asdasdasda' 
> '12132132131231231'

PS: Thanks Sanchises for pointing to a bug with odd-length inputs

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

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

Japt, 8 bytes

ñÊó g0_w

-3 bytes thanks to Shaggy!

Try it

PowerShell, 49 bytes

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

Try it online!

The double distillation.

T-SQL, 84 bytes

Input is a table variable

SELECT a FROM(SELECT*,row_number()over(order by len(a))r
FROM @)x order by(r%2-.5)*r

Try it online

Perl 6, 31 bytes

*.sort(&chars).sort:$++%2*$--

Try it online!

Sort by string length, then by static sequence 0, -1, 0, -3, 0, -5, ...

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;,[]);

Red, 116 101 bytes

func[b][sort/compare b func[x y][(length? x)> length? y]collect[forall b[keep take b]keep reverse b]]

Try it online!

perl 5 (-p0777F/n/ -M5.01), 59 bytes

for$x(sort$b=~y///c-length$a@F)--$}%$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


TIO