Class 54: Comparing Lists

Held Wednesday, December 8, 1999

Overview

Today, we'll go over a variety of issues, from the subject matter of this course to ideas on comparing lists.

Notes

• Note that I've changed the topic for today's class.
• We will spend the first few minutes of class working on class evaluations.
  • The evaluation refers regularly to the subject matter of the course, so we'll spend a little time talking about what that is.
• I hope to hand back exam 3 tomorrow, but I spent most of last night just grading the first problem.
  • If you haven't given me a printed copy, please do so ASAP.
  • You each get 5 points of extra credit because I lost the bet in class yesterday.
  • Those of you who included the time for each problem get an extra 3 points, as it specified in the instructions.
• I'm working hard to get the MailMessage class ready. Given the delay, I cannot expect you to have perfectly working and integrated versions of your classes ready for Friday. Try to get me something that you would expect to work.
• Are there other questions on the project stuff?

Contents

• What is CSC152?
• Comparing Lists
  • Metrics for Equality
  • Metrics for Inequality
  • Evaluating Metrics
  • Special Cases
  • General Coding Issues
  • Implementing Metrics
  • Testing Our Implementations

Summary

• Assigned:
  • Final exam (due during finals week)
• Course evaluations
• Comparing lists
  • Criteria for evaluating metrics
  • Some sample metrics
  • Implementing those metrics

What is CSC152?

• The course evaluation form asks a number of questions of the form ``X helped me understand the subject matter of the course'' (emphasis mine).
• I will admit that I have philosophical differences with that phrasing, since I would hope that many Grinnell courses teach you about more than their ``subject matter''. For example, many course implicitly or explicitly cover writing, problem solving, oral presentation, group work, moral issues, and more without any of those being the subject matter of the course.
• We'll spend some time considering the ``subject matter'' of 152 as well as any related issues you think we've covered. I'd like to hear your perspectives before I give my own.

Comparing Lists

• Problem 1 of exam 3 was clearly quite difficult for many/all of you. Hence, I'd like to spend today's class going over possible solutions to that problem.
• As we develop solutions, we'll need to consider
  • Potential metrics for comparing lists
  • Criteria for comparing metrics
  • Special cases
  • General implementation issues
  • Implementation of specific metrics
  • Testing of those metrics

Metrics for Equality

These are some of the metrics I saw for equality.

• E1: Two lists are equal if they have the same length and the corresponding elements of the two lists are equal.
• E2: Two lists are equal if they have the same length.
• E3: Two nonempty lists are equal if they have the same first element.
• E4: Two nonempty lists are equal if they have the same greatest element.
• E5: Two lists are equal if they have the same length and the same elements, independent of order.

Metrics for Inequality

• L1: List A is less than list B iff the length of A is less than the length of B.
• L2: List A is less than list B iff the length of A is less than or equal to the length of B and each element of A is less than the corresponding element of B.
• L3: List A is less than list B iff more elements of A are less than the corresponding elements of B than vice versa.
• L4: List A is less than list B iff the first element of list A is less than the first element of list B.
• L5: List A is less than list B iff there is some element of list A that is less than the corresponding element of list B and all prior elements of list A are equal to the corresponding elements of list B. List A is also less than list B if list B has more elements and all the elements of list A are equal to the corresponding elements of list B.
• L6: List A is less than list B iff the largest element of list A is less than the largest element of list B.
• L7: List A is less than list B iff when sorted, the elements of sorted list A are all less than or equal to the corresponding elements of sorted list B and the lists are not equal.

Evaluating Metrics

• How can we evaluate or refine those metrics?
• I gave one criterion in class: For any two lists, A and B, one of the following must hold:
  • A < B
  • B < A
  • A == B
  • The two lists are incomparable
• We'll try applying that to each ``reasonable'' pair of metrics.
  • For example, we might observe that in the combination of E1 and L2, we must decide that two lists are incomparable (at least for inequality) if A has some elements that are smaller than the corresponding elements of B and some that are not smaller.
• Are there other criteria? Certainly.
• We'd like the metric to be reasonable intuitive.
• We'd like the metric to be easy to implement.

Special Cases

• We may also want to refine our metrics by considering some special cases.
• The one that most frequently comes to mind is what to do if one or both lists are empty.
  • And how do we check for that special case?
• A second one is what to do if we get an exception when we compare a pair of elements.
  • We may do different things for equality and inequality.
  • Whatever we do, we have to document it.
