The Vector Class

Vector Class

• Write a Vector class. This will be a container class that will hold objects. It should allow the following operations:

– add Add an object to the end of the Vector – find Determine if an object is in the Vector – get Get a certain element (by number) from the

Vector – insert Insert a new element into a certain position– deleteDelete a certain element from the Vector– size Returns size of Vector

Typical Operation

Vector v;

v = new Vector();

v.add(“Larry”);

v.add(“Moe”);

v.add(“Curly”);

System.out.println

(v.find(“Ned”));

System.out.println

(v.get(1));

v.insert(“Shemp”, 1);

v.delete(2);

for

(int i=0;i<v.size();i++)

System.out.println

(v.get(i));

false

Moe

Larry

Shemp

Curly

Design

• Implementation will be easily accomplished with a linked list.

• We'll assume we have available an LLNode which holds objects and has get/setData and get/setNext methods.

• We'll start with the basic shell and the fields we'll need:

LLNode

class LLNode {

private Object data;

private LLNode next;

public LLNode(Object o) {

setData(o);

setNext(null);

}

public void setData(Object o) {

data = o;

}

public Object getData() {

return data;

}

LLNode

// class LLNode (continued)

public void setNext(LLNode n) {

next = n;

}

public LLNode getNext() {

return next;

}

} // LLNode

Things to notice

• As you get used to any language you will learn a basic shell or template from which to start programs.

• Creating and using such a shell will sometimes aid in getting started

• It’s also a good place to include things that you always forget (e.g. closing braces)

Basics

public class Vector {

private LLNode head;

private int count;

/* ------------------------------------------- */

/** Basic constructor.

 Precondition: None.

 Postcondition: Vector instantiated

with size set to zero.

*/

public Vector() {

setHead(null);

count = 0;

}

Basics

/** Sets head reference.

 Precondition: Instantiation.

 Postcondition: head reference set

to newhead

@param newhead New head reference

*/

private void setHead(LLNode newhead) {

head = newhead;

}

Basics

/** Returns head reference.

 Precondition: Instantiation.

 Postcondition: No change to Vector

@return Head reference

*/

private LLNode getHead() {

return head;

}

Things to Notice

• Make the documentation work for you as opposed to being just a “dumb” requirement that you do after the real work is done.

• Create the documentation in the form of Javadocs

• Create this documentation in a “working” i.e. compilable template

• As each method is written compile and test!

Design by Contract

/** Adds an object to the end of the Vector.

Precondition: Vector has been instantiated.

Postcondition: The last item in the Vector

will be the item added and the Vector will be

one element longer.

@param o The object to be added.

*/

public void add(Object o)

{

} // add

Design by Contract /** Finds the location of an object in the Vector.


Postcondition: The Vector will be unchanged.

@param o The object to be located. Note: The

target object must return true when tested

with o.equals(target)

@return An value indicating the location of

the item. The first element is numbered 0. A

-1 indicates element not found.

*/

public int find(Object o)

{

return 0;

} // find

Design by Contract /** Gets the n-th element of the Vector and returns it. Precondition: Vector has been instantiated and should have at least n+1 elements. Postcondition: The Vector will be unchanged. @param n The number of the object to be located. Note: The first object in the Vector is numbered 0. @return The desired object. If the Vector is not at least n+1 elements long null will be returned. */ public Object get(int i) { return null; } // get

Design by Contract /** Inserts an object into the Vector at the specified position. If the Vector is not long enough acts like add. @see add Precondition: Vector has been instantiated. Postcondition: The Vector will have one additional element. It will either be in position specified or in the last element in the Vector (whichever is smaller). @param o The object to be inserted. @param n The position into which the object is to be inserted. Note: The first object in the Vector is numbered 0. */ public void insert(Object o, int i) { } // insert

Design by Contract /** Deletes the n-th element of the Vector.

Precondition: Vector has been instantiated

and the n-th element is present.

Postcondition: The Vector will have the n-th

element deleted unless the original Vector

was not long enough to have the n-th element.

@param n The number of the object to be

deleted. Note: The first object in the Vector

is numbered 0.

*/

public void delete(int n)

{

} // delete

Design by Contract

/** Returns the size of the Vector.


Postcondition: Vector will be unchanged.

@return Size of the Vector.

*/

public int size()

{

return 0;

} // delete

} // Vector

Things to Notice

• Now we go back in a code incrementally• Write a method• Add some code to the test main to test it• TEST IT

/** Adds an object to the end of the Vector.

 Precondition: Vector has been

instantiated.

 Postcondition: The last item in the

Vector will be the item added and the Vector

will be one element longer.

@param o The object to be added.

*/

public void add(Object o) {

if(getHead() == null) {

setHead(new LLNode(o));

count++;

}

else

add(getHead(), o);

} // add

Typical error...had o insteadof new LLNode(o)

/** Add helper. Called by add. Adds an object to

the end of the Vector.


instantiated.

 Postcondition: The last item in the

Vector will be the item added and the Vector

will be one element longer.

@param current Current head of list

(recursive).

@param o The object to be added. */

private void add(LLNode current, Object o) {

if(current.getNext() == null) {

current.setNext(new LLNode(o));

count++;

} else

add(current.getNext(), o);

} // add helper

