JavaScript (ES6), 44 bytes

Shorter version suggested by @nwellnhof

Expects a deck with 1-indexed cards as input.

f=(a,x=1)=>a[x]-2&&1+f(a,x*2%(a.length-1|1))

Try it online!

Given a deck $[c_0,ldots,c_L-1]$ of length $L$, we define:

$$x_n=begincases
2^nbmod L&textif Ltext is odd\
2^nbmod (L-1)&textif Ltext is even\
endcases$$

And we look for $n$ such that $c_x_n=2$.

JavaScript (ES6),  57 52  50 bytes

Expects a deck with 0-indexed cards as input.

f=(a,x=1,k=a.length-1|1)=>a[1]-x%k&&1+f(a,x*-~k/2)

Try it online!

How?

Since JS is lacking native support for extracting array slices with a custom stepping, simulating the entire riffle-shuffle would probably be rather costly (but to be honest, I didn't even try). However, the solution can also be found by just looking at the 2nd card and the total number of cards in the deck.

Given a deck of length $L$, this code looks for $n$ such that:

$$c_2equivleft(frack+12right)^npmod k$$

where $c_2$ is the second card and $k$ is defined as:

$$k=begincases
L&textif Ltext is odd\
L-1&textif Ltext is even\
endcases$$

Python 2, 39 bytes

f=lambda x:x[1]-2and-~f(x[::2]+x[1::2])

Try it online!

-4 thanks to Jonathan Allan.

Jelly, 8 bytes

ŒœẎ$ƬiṢ’

Try it online!

How?

ŒœẎ$ƬiṢ’ - Link: list of integers A
 Ƭ - collect up until results are no longer unique...
 $ - last two links as a monad:
Œœ - odds & evens i.e. [a,b,c,d,...] -> [[a,c,...],[b,d,...]]
 Ẏ - tighten -> [a,c,...,b,d,...]
 Ṣ - sort A
 i - first (1-indexed) index of sorted A in collected shuffles
 ’ - decrement

Perl 6, 34 32 bytes

-2 bytes thanks to Jo King

(.[(2 X**^$_)X%$_-1+

Try it online!

Similar to Arnauld's approach. The index of the second card after n shuffles is 2**n % k with k defined as in Arnauld's answer.

Perl 6, 36 34 32 bytes

-2 bytes thanks to nwellnhof

$!=.[1]-2&&$!(.sort:$++%2)+1

Try it online!

Reverse riffle shuffles by sorting by the index modulo 2 until the list is sorted, then returns the length of the sequence.

It's funny, I don't usually try the recursive approach for Perl 6, but this time it ended up shorter than the original.

Explanation:

$!=.[1]-2&&$!(.sort:$++%2)+1
$!= # Assign the anonymous code block to $!
 .[1]-2&& # While the list is not sorted
 $!( ) # Recursively call the function on
 .sort:$++%2 # It sorted by the parity of each index
 +1 # And return the number of shuffles

R, 58 55 45 bytes

a=scan();while(a[2]>2)a=matrix(a,,2,F<-F+1);F

Try it online!

Simulates the sorting process. Input is 1-indexed, returns FALSE for 0.

APL (Dyalog Unicode), 35 26 23 22 bytes^SBCS

⍳⍴⍵]

Try it online!

Thanks to Adám for the help, Erik the Outgolfer for -3 and ngn for -1.

The TIO link contains two test cases.

Explanation:

⍳⍴⍵]
⍳⍴⍵] ⍝ function takes one argument: ⍵, the array
 ⍵≡⍳≢⍵ ⍝ if the array is sorted:
 ⍵≡⍳≢⍵ ⍝ array = 1..length(array)
 :0 ⍝ then return 0
 ⋄ ⍝ otherwise
 1+ ⍝ increment
 ∇ ⍝ the value of the recursive call with this argument:
 ⍵[ ] ⍝ index into the argument with these indexes:
 ⍳⍴⍵ ⍝ - generate a range from 1 up to the size of ⍵
 2| ⍝ - %2: generate a binary mask like [1 0 1 0 1 0]
 ⍒ ⍝ - grade (sorts but returns indexes instead of values), so we have the indexes of all the 1s first, then the 0s.

Old solution:
i⊣i+←1⋄⍵[⍒2⍣∧/2≤/⍵⍵⊣i←¯1

¹

05AB1E (legacy), 9 bytes

[DāQ#ι˜]N

Try it online!

Explanation

[ # ] # loop until
 ā # the 1-indexed enumeration of the current list
 D Q # equals a copy of the current list
 ι˜ # while false, uninterleave the current list and flatten
 N # push the iteration index N as output

Java (JDK), 59 bytes

a->1)]>2;)c++;return c;

Try it online!

