Question

I’m looking for some advice on a Java assignment. What I’m asked to do is perform different operations on numbers that are stored in a linked list, with each digit in a separate node. The point is to write a program that can do arithmetic on numbers that are very very large.

The particular problem that I’m looking for help on is for writing a method that compares two numbers, similar to regular compareTo() method for ints. It should return -1 if this.num < num, +1 if this.num > num, and 0 if they are equal.

What’s making this difficult for me is the fact that the assignment specifies that the linked lists should store the numbers in reverse order. For example, the linked list for the number 145 would look like:

5 => 4 => 1 => null

This makes it easier to add numbers together but it’s making it a headache for me when trying to compare. Here’s what I’ve come up with, the comments explain how it’s supposed to work.

public int compareTo(LLNum list)
{ // Compares two numbers.
  // If the two numbers are of a different length, clearly the shortest is the smallest.
  // If the two numbers are of equal length, call traverseToCompare to do the comparison.
  if (this.len > list.len)
  {
    compareResult = 1;
  }
  else if (this.len < list.len)
  {
    compareResult = -1;
  }
  else if (this.len == list.len)
  {
    traverseToCompare(this.head, list.head);
  }

  return compareResult;
}


public void traverseToCompare(ListNode node1, ListNode node2)
{ // In the case that both numbers are of the same length, recursively traverse the list.
  // compare each digit individually while unwinding the stack.
  // Once two digits are found to be different, break out of the unwinding (Note: I could not find a way of breaking out)
  // Since the dominant digit is at the tail end, this ensures the least number of   comparisons.
  if (node1 == null || node2 == null) 
  { // Base case. Handles the case where both numbers are identical.
    compareResult = 0;
    return;
  }
  traverseToCompare(node1.getNext(), node2.getNext());
  if (node1.getItem() > node2.getItem())
  {
    compareResult = 1;
  }
  if (node1.getItem() < node2.getItem())
  {
    compareResult = -1;
  }

  return; 
}

The numbers being in reverse order is what pulled me towards recursion. I thought I would recursively traverse the list and then compare each digit on the way out, and somehow break out of the recursion at the first digits that are not the same. I realize this is not a usual way to use recursion but I wasn’t sure how else to do it. Is there a way I could break without just throwing an exception? I think that might be a little too sloppy. Or any suggestions on how to do this without recursion?

Please don’t just give me some code to copy and paste. I’m just looking to be pointed in the right direction. Thanks!

Answer 1

If I had to do this I would first check the lengths of both lists (like you did). If they’re equal, a better way to do the comparison would be to create an iterator for each list. You can then increment the iterators at the same time and compare the values at that position in the linked lists. Doing it this way, you can simply stop comparing the lists once you have determined that one contains a larger number than the other.