For each task, submit your source java code file.(1) Objective Im.pdf

For each task, submit your source java code file.
(1) Objective: Implement Link List
Write a class that maintains the scores for a game application. Implement the addition and
removal function to update the database. The gamescore.txt contains player’ name and score data
record fields separated by comma. For Removal function, uses the name field to select record to
remove the game score record.
Download – List.java, LList.java, Dlink.java, GameEntry.java, gamescore.txt
(a)Read gamescore.txt to initialize the Linked list in sorted order. (1 point)
(b)Provide Remove and Add function for user to update the sorted linked list. (1 point)
(2)Add a reverse function to the LList.java class to reverse the order of the linked list. (2 points).
---------------------------------------------------------------------------------------------------------------------
-----------------------------------------
//gamescore.txt
Mike,1105
Rob,750
Paul,720
Anna,660
Rose,590
Jack,510
--------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------
//DLink.java
/** Source code example for "A Practical Introduction to Data
Structures and Algorithm Analysis, 3rd Edition (Java)"
by Clifford A. Shaffer
Copyright 2008-2011 by Clifford A. Shaffer
*/
/** Doubly linked list node */
class DLink {
private E element; // Value for this node
private DLink next; // Pointer to next node in list
private DLink prev; // Pointer to previous node
/** Constructors */
DLink(E it, DLink p, DLink n)

{ element = it; prev = p; next = n; }
DLink(DLink p, DLink n) { prev = p; next = n; }
/** Get and set methods for the data members */
DLink next() { return next; }
DLink setNext(DLink nextval)
{ return next = nextval; }
DLink prev() { return prev; }
DLink setPrev(DLink prevval)
{ return prev = prevval; }
E element() { return element; }
E setElement(E it) { return element = it; }
}
--------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------
//GameEntry.java
public class GameEntry {
protected String name;
protected int score;
public GameEntry(String n, int s) {
name = n;
score = s;
}
public String getName() {return name;}
public int getScore() {return score;}
public String toString() {
return "("+name+","+score+")";
}
}
--------------------------------------------------------------------------------------------------------------------
----------------------------------
//List.java
*/

