Jelly, 15 bytes

µ×3żHḞḢḟȯ1Ṫ;µ¡Ḣ

A full program accepting the integer, n (1-based), from STDIN which prints the result.

Try it online!

How?

µ×3żHḞḢḟȯ1Ṫ;µ¡Ḣ - Main Link: no arguments (implicit left argument = 0)

µ           µ¡  - repeat this monadic chain STDIN times (starting with x=0)

                -                   e.g. x = ...  0      [1,0]            [9,3,1,0]

 ×3             -   multiply by 3                 0      [3,0]            [27,9,3,0]

    H           -   halve                         0      [1.5,0]          [4.5,1.5,0.5,0]

   ż            -   zip together                  [0,0]  [[3,1.5],[0,0]]  [[27,4.5],[9,1.5],[3,0.5],[0,0]]

     Ḟ          -   floor                         [0,0]  [[3,1],[0,0]]    [[27,4],[9,1],[3,0],[0,0]]

      Ḣ         -   head                          0      [3,1]            [27,4]

       ḟ        -   filter discard if in x        []     [3]              [27,4]

        ȯ1      -   logical OR with 1             1      [3]              [27,4]

          Ṫ     -   tail                          1      3                4

           ;    -   concatenate with x            [1,0]  [3,1,0]          [4,9,3,1,0]

              Ḣ - head                            1      3                4

                - implicit print

JavaScript (ES6),  55 51  50 bytes

Saved 1 byte thanks to @EmbodimentofIgnorance
Saved 1 byte thanks to @tsh

n=>eval("for(o=[p=2];n--;)o[p=o[q=p>>1]?3*p:q]=p")

Try it online!

Perl 6, 51 bytes

{(1,3,{first *∉@_,@_[*-1]+>1,3*@_[*-1]}...*)[$_]}

Try it online!

Returns the 0-indexed element in the sequence. You can change this to 1-indexed by changing the starting elements to 0,1 instead of 1,3

Explanation:

{                                               }  # Anonymous code block

 (                                     ...*)[$_]   # Index into the infinite sequence

  1,3                                              # That starts with 1,3

     ,{                               }            # And each element is

       first                                       # The first of

                  @_[*-1]+>1                         # The previous element bitshifted one

                            ,3*@_[*-1]               # Triple the previous element

             *∉@_,                                 # That hasn't appeared in the sequence

J, 47 40 bytes

[:{:0 1(],<.@-:@{:@](e.{[,3*{:@])])^:[~]

Try it online!

ungolfed

[: {: 0 1 (] , <.@-:@{:@] (e. { [ , 3 * {:@]) ])^:[~ ]

Direct translation of the definition into J. It builds bottom up by using ^: to iterate from the starting value the required number of times.

05AB1E, 16 15 bytes

Saved 1 byte thanks to Kevin Cruijssen.

0-indexed.

¾ˆ$FDˆx3*‚;ï¯Kн

Try it online!

Explanation

Using n=1 as example

¾ˆ                 # initialize global array as [0]

  $                # initialize stack with 1, input

   F               # input times do:

    Dˆ             # duplicate current item (initially 1) and add one copy to global array

                   # STACK: 1, GLOBAL_ARRAY: [0, 1]

      x            # push Top_of_stack*2

                   # STACK: 1, 2, GLOBAL_ARRAY: [0, 1]

       3*          # multiply by 3

                   # STACK: 1, 6, GLOBAL_ARRAY: [0, 1]

         ‚;ï       # pair and integer divide both by 2

                   # STACK: [0, 3], GLOBAL_ARRAY: [0, 1]

            ¯K     # remove any numbers already in the global array

                   # STACK: [3], GLOBAL_ARRAY: [0, 1]

              н    # and take the head

                   # STACK: 3

Jelly, 21 bytes

Ø.;0ị×3$:2$:2eɗ?Ɗ$⁸¡Ṫ

Try it online!

A monadic link that takes zero-indexed $n$ as the argument and returns $a(n)$.

Java 10, 120 99 bytes

n->{var L=" 1 0 ";int r=1,t;for(;n-->0;L+=r+" ")if(L.contains(" "+(r=(t=r)/2)+" "))r=t*3;return r;}

Try it online.

Explanation:

n->{                              // Method with integer as both parameter and return-type

  var L=" 1 0 ";                  //  Create a String that acts as 'List', starting at [1,0]

  int r=1,                        //  Result-integer, starting at 1

      t;                          //  Temp-integer, uninitialized

  for(;n-->0;                     //  Loop the input amount of times:

      L+=r+" "))                  //    After every iteration: add the result to the 'List'

                          t=r     //   Create a copy of the result in `t`

                       r=(...)/2  //   Then integer-divide the result by 2

    if(L.contains(" "+(...)+" ")) //   If the 'List' contains this result//2:

      r=t*3;                      //    Set the result to `t` multiplied by 3 instead

  return r;}                      //  Return the result

Japt, 15 14 bytes

1-indexed.

@[X*3Xz]kZ Ì}g

Try it

@[X*3Xz]kZ Ì}g     :Implicit input of integer U

             g     :Starting with the array [0,1] do the following U times, pushing the result to the array each time

@                  :  Pass the last element X in the array Z through the following function

 [                 :    Build an array containing

  X*3              :      X multiplied by 3

     Xz            :      X floor divided by 2

       ]           :    Close array

        kZ         :    Remove all elements contained in Z

           Ì       :    Get the last element

            }      :  End function

                   :Implicit output of the last element in the array

