Question

I decided to implement a very simple program recursively, to see how well Java handles recursion*, and came up a bit short. This is what I ended up writing:

public class largestInIntArray {
  public static void main(String[] args)
  {
    // These three lines just set up an array of ints:
    int[] ints = new int[100];
    java.util.Random r = new java.util.Random();
    for(int i = 0; i < 100; i++) ints[i] = r.nextInt();

    System.out.print("Normal:"+normal(ints,-1)+" Recursive:"+recursive(ints,-1));
  }

  private static int normal(int[] input, int largest) {
    for(int i : input)
      if(i > largest) largest = i;

    return largest;
  }

  private static int recursive(int[] ints, int largest) {
    if(ints.length == 1)
      return ints[0] > largest ? ints[0] : largest;

    int[] newints = new int[ints.length - 1];
    System.arraycopy(ints, 1, newints, 0, ints.length - 1); 

    return recursive(newints, ints[0] > largest ? ints[0] : largest);
  }
}

And that works fine, but as it’s a bit ugly I wondered if there was a better way. If anyone has any thoughts/alternatives/syntactic sugar to share, that’d be much appreciated!

P.s. If you say “use Lisp” you win nothing (but respect). I want to know if this can be made to look nice in Java.

*and how well I handle recursion

Answer 1

2 improvements:

• no copy of the array (just using the offset)

• no need to give the current max

  private static int recursive(int[] ints, int offset) {
      if (ints.length - 1 == offset) {
          return ints[offset];
      } else {
          return Math.max(ints[offset], recursive(ints, offset + 1));
      }
  }
  

Start the recursion with recursive(ints, 0).