Works reliably only for arrays with a size less than 31 or solutions with less than 31 iterations. For a more general solution, see the following solution with 63 bytes:

a->1);return c;

Try it online!

Explanation

In a riffle, the next position is the previous one times two modulo either length if it's odd or length - 1 if it's even.

So I'm iterating over all indices using this formula until I find the value 2 in the array.

Credits

• -8 bytes thanks to Kevin Cruijssen. (Previous algorithm, using array)


• -5 bytes thanks to Arnauld.

APL(NARS), chars 49, bytes 98

0∧/¯1↓⍵≤1⌽⍵:⍺⋄(⍺+1)∇⍵[d],⍵[i∼d←↑¨i⊂⍨2∣i←⍳≢⍵]⍵

why use in the deepest loop, one algo that should be nlog(n), when we can use one linear n? just for few bytes more?
[⍵≡⍵[⍋⍵] O(nlog n) and the confront each element for see are in order using ∧/¯1↓⍵≤1⌽⍵ O(n)]test:

 f←0∧/¯1↓⍵≤1⌽⍵:⍺⋄(⍺+1)∇⍵[d],⍵[i∼d←↑¨i⊂⍨2∣i←⍳≢⍵]⍵
 f ,1
0
 f 1 2 3
0
 f 1,9,8,7,6,5,4,3,2,10
3
 f 1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20
17

Ruby, 42 bytes

f=->d,r=1~-d.max)]

Try it online!

How:

Search for number 2 inside the array: if it's in second position, the deck hasn't been shuffled, otherwise check the positions where successive shuffles would put it.

R, 70 72 bytes

x=scan();i=0;while(any(x>sort(x)))x=c(x[y<-seq(x)%%2>0],x[!y]);i=i+1;i

Try it online!

Now handles the zero shuffle case.

C (GCC) 64 63 bytes

-1 byte from nwellnhof

i,r;f(c,v)int*v;1);return~-r;

This is a drastically shorter answer based on Arnauld's and Olivier Grégoire's answers. I'll leave my old solution below since it solves the slightly more general problem of decks with cards that are not contiguous.

Try it online

C (GCC) 162 bytes

a[999],b[999],i,r,o;f(c,v)int*v;for(r=0;o=1;++r)!i)&o;if(o)return r;for(i+=o=c+1;i--;)v[i]=i<o/2?a[i]:b[i-o/2];

Try it online

a[999],b[999],i,r,o; //pre-declare variables
f(c,v)int*v; //argument list
 for(r=0;o=1;++r)!i)&o; //if out of order set o (ordered) to false
 if(o) //if ordered
 return r; //return number of shuffles
 //note that i==-1 at this point
 for(i+=o=c+1;i--;)//set i=c and o=c+1, loop through v
 v[i]=i<o/2?a[i]:b[i-o/2];//set first half of v to a, second half to b
 

Wolfram Language (Mathematica), 62 bytes

c=0;While[Sort[a]!=a,a=a[[1;;-1;;2]]~Join~a[[2;;-1;;2]];c++];c

Try it online!

Explanation

The input list is a . It is unriffled and compared with the sorted list until they match.

Red, 87 79 78 bytes

func[b][c: 0 while[b/2 > 2][c: c + 1 b: append extract b 2 extract next b 2]c]

Try it online!

Perl 5 -pa, 77 bytes

mappush@$_%2,$_0..$#F;$_=0;++$_,@s=sort$a-$b@F=@F[@0,@1]while"@F"ne"@s"

Try it online!

Pyth, 18 bytes

L?SIb0hys%L2>Bb1
y

Try it online!

-2 thanks to @Erik the Outgolfer.

The script has two line: the first one defines a function y, the second line calls y with the implicit Q (evaluated stdin) argument.

L?SIb0hys%L2>Bb1
L function y(b)
 ? if...
 SIb the Invariant b == sum(b) holds
 0 return 0
 h otherwise increment...
 y ...the return of a recursive call with:
 B the current argument "bifurcated", an array of:
 b - the original argument
 > 1 - same with the head popped off
 L map...
 % 2 ...take only every 2nd value in each array
 s and concat them back together

¹

Japt, 13 11 bytes

Taking my shiny, new, very-work-in-progress interpreter for a test drive.

g1 Í©ÒßUñÏu

Try it or run all test cases

g1 Í©ÒßUñÏu :Implicit input of integer array U
g1 :Get the element at 0-based index 1
 Í :Subtract from 2
 © :Logical AND with
 Ò : Negation of bitwise NOT of
 ß : A recursive call to the programme with input
 Uñ : U sorted
 Ï : By 0-based indices
 u : Modulo 2

J, 28 bytes

1#@}.(/:2|i.@#)^:(2<1