• A third has to do with comparing a list to itself. (Since we're probably using advance to step through the elements, we need to be careful not to advance twice on the same list.)

General Coding Issues

• Most implementations will have the general structure

  while there are elements left in both lists
    compare the corresponding elements of both lists and do something
    move on to the next element of both lists
  end while
  Do whatever is appropriate for when you run off the end of the lists.
  

• Some of you had some difficulty deciding how to implement that loop, given that the CursoredList interface lacks a hasMoreElements method.
• Here's one solution. It assumes that both lists are nonempty.

      // Are there more elements left in listA?
      boolean moreA = true;
      // Are there more elements left in listB?
      boolean moreB = true;
      // While there are elements left in both lists.
      while (moreA && moreB) {
        // Compare the corresponding elements of both lists.
        try {
          if (compare.lessThan(listA.getCurrent(), listB.getCurrent())) {
            // Do something
            ...
          }
        }
        catch (IncomparableException e) {
          // Do something
          ...
        }
        // Move on to the next element of both lists
        try { listA.advance(); }
        catch (Exception e) { moreA = false; }
        try { listB.advance(); }
        catch (Exception e) { moreB = false; }
      } // while there are more elements left in both lists.
      // One list is over.  Do whatever is appropriate.
      ...
  

Implementing Metrics

• We'll pick a metric and try to implement it together.

Testing Our Implementations

• How do we test our implementations? Mostly, by building a lot of lists and seeing what they do. We certainly want to verify that the first criterion holds for each list.
• What are some pairs that you might test? (Note that it might differ from metric to metric.)
  • Same length lists
  • Different length lists
  • Special cases
  • ...
• Here's a simple (not complete) tester:

  
  import Comparator;
  import CursoredList;
  import CursoredLinkedList;
  
  /**
   * Test a list comparator.
   */
  public class LCTester {
    /**
     * Perform some simple tests on a list comparator.
     */
    public LCTester(Comparator lcomp) {
      // Prepare for output.
      SimpleOutput out = new SimpleOutput();
      // Some sample arrays for later conversion to lists
      Object[] aaa = {"a", "a", "a"};
      Object[] aaaa = {"a", "a", "a", "a"};
      Object[] abc = {"a", "b", "c"};
      Object[] bac = {"b", "a", "c"};
      Object[] cba = {"c", "b", "a"};
      // Check one pair of equal lists.
      checkPair(out, lcomp, buildList(aaa), buildList(aaa));
      // Check two empty lists.
      checkPair(out, lcomp, new CursoredLinkedList(), new CursoredLinkedList());
      // Check one empty and one nonempty list.
      checkPair(out, lcomp, new CursoredLinkedList(), buildList(aaa));
      // Check various incomparable lists
      checkPair(out, lcomp, buildList(aaa), buildList(abc));
      checkPair(out, lcomp, buildList(abc), buildList(bac));
      // Check two inequal lists of different lengths
      checkPair(out, lcomp, buildList(aaa), buildList(aaaa));
    } // LCTester(Comparator)
  
    /**
     * Compare one pair of cursored lists.
     */
    public void checkPair(SimpleOutput out, Comparator lcomp,
                          CursoredList listA, CursoredList listB) {
      out.println("Comparing A:" + toString(listA) + " to B:" 
                  + toString(listB) + ".");
  
      out.print("  Equality: ");
      try {
        if (lcomp.equals(listA,listB)) 
          out.println("The two lists are equal");
        else
          out.println("The two lists are inequal");
      } // try
      catch (IncomparableException e) {
        out.println("The two lists are incomparable.");
      }
  
      out.print("  Inequality (A vs. B): ");
      try {
        if (lcomp.lessThan(listA,listB)) 
          out.println("A is less than B.");
        else
          out.println("A is not less than B.");
      } // try
      catch (IncomparableException e) {
        out.println("The two lists are incomparable.");
      } // catch
  
      out.print("  Inequality (B vs. A): ");
      try {
        if (lcomp.lessThan(listB,listA)) 
          out.println("B is less than A.");
        else
          out.println("B is not less than A.");
      } // try
      catch (IncomparableException e) {
        out.println("The two lists are incomparable.");
      } // catch
    }  // checkPair
  
    /**
     * Build a list, given an array of object.
     */
    public CursoredList buildList(Object[] elements) {
      CursoredList newList = new CursoredLinkedList();
      for (int i = elements.length-1; i >= 0; --i) {
        newList.addToFront(elements[i]);
      }
      return newList;
    } // buildList(Object[])
  
    /**
     * Turn a cursored list into a string.  May change the position
     * of the cursor.
     */
    public String toString(CursoredList cl) {
      String result = "(";
      cl.front();
      try {
        // Keep printing the current element and then advancing the
        // cursor until you advance off the end of the list.  At that
        // point, the advance method should throw an exception and 
        // we escape from the while loop.
        while (true) {
          result = result + cl.getCurrent() + " ";
          cl.advance();
        }
      }
      catch (Exception e) {
      }
      result = result + ")";
      return result;
    } // toString(CursoredList)
  
  } // class LCTester