Haskell, 67 65 bytes

(h[1,0]!!)

h l@(a:o)|elem(div a 2)o=a:h(3*a:l)|1>0=a:h(div a 2:l)

Try it online!

Uses 0-based indexing.

EDIT: saved 2 bytes by using elem instead of notElem and switching conditions

Python 2, 66 bytes

l=lambda n,p=1,s=[0]:p*(n<len(s))or l(n,3*p*(p/2in s)or p/2,[p]+s)

Try it online!

Uses zero-based indexing. The lambda does little more than recursively building up the sequence and returning as soon as the required index is reached.

Wolfram Language (Mathematica), 63 bytes

(L=Last)@Nest[{##,If[FreeQ[#,x=⌊L@#/2⌋],x,3L@#]}&,{0,1},#]&

Try it online!

This is 0-indexed

(In TIO I added -1 in every test case)

Ruby, 54 52 48 bytes

->n{*s=0;j=2;n.times{s<<j=s==s-[j/2]?j/2:j*3};j}

Try it online!

C++ (gcc), 189 180 bytes

-9 bytes to small golfing

#import<vector>

#import<algorithm>

int a(int n){std::vector<int>s={1};for(int i=0;i<n;++i)s.push_back(i&&std::find(s.begin(),s.end(),s[i]/2)==s.end()?s[i]/2:3*s[i]);return s[n-1];}

Try it online!

Computes the sequence up to n, then returns the desired element. Slow for larger indices.

Stax, 14 bytes

üÑα↕○Ü1∟¡f↑ô┬♥

Run and debug it

Zero-indexed.

Python 2, 62 bytes

a=lambda n:n<1or a(n-1)*6**(a(n-1)//2in[0]+map(a,range(n)))//2

Try it online!

Returns True for a(0). 0-indexed.

Python 3, 105 103 100 95 83 bytes

-2 bytes thanks to agtoever
-12 bytes thanks to ArBo

def f(n):

 s=0,1

 while len(s)<=n:t=s[-1]//2;s+=(t in s)*3*s[-1]or t,

 return s[-1]

Try it online!

Gaia, 22 20 bytes

2…@⟨:):3פḥ⌋,;D)+⟩ₓ)

Try it online!

0-based index.

Credit to Shaggy for the approach

2…			| push [0 1]

  @⟨		 ⟩ₓ	| do the following n times:

    :):			| dup the list L, take the last element e, and dup that

       3פḥ⌋,		| push [3*e floor(e/2)]

	     ;D		| take the asymmetric set difference [3*e floor(e/2)] - L

	       )+	| take the last element of the difference and add it to the end of L (end of loop)

		   )	| finally, take the last element and output it

;D

Haskell, 55 bytes

(1%[0]!!)

a%o|b<-div a 2=a:last(b:[3*a|elem b o])%(a:o)

Try it online!

Golfing user1472751's slick list-generation method.

Same length:

(1%[0]!!)

a%o=a:[x|x<-[div a 2,a*3],all(/=x)o]!!0%(a:o)

Try it online!