Module 9 Assignment
Worth 2% of your total course grade
CS1083 – Introduction to Computer Programming II (in Java)
Online Open Entry Version
Instructor: Andrew McAllister
Assignment Objectives
The purpose of this assignment is to give you practice:
• working with linked lists
General Instructions for All Assignments
• Follow the instructions in the document "Java Coding Guidelines.pdf" available
within the "Start Here" module, under the "Assignments" topic.
• For each .java file you create, include a javadoc comment (one that begins with
/**) at the beginning of the file that describes that Java class. This comment block
should include a line that begins with @author followed by your name and
student number on the same line. (Note: inclusion of this comment is part of the
instructions given in "Java Coding Guidelines.pdf")
• Include comments throughout your programs to explain any non-obvious portions
of your code.
• It is recommended that you create a separate folder on your computer for each
assignment. You might even wish to create separate sub-folders within an
assignment folder if the assignment has multiple parts. Keeping your work
organized makes it easier to find things later when you want to review what you
have done.
• Few things in life are more frustrating than losing your work while working on an
assignment. Get in the habit of saving frequently when working on an
assignment. Also, regularly make backup copies of any files you create as part of
your work for this course.
Assignment Guide
• Feel free to email your instructor if you need help in completing an assignment.
When you do so, please attach to the email a copy of *all* files required to
compile and run the program you are asking about, even if you downloaded
those files from D2L. (Otherwise the instructor will have to figure out what files
are missing and then go looking for them. Make it convenient to help you.) Also
describe the problem you are encountering and the specific help you would like
to receive.
• Submitting your assignment involves creating a pdf file and uploading that single
file to the assignment drop box on D2L. In general, that file will tend to include all
Java code you wrote for the assignment, plus any output from running your
programs that the assignment instructions specify you should capture. Specific
submission instructions are included at the end of each assignment.
• To create the pdf file for each assignment, begin by opening a new document
using the word processing program of your choice. Save the document using the
name “Your Name CS1083 Module x Assignment Submission.docx” Replace x
with the correct module number. “docx” may be different depending on which
word processing software you choose to use.
• If you don’t already have a word processor, UNB students are able to use
Microsoft Office 365 (includes Microsoft Word) for free, which can be accessed
by logging in to MyUNB.
• At the beginning of your submission document enter your name, your student
number, CS1083, the assignment name (this one is “Module 2 Assignment”), and
the date. It doesn’t matter if the date is when you started working on the
assignment or when you submit it – either will do.
• You can add content to your submission document as you work on the various
questions in the assignment. Clearly label each part of the assignment (“Part A”
etc.) in your document. Be sure to save frequently as you work on this document.
• When your document is complete, save / export it as a pdf file. Always make sure
your pdf file opens properly before uploading it.
• To include Java code in your submission document, copy all the text in your .java
file and then paste that text into your submission document. Use a monospaced
font (e.g.: Consolas , Courier ) for your code to maintain proper indentation.
Submitting code without proper indentation will result in marks being deducted.
It’s not enough that your code is indented in your text editor or in your integrated
programming environment – the indentation must show up that way in your
submission document as well. This sort of thing is part of learning to be an IT
professional.
• To include output from running your program in your submission document, the
preferred method is to copy and paste the text from your command prompt
window. Include the line with the “java” command you used to run your program.
 If the text shows up as a weird font or colour in your submission document,
first paste the text into a blank text editor document, then copy and paste from
there into your Microsoft Word submission document. This will remove all
formatting from the text.
 Use a monospaced font (e.g.: Consolas , Courier ) for output text in your
Word document. This will maintain alignment of your output.
• If at all possible, each line of code and each line of output should appear on a
single line in your submission document. Avoid allowing lines to “wrap” around
onto the next line. Use the tips provided in the “Avoiding Wrapped Lines” section
on the next page to accomplish this.
• To copy text from your command prompt window, try selecting the desired text
and then pressing either command-c (Mac) or control-c (Windows or Linux). If
you have issues, you can always use Google to see how to do this on your
specific type of computer.
• If a program involves graphical output (such as a JavaFX GUI program), capture
a screen shot of the output and include that as a picture / image in your
submission document.
 Make sure the image includes only the relevant portion of the screen (such
as a GUI window). Capturing an image of your entire computer screen often
makes the relevant portion too small to see, with tiny text that is difficult to read.
This makes your assignment submission difficult to grade.
• To capture a screen shot of a selected portion of your screen, try command-shift4 (Mac), WindowsKey-shift-s (Windows), or shift-PrtScrn (Linux).
Avoiding Wrapped Lines
In the following example, the lines of code containing the comment and the println
statement are both too long. The text is formatted so those lines can't fit all on one line
in this document. This obscures the indentation and makes the code more difficult to
read.
import java.util.Scanner;
public class WrapExample
{ public static void main(String[] args)
{ double pay = hours * wage;
int dollars = (int) pay;
int pennies = (int) ((pay - dollars) * 100.0);
// First all * and / operations are performed, left to
right, then all + and - operations, left to right
System.out.println("nThe pay for " + name + " is " +
dollars + " dollars and " + pennies + " cents.n");
} // end main method
} // end class
Below is the same code, but reformatted so none of the statements wrap around onto
the next line. Several changes were made:
1. The font size (in the Word document) is changed to a smaller size,
2. The tab size (in the Word document) is reduced
3. The longer statements and long comments are broken up onto multiple lines (do
this in your text editor, in the .java file), and
4. If need be, you can change the orientation of your Word document from Portrait
to Landscape
Now the indentation of the code within the main method is easier to see.
import java.util.Scanner;
public class WrapExample
{ public static void main(String[] args)
{ double pay = hours * wage;
int dollars = (int) pay;
int pennies = (int) ((pay - dollars) * 100.0);
// First all * and / operations are performed, left to right
 // Then all + and - operations, left to right
System.out.println("nThe pay for " + name + " is " + dollars
 + " dollars and " + pennies + " cents.n");
} // end main method
} // end class
Instructions – Part A – A Linked List of Numbers
The following files are provided for download earlier in this module:
• Node.java – A simple class for linked list nodes, where each node contains a
person’s name as a String.
• LinkedList.java – Contains some simple functionality for managing a linked
list of Node objects.
• ListTest.java – Performs simple testing for some of the functionality in the
LinkedList class.
All three of these classes will be updated as part of this assignment.
Update the Node class to store one int value in each Node instance, rather than a
name.
Update the LinkedList class to be consistent with your updated Node class.
Write a new testing class that does the following:
1. Create a new (empty) list using your updated LinkedList class.
2. Call the display method to display that empty list.
3. Use the insertInOrder() method to insert six randomly selected numbers between
1 and 49. Use the Random class to help generate each of those six numbers.
4. Call the display method to display your linked list of six numbers.
Include in Part A of your submission document:
• Complete code for Node.java, LinkedList.java, and your new testing class.
• Output from running your testing class twice.
Instructions – Part B – A Doubly Linked List of Numbers
1. Turn your updated list from Part A into a doubly linked list so Nodes are linked in
both directions, forward and backward. This entails:
• Adding a “previous” pointer to each Node object, along with getPrevious() and
setPrevious() methods in the Node class;
• Adding a “tail” pointer in the LinkedList class, along with a getTail() method;
and
• Updating whatever existing methods in the LinkedList class should be
changed so the values of “tail” and the “previous” pointers will be maintained
appropriately during all actions on the LinkedList.
2. Add a new instance variable called “size” to the LinkedList class. This variable must
keep track of the number of Nodes in the list at all times.
• Update the LinkedList constructor to set this variable appropriately when a
new list is created.
• Add a getSize() method that accesses the value of this variable. (Note: It
would not be appropriate to have a mutator method for this variable.)
• Update whatever existing methods in the LinkedList class should be changed
so the value of “size” will be maintained appropriately during all actions on the
LinkedList.
3. Add the following methods to the LinkedList class. Make sure all instance variables
in the Node and LinkedList classes are handled appropriately by these methods:
• insertAtHead(int num) – Inserts a new Node with the given number at the
beginning of the list. There is no need to check whether this operation keeps
the list in sorted order, nor is there any need to check whether this operation
results in duplicate numbers in the list.
• insertAtTail(int num) – Inserts a new Node with the given number at the end
of the list. There is no need to check whether this operation keeps the list in
sorted order, nor is there any need to check whether this operation results in
duplicate numbers in the list. (NOTE: This method should not include a loop.)
• removeAtHead() – removes the first Node in the list. Returns true if
successful, false otherwise (which should only happen when attempting to
removeAtHead() from an empty list).
• removeAtTail() – removes the last Node in the list. Returns true if successful,
false otherwise (which should only happen when attempting to removeAtTail()
from an empty list). (NOTE: This method should not include a loop.)
Update your testing class from Part A to test your updated Node and LinkedList classes
as follows:
1. Keep the four testing steps described in Part A (displaying the empty list, adding
and displaying six random numbers, etc.)
2. Use insertAtHead() to insert a randomly selected number between -100 and -50
at the head of the list. (The list should now contain seven nodes.)
3. Use insertAtTail() to insert a randomly selected number between 50 and 100 at
the tail of the list. (The list should now contain eight nodes.)
4. Call the display method to display your linked list of eight numbers.
5. Loop to call removeAtHead() three times.
6. Loop to call removeAtTail() three times.
7. Call the display method to display your linked list of what should now be two
numbers.
Include in Part B of your submission document:
• Complete code for your updated Node.java, LinkedList.java, and your updated
testing class.
• Output from running your updated testing class twice.
Instructions – Part C – An Updated LotteryTicket Class
Copy all the classes you wrote for the Module 2 Assignment to a new directory.
The LotteryTicket class you created for the Module 2 Assignment includes an array of
six randomly selected numbers between 1 and 49, without duplicates.
Update this LotteryTicket class to replace that array with a linked list of six randomly
selected numbers between 1 and 49, without duplicates. Use the Node and LinkedList
classes you updated for Part B to accomplish this.
This includes updating the following components of the LotteryTicket class:
• The constructor
• getNumbers()
• toString()
• chooseRandomNumbers()
• duplicateNumber(int i)
• countWinningNumbers(LinkedList winningNumbers)
The getWinningNumbers() method of the LotteryDraw class will also need to be
updated to return a reference to a LinkedList object rather than an array reference.
Test to make sure the LotteryDrawTest class you wrote for the Module 2 Assignment
still works with your updated LotteryTicket and LotteryDraw classes.
Include in Part C of your submission document:
• Complete code for your updated LotteryTicket and LotteryDraw classes.
• Output from running LotteryDrawTest twice.
Submission Instructions
Include the following in your submission document:
Your name, student number, CS1083, Module 9 Assignment, and the date.
Complete source code and testing output for each of Sections A, B, and C as
described above.
D2L DROPBOX SUBMISSION INSTRUCTIONS
Upload only one pdf file to D2L. Do not upload separate files (such as your .java
files) as they will be ignored. Upload your submission document as follows:
1. In the top-navigation bar on the course screen, select 'Assessments' and then
'Assignments'.
2. Select the assignment title and follow the instructions to upload your submission
document.
请加QQ：99515681  邮箱：99515681@qq.com   WX：codehelp