 <p>Your current search function doesn't actually do anything. I'm assuming this is homework so, no free lunch ;)</p> <p>The simplest approach would be to have two recursive functions:</p> <pre><code>public boolean findStart(String word, int x, int y) </code></pre> <p>This will do a linear search of the board looking for the first character in <code>word</code>. If your current location doesn't match, you call yourself with the next set of coords. When it finds a match, it calls your second recursive function using <code>word</code>, the current location, and a new, empty 4x4 matrix:</p> <pre><code>public boolean findWord(String word, int x, int y, int[][] visited) </code></pre> <p>This function first checks to see if the current location matches the first letter in <code>word</code>. If it does, it marks the current location in <code>visited</code> and loops through all the adjoining squares <em>except ones marked in <code>visited</code></em> by calling itself with <code>word.substring(1)</code> and those coords. If you run out of letters in <code>word</code>, you've found it and return true. Note that if you're returning false, you need to remove the current location from <code>visited</code>.</p> <p>You <em>can</em> do this with one function, but by splitting out the logic I personally think it becomes easier to manage in your head. The one downside is that it does do an extra comparison for each first letter in a word. To use a single function you would need to keep track of what "mode" you were in either with a boolean or a depth counter.</p> <p><strong>Edit:</strong> Your longest word should only be <code>16</code>. Boggle uses a 4x4 board and a word can't use the same location twice. Not that this really matters, but it might for the assignment. Also note that I just did this in my head and don't know that I got it 100% right - comments appreciated. </p> <p><strong>Edit in response to comments:</strong> </p> <p>Here's what your iterative <code>locate</code> would look like using the method I outline above:</p> <pre><code>public boolean locate(String word) { for (int row = 0; row &lt; 4; row++) { for (int col =0; col &lt; 4; col++) { if (word.charAt(0) == letters[row][col]) { boolean found = findWord(word, row, col, new boolean[4][4]); if (found) return true; } } } return false; } </code></pre> <p>The same thing recursively looks like the following, which should help:</p> <pre><code>public boolean findStart(String word, int x, int y) { boolean found = false; if (word.charAt(0) == letters[x][y]) { found = findWord(word, x, y, new boolean[4][4]); } if (found) return true; else { y++; if (y &gt; 3) { y = 0; x++; } if (x &gt; 3) return false; } return findStart(word, x, y); } </code></pre> <p>So here's <code>findWord()</code> and a helper method <code>getAdjoining()</code> to show you how this all works. Note that I changed the <code>visited</code> array to <code>boolean</code> just because it made sense:</p> <pre><code>public boolean findWord(String word, int x, int y, boolean[][] visited) { if (letters[x][y] == word.charAt(0)) { if (word.length() == 1) // this is the last character in the word return true; else { visited[x][y] = true; List&lt;Point&gt; adjoining = getAdjoining(x,y,visited); for (Point p : adjoining) { boolean found = findWord(word.substring(1), p.x, p.y, visited); if (found) return true; } visited[x][y] = false; } } return false; } public List&lt;Point&gt; getAdjoining(int x, int y, boolean[][] visited) { List&lt;Point&gt; adjoining = new LinkedList&lt;Point&gt;(); for (int x2 = x-1; x2 &lt;= x+1; x2++) { for (int y2 = y-1; y2 &lt;= y+1; y2++) { if (x2 &lt; 0 || x2 &gt; 3 || y2 &lt; 0 || y2 &gt; 3 || (x2 == x &amp;&amp; y2 == y) || visited[x2][y2]) { continue; } adjoining.add(new Point(x2,y2)); } } return adjoining; } </code></pre> <p>So now, after you get input from the user as a <code>String</code> (word), you would just call:</p> <pre><code>boolean isOnBoard = findStart(word,0,0); </code></pre> <p>I did this in my head originally, then just went down that path to try and show you how it works. If I were to actually implement this I would do some things differently (mainly eliminating the double comparison of the first letter in the word, probably by combining the two into one method though you can do it by rearranging the logic in the current methods), but the above code does function and should help you better understand recursive searching. </p>