/** Finds the location of an object in the Vector.


instantiated.

 Postcondition: The Vector will be

unchanged.

@param o The object to be located. Note: The

target object must return true when tested

with o.equals(target)

@return An value indicating the location of

the item. The first element is numbered 0. A

-1 indicates element not found. */

public int find(Object o) {

if(getHead() == null)

return -1;

else

return find(getHead(), o, 0);

} // find

/* ---------------------------------------------*/

/* find helper */

/* ---------------------------------------------*/

private int find(LLNode current, Object o, int k)

{

if(current.getData().equals(o))

return k;

else if(current.getNext() == null)

return -1;

else

return find(current.getNext(), o, k+1);

} // find helper

/** Gets the nth element of the Vector and returns it.


instantiated and should have at least n+1 elements.

 Postcondition: The Vector will be unchanged.

@param n The number of the object to be located. Note: The first object in the Vector is numbered 0.

@return The desired object. If the Vector is not at least n+1 elements long null will be returned. */

public Object get(int i) {

if(getHead() == null)

return null;

else

return get(getHead(), i, 0);

} // get

/* ---------------------------------------------*/

/* get helper

/* ---------------------------------------------*/

private Object get(LLNode current, int i, int k) {

if(i == k)

return current.getData();

else if(current.getNext() == null)

return null;

else

return get(current.getNext(), i, k+1);

} // get helper

/** Inserts an object into the Vector at the specified position. If the Vector is not long enough acts like add.

 Precondition: Vector has been instantiated.

 Postcondition: The Vector will have one additional element. It will either be in position

specified or in the last element in the Vector (whichever is smaller).

@param o The object to be inserted. @param n The position into which the object is to be inserted. Note: The first object in the

Vector is numbered 0. */

public void insert(Object o, int i) { if((getHead() == null) || (i == 0)) { LLNode temp = new LLNode(o); temp.setNext(getHead()); setHead(temp); count++; } else insert(getHead(), o, i, 1); } // insert

/* ---------------------------------------------*/

/* insert helper /* ---------------------------------------------*/ private void insert(LLNode current, Object o, int i, int k) { if((current.getNext() == null) || (i == k)) { LLNode temp = new LLNode(o); temp.setNext(current.getNext()); current.setNext(temp); count++; } else insert(current.getNext(), o, i, k+1); } // insert helper

/** Deletes the n-th element of the Vector.


instantiated and the n-th element is present.

 Postcondition: The Vector will

have the n-th element deleted unless the

original Vector was not long enough to have

the n-th element.



is numbered 0. */

public void delete(int n) {

/* Check to make sure element to be deleted

is in Vector */

if(n < size() && n >= 0) {

if(n == 0) {

setHead(getHead().getNext());

count--;

} else {

delete(getHead(), n, 1);

}

}

} // delete

/** Delete helper. Deletes the n-th element of

the Vector.


instantiated.

 Postcondition: The Vector will

have the n-th element deleted.

@param current Head of current list

(recursive).



is numbered 0.

@param k Current count.

*/

Note: Javadocs do not by default include private items. However this can be overridden so two versions of Javadocs could be produced: one for internal and one for external use

Note: Javadocs do not by default include private items. However this can be overridden so two versions of Javadocs could be produced: one for internal and one for external use

private void delete(LLNode current, int n, int k){

if(n == k) {

current.setNext(current.getNext().getNext());

count--;

} else {

delete(current.getNext(), n, k+1);

}

} // delete helper

/** Returns the size of the Vector.


instantiated.

 Postcondition: Vector will be

unchanged.

@return Size of the Vector. */

public int size()

{

return count;

} // size

/** Convert vector into string listing.

 Precondition:Instantiation.

 Postcondition:No change to Vector.

@return Representation of Vector as list.

*/

public String toString()

{

String retVal = "";

for(int i=0; i < size(); i++)

{

retVal += get(i) + "\n";

}

return retVal;

}

/** Test main. */

public static void main(String args[]) {

Vector v = new Vector();

System.out.println("Should be -1: " +

v.find("Test"));

v.add("Test");

v.add("Test2");

System.out.println("Should be 0: " +

v.find("Test"));

System.out.println("Should be 1: " +

v.find("Test2"));

System.out.println("Should be -1: " +

v.find("Missing"));

/** Test main. */

/* Test get */

System.out.println("Should be Test: " +

v.get(0));

System.out.println("Should be Test2: " +

v.get(1));

if(v.get(2) == null)

System.out.println("Passed get 2 test");

else

System.out.println("Failed get 2 test");

/** Test main. */

/* insert test */

v.insert("NewHead", 0);

v.insert("NewOne", 1);

System.out.println("Start Traversal");

System.out.println(v);

System.out.println("End Traversal");

System.out.println("Size: " + v.size());

/* delete test */ v = new Vector(); v.add("Zero"); v.add("One"); v.add("Two"); v.add("Three"); v.add("Four"); v.add("Five"); System.out.println("Starting vector\n"+v); v.delete(0); System.out.println("Deleted first\n"+v); v.delete(4); System.out.println("Deleted last\n"+v); v.delete(-v.size()); v.delete(v.size()); System.out.println("Should be no change\n"+v); v.delete(1); System.out.println("Two should be gone\n"+ v); } // main} // Vector

The Vector Class

Documents

Transcript of The Vector Class