/** List ADT */
public interface List {
/** Remove all contents from the list, so it is once again
empty. Client is responsible for reclaiming storage
used by the list elements. */
public void clear();
/** Insert an element at the current location. The client
must ensure that the list's capacity is not exceeded.
@param item The element to be inserted. */
public void insert(E item);
/** Append an element at the end of the list. The client
must ensure that the list's capacity is not exceeded.
@param item The element to be appended. */
public void append(E item);
/** Remove and return the current element.
@return The element that was removed. */
public E remove();
/** Set the current position to the start of the list */
public void moveToStart();
/** Set the current position to the end of the list */
public void moveToEnd();
/** Move the current position one step left. No change
if already at beginning. */
public void prev();
/** Move the current position one step right. No change
if already at end. */
public void next();
/** @return The number of elements in the list. */
public int length();
/** @return The position of the current element. */
public int currPos();
/** Set current position.
@param pos The position to make current. */
public void moveToPos(int pos);
/** @return The current element. */
public E getValue();

}
--------------------------------------------------------------------------------------------------------------------
-----------------------------------
//LList.java
*/
// Doubly linked list implementation
class LList implements List {
private DLink head; // Pointer to list header
private DLink tail; // Pointer to last element in list
protected DLink curr; // Pointer ahead of current element
int cnt; // Size of list
//Constructors
LList(int size) { this(); } // Ignore size
LList() {
curr = head = new DLink(null, null); // Create header node
tail = new DLink(head, null);
head.setNext(tail);
cnt = 0;
}
public void clear() { // Remove all elements from list
head.setNext(null); // Drop access to rest of links
head.setNext(tail);
cnt = 0;
}
public void moveToStart() // Set curr at list start
{ curr = head; }
public void moveToEnd() // Set curr at list end
{ curr = tail.prev(); }
/** Insert "it" at current position */
public void insert(E it) {

curr.setNext(new DLink(it, curr, curr.next()));
curr.next().next().setPrev(curr.next());
cnt++;
}
/** Append "it" to list */
public void append(E it) {
tail.setPrev(new DLink(it, tail.prev(), tail));
tail.prev().prev().setNext(tail.prev());
cnt++;
}
/** Remove and return current element */
public E remove() {
if (curr.next() == tail) return null; // Nothing to remove
E it = curr.next().element(); // Remember value
curr.next().next().setPrev(curr);
curr.setNext(curr.next().next()); // Remove from list
cnt--; // Decrement the count
return it; // Return value removed
}
/** Move curr one step left; no change if at front */
public void prev() {
if (curr != head) // Can't back up from list head
curr = curr.prev();
}
// Move curr one step right; no change if at end
public void next()
{ if (curr != tail.prev()) curr = curr.next(); }
public int length() { return cnt; }
// Return the position of the current element
public int currPos() {
DLink temp = head;
int i;
for (i=0; curr != temp; i++)
temp = temp.next();
return i;
}

// Move down list to "pos" position
public void moveToPos(int pos) {
assert (pos>=0) && (pos<=cnt) : "Position out of range";
curr = head;
for(int i=0; i. The vertical
* bar represents the current location of the fence. This method
* uses toString() on the individual elements.
* @return The string representation of this list
*/
public String toString()
{
// Save the current position of the list
int oldPos = currPos();
int length = length();
StringBuffer out = new StringBuffer((length() + 1) * 4);
moveToStart();
out.append("< ");
for (int i = 0; i < oldPos; i++) {
if (getValue()!=null)
{
out.append(getValue());
out.append(" ");
}
next();
}
out.append("| ");
for (int i = oldPos; i < length; i++) {
out.append(" ");
next();
}
out.append(">");
moveToPos(oldPos); // Reset the fence to its original position
return out.toString();
}
}

Solution
The added code is highlighted in bold letters.
Program code to copy:
//DLink.java
*/
/** Doubly linked list node */
class DLink
{
private E element; // Value for this node
private DLink next; // Pointer to next node in list
private DLink prev; // Pointer to previous node
/** Constructors */
DLink(E it, DLink p, DLink n)
{
element = it;
prev = p;
next = n;
}
DLink(DLink p, DLink n)
{
prev = p;
next = n;
}
/** Get and set methods for the data members */
DLink next()
{
return next;
}
DLink setNext(DLink nextval)
{

return next = nextval;
}
DLink prev()
{
return prev;
}
DLink setPrev(DLink prevval)
{
return prev = prevval;
}
E element()
{
return element;
}
E setElement(E it)
{
return element = it;
}
}
//List.java
*/
/** List ADT */
publicinterface List
{
/**
* Remove all contents from the list, so it is once again empty. Client is
* responsible for reclaiming storage used by the list elements.
*/
publicvoid clear();
/**
* Insert an element at the current location. The client must ensure that
* the list's capacity is not exceeded.

*
* @param item
* The element to be inserted.
*/
publicvoid insert(E item);
/**
* Append an element at the end of the list. The client must ensure that
* the list's capacity is not exceeded.
*
* @param item
* The element to be appended.
*/
publicvoid append(E item);
/**
* Remove and return the current element.
*
* @return The element that was removed.
*/
public E remove();
/** Set the current position to the start of the list */
publicvoid moveToStart();
/** Set the current position to the end of the list */
publicvoid moveToEnd();
/**
* Move the current position one step left. No change if already at
* beginning.
*/
publicvoid prev();
/**
* Move the current position one step right. No change if already at end.
*/
publicvoid next();
/** @return The number of elements in the list. */
publicint length();
/** @return The position of the current element. */
publicint currPos();

/**
* Set current position.
*
* @param pos
* The position to make current.
*/
publicvoid moveToPos(int pos);
/** @return The current element. */
public E getValue();
}
//LList.java
/**
* Source code example for "A Practical Introduction to Data Structures and
* Algorithm Analysis, 3rd Edition (Java)" by Clifford A. Shaffer Copyright
* 2008-2011 by Clifford A. Shaffer
*/
// Doubly linked list implementation
class LList implements List
{
private DLink head; // Pointer to list header
private DLink tail; // Pointer to last element in list
protected DLink curr; // Pointer ahead of current element
int cnt; // Size of list
// Constructors
LList(int size)
{
this();
} // Ignore size
LList()
{
head.setNext(tail);
cnt = 0;
}
publicvoid clear()

{ // Remove all elements from list
head.setNext(null); // Drop access to rest of links
head.setNext(tail);
cnt = 0;
}
publicvoid moveToStart() // Set curr at list start
{
curr = head;
}
publicvoid moveToEnd() // Set curr at list end
{
curr = tail.prev();
}
/** Insert "it" at current position */
publicvoid insert(E it)
{
curr.setNext(new DLink(it, curr, curr.next()));
curr.next().next().setPrev(curr.next());
cnt++;
}
/** Append "it" to list */
publicvoid append(E it)
{
tail.setPrev(new DLink(it, tail.prev(), tail));
tail.prev().prev().setNext(tail.prev());
cnt++;
}
/** Remove and return current element */
public E remove()
{
if (curr.next() == tail)
returnnull; // Nothing to remove
E it = curr.next().element(); // Remember value
curr.next().next().setPrev(curr);

curr.setNext(curr.next().next()); // Remove from list
cnt--; // Decrement the count
return it; // Return value removed
}
/** Move curr one step left; no change if at front */
publicvoid prev()
{
if (curr != head) // Can't back up from list head
curr = curr.prev();
}
// Move curr one step right; no change if at end
publicvoid next()
{
if (curr != tail.prev())
curr = curr.next();
}
publicint length()
{
return cnt;
}
// Return the position of the current element
publicint currPos()
{
DLink temp = head;
int i;
for (i = 0; curr != temp; i++)
temp = temp.next();
return i;
}
// Move down list to "pos" position
publicvoid moveToPos(int pos)
{
assert (pos >= 0) && (pos <= cnt) : "Position out of range";
curr = head;
for (int i = 0; i < pos; i++)
curr = curr.next();

}
public E getValue()
{
// Return current element
if (curr.next() == tail)
returnnull;
return curr.next().element();
}
// reverseList() method that reverses the LList
publicvoidreverseList()
{
LList revList =newLList();
curr=tail.prev();
while(curr!=head)
{
revList.append(curr.element());
curr=curr.prev();
}
head.setNext(revList.head.next());
}
// Extra stuff not printed in the book.
/**
* Generate a human-readable representation of this list's contents that
* looks something like this: < 1 2 3 | 4 5 6 >. The vertical bar
* represents the current location of the fence. This method uses
* toString() on the individual elements.
*
* @return The string representation of this list
*/
public String toString()
{
// Save the current position of the list
int oldPos = currPos();
int length = length();
StringBuffer out = new StringBuffer((length() + 1) * 4);
moveToStart();

out.append("< ");
for (int i = 0; i < oldPos; i++)
{
if (getValue() != null)
{
out.append(" ");
}
next();
}
out.append("| ");
for (int i = oldPos; i < length; i++)
{
out.append(" ");
next();
}
out.append(">");
moveToPos(oldPos); // Reset the fence to its original position
return out.toString();
}
}
//DLLSports.java
importjava.util.*;
importjava.io.*;
publicclassDLLSports
{
publicstaticvoidmain(String args[])throwsException
{
GameEntry ge =null;
LList llge =newLList();
Scanner input =newScanner(newFile("gamescore.txt"));
String line ="";
String name;
intscore;
// read till end of the file

while(input.hasNextLine())
{
// read the line from the file
line = input.nextLine();
// split the string at ","
String data[] = line.split(",");
// set the values
name = data[0];
score = Integer.parseInt(data[1]);
// create an object of GameEntry
ge =newGameEntry(name, score);
// call the addRecord function
// to add the data in sorted order
addRecord(llge, ge);
}
input.close();
//print the current list
System.out.println("Current list: ");
System.out.println(llge.toString());
// call the method removeRecord() that removes
// the name from the list by looking into the
// name
removeRecord(llge,"Mike");
// print the list
System.out.println(" Mike is removed from the list. The updated list is: ");
//call the reverseList() method of LList
System.out.println(" Reverse of list: ");
llge.reverseList();

// print the list
}
// addRecord() that takes a LList object and GameEntry object
// and adds the ge to the llge in sorted order
publicstaticvoidaddRecord(LList llge, GameEntry ge)
{
// get the length
intlength = llge.length();
// move the pointer to the begining of the list
llge.moveToStart();
inti = 0;
// condition to check whether getValue() is null or not
// if null, append ge to the empty list
if(llge.getValue() ==null)
{
llge.append(ge);
}
// else insert ge at appropriate location
else
{
//loop through find the greater value
while(i != length)
{
// condition to compare by name
if(llge.getValue().getName().compareTo(ge.getName()) < 0)
{
// move the pointer
llge.next();
}
else
{

break;
}
i++;
}
// insert the ge to the llge at appropriate position
llge.insert(ge);
}
}
// removeRecord() that takes a LList object and String object
// and removes the name from the llge. This method removes all the
// records that matches the name
publicstaticvoidremoveRecord(LList llge, String name)
{
// get the length
intlength = llge.length();
// move the pointer to the begining of the list
llge.moveToStart();
inti = 0;
// condition to check whether getValue() is matches the
// name, then remove the record from the list
if(llge.getValue().getName().equalsIgnoreCase(name))
{
llge.remove();
}
// else move to the appropriate record
else
{
// loop till the value is found
while(i != length)
{
// if found, remove the record.
if(llge.getValue().getName().equalsIgnoreCase(name))

{
llge.remove();
}
else
{
llge.next();
}
i++;
}
}
}
}
Sample Input: gamescore.txt
Mike,1105
Rob,750
Paul,720
Anna,660
Rose,590
Jack,510
Sample Output:
Current list:
< (Anna,660) | (Jack,510) (Mike,1105) (Paul,720) (Rob,750) (Rose,590) >
Mike is removed from the list. The updated list is:
< (Anna,660) (Jack,510) (Paul,720) (Rob,750) (Rose,590) | >
Reverse of list:
< | (Rose,590) (Rob,750) (Paul,720) (Jack,510) (Anna,660) >

For each task, submit your source java code file.(1) Objective Im.pdf

Recommended

More Related Content

Similar to For each task, submit your source java code file.(1) Objective Im.pdf (20)

More from dhavalbl38 (20)

Recently uploaded (20)

For each task, submit your source java code file.(1) Objective Im.pdf