• hw3


    smoosh相对来说比较复杂一些,尤其是最后一个数字向后比较的时候,很容易就丢了一个数,作业上说是用了14行码,我正好也是14行。后面squish开始忘记了比较要用equals不能用==,也是卡了半天,不好好审题。后面加了一些testcode检验这三个method。
    import java.lang.reflect.Array;
    
    /* SList.java */
    
    /**
     *  The SList class is a singly-linked implementation of the linked list
     *  abstraction.  SLists are mutable data structures, which can grow at either
     *  end.
     *
     *  @author Kathy Yelick and Jonathan Shewchuk
     **/
    
    public class SList {
    
      private SListNode head;
      private int size;
    
    
      /**
       *  SList() constructs an empty list.
       **/
    
      public SList() {
        size = 0;
        head = null;
      }
    
      /**
       *  isEmpty() indicates whether the list is empty.
       *  @return true if the list is empty, false otherwise.
       **/
    
      public boolean isEmpty() {
        return size == 0;
      }
    
      /**
       *  length() returns the length of this list.
       *  @return the length of this list.
       **/
    
      public int length() {
        return size;
      }
    
      /**
       *  insertFront() inserts item "obj" at the beginning of this list.
       *  @param obj the item to be inserted.
       **/
    
      public void insertFront(Object obj) {
        head = new SListNode(obj, head);
        size++;
      }
    
      /**
       *  insertEnd() inserts item "obj" at the end of this list.
       *  @param obj the item to be inserted.
       **/
    
      public void insertEnd(Object obj) {
        if (head == null) {
          head = new SListNode(obj);
        } else {
          SListNode node = head;
          while (node.next != null) {
            node = node.next;
          }
          node.next = new SListNode(obj);
        }
        size++;
      }
    
      /**
       *  nth() returns the item at the specified position.  If position < 1 or
       *  position > this.length(), null is returned.  Otherwise, the item at
       *  position "position" is returned.  The list does not change.
       *  @param position the desired position, from 1 to length(), in the list.
       *  @return the item at the given position in the list.
       **/
    
      public Object nth(int position) {
        SListNode currentNode;
    
        if ((position < 1) || (head == null)) {
          return null;
        } else {
          currentNode = head;
          while (position > 1) {
            currentNode = currentNode.next;
            if (currentNode == null) {
              return null;
            }
            position--;
          }
          return currentNode.item;
        }
      }
      /**
       *  smoosh() takes an array of ints.  On completion the array contains
       *  the same numbers, but wherever the array had two or more consecutive
       *  duplicate numbers, they are replaced by one copy of the number.  Hence,
       *  after smoosh() is done, no two consecutive numbers in the array are the
      * same. *
       *  Any unused elements at the end of the array are set to -1.
       *
       *  For example, if the input array is [ 0 0 0 0 1 1 0 0 0 3 3 3 1 1 0 ],
       *  it reads [ 0 1 0 3 1 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 ] after smoosh()
       *  completes.
       *
       *  @param ints the input array.
       **/
      
      public static void smoosh(int[] ints) {
          int k=0;
         int lengthOriginal=Array.getLength(ints);
          int lengthOf=lengthOriginal;
         for(int i=0;i<lengthOf;i++){
             if(ints[i]==ints[i+1]){
                 for(int j=i+1;j<lengthOf;j++){
                     ints[j-1]=ints[j];             
             }
             lengthOf--;
             k++;
             if(i!=lengthOf-1)i--;}
         }
         for(int x=lengthOriginal-k;x<lengthOriginal;x++){
             ints[x]=-1;
         }
    
          
          // Fill in your solution here.  (Ours is fourteen lines long, not counting
          // blank lines or lines already present in this file.)
      }
      /**
       *  squish() takes this list and, wherever two or more consecutive items are
       *  equals(), it removes duplicate nodes so that only one consecutive copy
       *  remains.  Hence, no two consecutive items in this list are equals() upon
       *  completion of the procedure.
       *
       *  After squish() executes, the list may well be shorter than when squish()
       *  began.  No extra items are added to make up for those removed.
       *
       *  For example, if the input list is [ 0 0 0 0 1 1 0 0 0 3 3 3 1 1 0 ], the
       *  output list is [ 0 1 0 3 1 0 ].
       *
       *  IMPORTANT:  Be sure you use the equals() method, and not the "=="
       *  operator, to compare items.
       **/
    
      public void squish() {
        SListNode a=head;
        while(a!=null){
        if(a.next!=null){
            if(a.item.equals(a.next.item)){
              a.next=a.next.next;
              size--;
        }else  a=a.next;
        
        }else a=a.next;
    }}
      /**
       *  twin() takes this list and doubles its length by replacing each node
       *  with two consecutive nodes referencing the same item.
       *
       *  For example, if the input list is [ 3 7 4 2 2 ], the
       *  output list is [ 3 3 7 7 4 4 2 2 2 2 ].
       *
       *  IMPORTANT:  Do not try to make new copies of the items themselves.
       *  Make new SListNodes, but just copy the references to the items.
       **/
    
      public void twin() {
        SListNode original=head;
        SListNode copy;
        while(original!=null){
            copy=new SListNode(original.item,original.next);
            original.next=copy;
            original=copy.next;
            
        }// Fill in your solution here.  (Ours is seven lines long.)
      }
    
      /**
       *  toString() converts the list to a String.
       *  @return a String representation of the list.
       **/
    
      public String toString() {
        int i;
        Object obj;
        String result = "[  ";
    
        SListNode cur = head;
    
        while (cur != null) {
          obj = cur.item;
          result = result + obj.toString() + "  ";
          cur = cur.next;
        }
        result = result + "]";
        return result;
      }
    
    
      /**
       *  main() runs test cases on the SList class.  Prints summary
       *  information on basic operations and halts with an error (and a stack
       *  trace) if any of the tests fail.
       **/
    
      public static void main (String[] args) {
        int[] myArray={3,7,7,7,7,4,4,2,2,2,2,1};
        smoosh(myArray);
        testEmpty();
        testAfterInsertFront();
        testAfterInsertEnd();
        testsmoosh();
        testsquish();
        testtwin();
        
      }
      private static void testsmoosh(){
          int[] testInt={1,2,2,2,3,3,3,5,5,5};
          System.out.println("Here is the original Array: ");
                for(int i=0;i<10;i++){
                  System.out.print(testInt[i]);
                } 
                 System.out.println();
                 System.out.println("Here is the Array after smoosh method: ");
                    smoosh(testInt);
                 for(int i=0;i<10;i++){
                      System.out.print(testInt[i]);
                    } 
      }
      private static void testsquish(){
          SList testList1=new SList();
         testList1.insertFront(1);
         testList1.insertFront(1);
         testList1.insertFront(2);
         testList1.insertFront(2);
         testList1.insertFront(3);
         testList1.insertFront(3);
         testList1.insertFront(3);
         System.out.println();
         System.out.println("Here is a list of original construction: "
                       + testList1.toString());
         testList1.squish();
            System.out.println("Here is a list of after squish method: "
                       + testList1.toString());
      }
      private static void testtwin(){
          SList testList2=new SList();
          testList2.insertFront(1);
          testList2.insertFront(2);
          testList2.insertFront(3);
          testList2.insertFront(4);
          testList2.insertFront(5);
          testList2.insertFront(5);
          System.out.println();
          System.out.println("Here is a list of original construction: "
                       + testList2.toString());
          testList2.twin();
              System.out.println("Here is a list after twin method: "
                   + testList2.toString());
      }
        
      /**
       *  testEmpty() tests toString(), isEmpty(), length(), insertFront(), and
       *  insertEnd() on an empty list.  Prints summary information of the tests
       *  and halts the program if errors are detected.
       **/
    
      private static void testEmpty() {
        SList lst1 = new SList();
        SList lst2 = new SList();
        System.out.println();
        System.out.println("Here is a list after construction: "
                   + lst1.toString());
        TestHelper.verify(lst1.toString().equals("[  ]"),
                  "toString on newly constructed list failed");
    
        System.out.println("isEmpty() should be true. It is: " +
                   lst1.isEmpty());
        TestHelper.verify(lst1.isEmpty() == true,
                  "isEmpty() on newly constructed list failed");    
    
        System.out.println("length() should be 0. It is: " +
                   lst1.length());
        TestHelper.verify(lst1.length() == 0, 
                  "length on newly constructed list failed");    
        lst1.insertFront(new Integer(3));
        System.out.println("Here is a list after insertFront(3) to an empty list: "
                   + lst1.toString());
        TestHelper.verify(lst1.toString().equals("[  3  ]"),
                  "InsertFront on empty list failed");
        lst2.insertEnd(new Integer(5));
        System.out.println("Here is a list after insertEnd(5) on an empty list: "
                   + lst2.toString());
        TestHelper.verify(lst2.toString().equals("[  5  ]"),
                  "insertEnd on empty list failed");
      }
    
      /**
       *  testAfterInsertFront() tests toString(), isEmpty(), length(),
       *  insertFront(), and insertEnd() after insertFront().  Prints summary
       *  information of the tests and halts the program if errors are detected.
       **/
    
      private static void testAfterInsertFront() {
        SList lst1 = new SList();
        lst1.insertFront(new Integer(3));
        lst1.insertFront(new Integer(2));
        lst1.insertFront(new Integer(1));
        System.out.println();
        System.out.println("Here is a list after insertFront 3, 2, 1: "
                   + lst1.toString());
        System.out.println("Here is a list after insertFront 3, 2, 1: "
                   + lst1.toString());
        TestHelper.verify(lst1.toString().equals("[  1  2  3  ]"),
                  "InsertFronts on non-empty list failed");
        System.out.println("isEmpty() should be false. It is: " +
                   lst1.isEmpty());
        TestHelper.verify(lst1.isEmpty() == false,
                  "isEmpty() after insertFront failed");    
        System.out.println("length() should be 3. It is: " +
                   lst1.length());
        TestHelper.verify(lst1.length() == 3, 
                  "length() after insertFront failed");
        lst1.insertEnd(new Integer(4));
        System.out.println("Here is the same list after insertEnd(4): "
                   + lst1.toString());
        TestHelper.verify(lst1.toString().equals("[  1  2  3  4  ]"),
                  "insertEnd on non-empty list failed");
      }
        
      /**
       *  testAfterInsertEnd() tests toString(), isEmpty(), length(),
       *  insertFront(), and insertEnd() after insertEnd().  Prints summary
       *  information of the tests and halts the program if errors are detected.
       **/
    
      private static void testAfterInsertEnd() {
        SList lst1 = new SList();
        lst1.insertEnd(new Integer(6));
        lst1.insertEnd(new Integer(7));
        System.out.println();
        System.out.println("Here is a list after insertEnd 6, 7: "
                   + lst1.toString());
        System.out.println("isEmpty() should be false. It is: " +
                   lst1.isEmpty());
        TestHelper.verify(lst1.isEmpty() == false,
                  "isEmpty() after insertEnd failed");    
        System.out.println("length() should be 2. It is: " +
                   lst1.length());
        TestHelper.verify(lst1.length() == 2, 
                  "length() after insertEndfailed");
        lst1.insertFront(new Integer(5));
        System.out.println("Here is the same list after insertFront(5): "
                   + lst1.toString());
        TestHelper.verify(lst1.toString().equals("[  5  6  7  ]"),
                  "insertFront after insertEnd failed");
      }
    }
    View Code

    运行结果:

  • 相关阅读:
    作业2(5)
    作业2(7)
    作业2(4)
    作业2(3)
    作业2(1)
    作业3(5)
    作业3(6)
    实验7综合练习(4)
    实验7综合练习(2)
    计算成绩
  • 原文地址:https://www.cnblogs.com/Jingjunw/p/7223391.html
Copyright © 2020-2023  润新知