R, 69 bytes

for(i in 1:scan()-1)cat('<'[i%%2],rep('-',i/2),'>'[!i%%2],'

',sep='')

Try it online!

• -5 bytes thanks to @Giuseppe


• -3 bytes thanks to @Robert S.

Canvas, 10 bytes

⇵-×<ｎ¹［↔｝］

Try it here!

Python 2, 53 bytes

k=-1

exec"print'<'[k%2:]+'-'*k+k%2*'>';k+=1;"*input()

Try it online!

Commodore BASIC V2 (C64), 94 bytes

0inputn:fOi=1ton:oniaN1gO1:?"<";

1on-(i<3)gO2:fOj=1.5toi/2:?"-";:nE

2on-nOiaN1gO3:?">";

3?:nE

Not entirely sure about the byte count, this is based on the text representation for typing the valid program. It's a bit shorter on disk (91 bytes) because BASIC V2 uses a "tokenized" representation of programs.

Online Demo

Slightly "ungolfed":

0 inputn:fori=1ton:oniand1goto1:print"<";    :rem read n from user, loop to n, if odd skip "<"

1 on-(i<3)goto2:forj=1.5toi/2:print"-";:next :rem skip for i<3, print (i-1)/2 times "-"

2 on-notiand1goto3:print">";                 :rem if even skip ">"

3 print:next                                 :rem newline and next loop iteration

PowerShell, 62 56 50 bytes

param($n)(0..$n|%{($j='-'*$_)+'>';"<$j"})[0..--$n]

Try it online!

Loops from 0 up to input $n, each iteration creating two arrow strings. Those are then indexed with 0..--$n to pull out the correct number of elements.

Saved 6 bytes thanks to KGlasier.

Pyth, 17 bytes

m_W%d2+*-/d2@"><

Output is a list of strings. Try it online here.

m_W%d2+*-/d2@"><"dQ   Implicit: Q=eval(input())

                       Trailing "dQ inferred

m                  Q   Map [0-Q), as d, using:

          /d2            Floored division of d by 2

       *-               Repeat "-" the above number of times

      +                  Append to the above...

             @"><"d      Modular index d into "><" - yields ">" for even d, "<" for odd

                         - examples: d=4 gives "-->", d=7 gives "---<"

 _W                      Reverse the above if...

   %d2                   ... (d % 2) != 0

                       Implicit print result of the map

Java (JDK), 81 bytes

n->{for(int i=0;i<n;)System.out.printf(i%2<1?"<%s%n":"%s>%n","-".repeat(i++/2));}

Try it online!

Explanations

n->{                  // int-accepting consumer

 for(int i=0;i<n;)    //  for each i from 0 to n-1 included

  System.out.printf(  //   output on stdout with a pattern

   i%2<1              //    if i is even:

    ?"<%s%n"          //     use the left-arrow pattern

    :"%s>%n",         //    else: use the right-arrow pattern

   "-".repeat(i++/2)  //    fill the pattern with i/2 dashes, and increment i

  );                  // 

}                     //

SNOBOL4 (CSNOBOL4), 123 122 118 bytes

	N =INPUT - 1

P	H =X / 2

	Y =DUPL('-',H)

	OUTPUT =EQ(H,X - H) Y '>'	:S(I)

	OUTPUT ='<' Y

I	X =LT(X,N) X + 1	:S(P)

END	

Try it online!

JavaScript (ES6), 58 bytes

Returns a space-separated string.

n=>(g=p=>n--?k++&1?`<${p} `+g(p+'-'):p+'> '+g(p):'')(k='')

Try it online!

Jelly, 15 bytes

ị⁾><;’H”-ẋƲṚ⁸¡)

Try it online!

Haskell, 51 bytes

(`take`do b<-['-'<$[1..n]|n<-[0..]];[b++">",'<':b])

Try it online!

Explanation / Ungolfed

Using do-notation saves us a concat, using '-'<$[1..n] is shorter than replicate, and finally using infix-notation allows a pointfree function with take, undoing these would give:

f n = take n $ concat [ [b++">", '<':b] | n<-[0..], let b = replicate n '-' ]

Haskell, 41 bytes

(`take`g"")

g p=(p++">"):('<':p):g('-':p)

Try it online!

Plain old recursion: start with an emtpy string p, collect p with a right arrow, a left arrow with p and a recursive call with p one - longer. Take the first n items of this list.

Powershell, 51 bytes

param($n)0..$n|%{'-'*$_+'>';'<'+'-'*$_}|?{$n---gt0}

V, 22 bytes

i>

<Àñäkjjé-já-ñÀGjdG

Try it online!

Japt -m, 22 bytes

u ç'< +Uz ç'- +°Uu ç'>

Try it online!

Explanation:

                          #Implicitly map over the range [0..input) as U

u                         #U modulo 2

  ç'<                     #Print "<" that number of times (i.e. once, only if it's odd)

      +                   #Concat

       Uz                 #U integer divide by 2

          ç'-             #Print "-" that number of times

              +           #Concat

               °Uu        #U+1 modulo 2

                   ç'>    #Print ">" that number of times (i.e. once, only if it's even)