Assignment #2 Solution

$30.00 $24.00

The‌ ‌goal‌ ‌of‌ ‌this‌ ‌assignment‌ ‌is‌ ‌to‌ ‌use‌ ‌Java‌ ‌arrays‌ ‌as‌ ‌a‌ ‌tool‌ ‌to‌ ‌implement‌ ‌data‌ ‌structures‌ ‌ that‌ ‌store‌ ‌sequential‌ ‌data.‌ ‌In‌ ‌particular,‌ ‌we‌ ‌will‌ ‌implement‌ ‌a‌ ‌Stack‌ ‌of‌ ‌integers‌ ‌and‌ ‌a‌ ‌ Queue‌ ‌of‌ ‌integers.‌ ‌ ‌ **High‌ ‌Level:** With‌ ‌a‌ ‌Stack,‌ ‌you‌ ‌add‌ ‌and‌ ‌remove‌ ‌elements‌ ‌from‌ ‌the‌ ‌same‌ ‌end‌ ‌of‌ ‌the‌…

5/5 – (2 votes)

You’ll get a: zip file solution

 

Description

5/5 – (2 votes)

The‌ ‌goal‌ ‌of‌ ‌this‌ ‌assignment‌ ‌is‌ ‌to‌ ‌use‌ ‌Java‌ ‌arrays‌ ‌as‌ ‌a‌ ‌tool‌ ‌to‌ ‌implement‌ ‌data‌ ‌structures‌ ‌

that‌ ‌store‌ ‌sequential‌ ‌data.‌ ‌In‌ ‌particular,‌ ‌we‌ ‌will‌ ‌implement‌ ‌a‌ ‌Stack‌ ‌of‌ ‌integers‌ ‌and‌ ‌a‌ ‌

Queue‌ ‌of‌ ‌integers.‌ ‌ ‌

**High‌ ‌Level:**

With‌ ‌a‌ ‌Stack,‌ ‌you‌ ‌add‌ ‌and‌ ‌remove‌ ‌elements‌ ‌from‌ ‌the‌ ‌same‌ ‌end‌ ‌of‌ ‌the‌ ‌sequence.‌ ‌(Also‌ ‌

known‌ ‌as:‌ ‌First‌ ‌in,‌ ‌Last‌ ‌Out)‌ ‌

With‌ ‌a‌ ‌Queue,‌ ‌you‌ ‌add‌ ‌elements‌ ‌at‌ ‌one‌ ‌end‌ ‌of‌ ‌the‌ ‌sequence‌ ‌and‌ ‌remove‌ ‌them‌ ‌from‌ ‌the‌ ‌

other‌ ‌end.‌ ‌(Also‌ ‌known‌ ‌as:‌ ‌First‌ ‌in,‌ ‌First‌ ‌Out)‌ ‌

The‌ ‌textbook‌ ‌has‌ ‌separate‌ ‌implementations‌ ‌of‌ ‌a‌ ‌Stack‌ ‌and‌ ‌a‌ ‌Queue.‌ ‌ ‌

For‌ ‌this‌ ‌assignment,‌ ‌we‌ ‌will‌ ‌create‌ ‌an‌ ‌UnlimitedArray‌ ‌data‌ ‌structure‌ ‌that‌ ‌allows‌ ‌you‌ ‌to‌ ‌

add‌ ‌elements‌ ‌on‌ ‌one‌ ‌end‌ ‌but‌ ‌you‌ ‌can‌ ‌remove‌ ‌elements‌ ‌from‌ ‌either‌ ‌end‌ ‌(You‌ ‌can‌ ‌only‌ ‌

add‌ ‌to‌ ‌the‌ ‌front‌ ‌but‌ ‌you‌ ‌can‌ ‌remove‌ ‌from‌ ‌the‌ ‌front‌ ‌or‌ ‌the‌ ‌back.)‌ ‌If‌ ‌we‌ ‌have‌ ‌this‌ ‌data‌ ‌

structure‌ ‌it‌ ‌will‌ ‌be‌ ‌easy‌ ‌to‌ ‌make‌ ‌either‌ ‌a‌ ‌Stack‌ ‌or‌ ‌a‌ ‌Queue.‌ ‌Indeed,‌ ‌I‌ ‌provide‌ ‌you‌ ‌with‌ ‌

Stack‌ ‌and‌ ‌Queue‌ ‌code‌ ‌that‌ ‌uses‌ ‌this‌ ‌data‌ ‌structure.‌ ‌ ‌

**Detailed‌ ‌Instructions:**

As‌ ‌indicated‌ ‌in‌ ‌the‌ ‌syllabus,‌ ‌you‌ ‌are‌ ‌welcome‌ ‌to‌ ‌collaborate‌ ‌and‌ ‌discuss‌ ‌these‌ ‌

assignments‌ ‌with‌ ‌others‌ ‌in‌ ‌the‌ ‌class,‌ ‌but‌ ‌everyone‌ ‌should‌ ‌submit‌ ‌their‌ ‌own‌ ‌code.‌ ‌

Additionally,‌ ‌in‌ ‌a‌ ‌comment‌ ‌at‌ ‌the‌ ‌top‌ ‌of‌ ‌your‌ ‌files,‌ ‌please‌ ‌include:‌ ‌

–‌ ‌Your‌ ‌Name‌ ‌

–‌ ‌The‌ ‌names‌ ‌of‌ ‌anyone‌ ‌that‌ ‌you‌ ‌collaborated‌ ‌with‌ ‌

–‌ ‌Any‌ ‌resources‌ ‌other‌ ‌than‌ ‌the‌ ‌textbook‌ ‌that‌ ‌were‌ ‌particularly‌ ‌helpful‌ ‌(Youtube‌ ‌videos,‌ ‌

online‌ ‌examples,‌ ‌etc)‌ ‌ ‌

You‌ ‌can‌ ‌find‌ ‌the‌ ‌code‌ ‌for‌ ‌in‌ ‌the‌ ‌course‌ ‌GitHub‌ ‌repository‌ ‌

(‌ ‌‌https://github.com/mlepinski/Data-Structures‌‌ ‌)‌ ‌

**Part‌ ‌A:‌**

In‌ ‌the‌ ‌GitHub‌ ‌you‌ ‌should‌ ‌find‌ ‌an‌ ‌interface‌ ‌‌UnlimitedArray.‌ ‌‌This‌ ‌is‌ ‌a‌ ‌Data‌ ‌Structure‌ ‌that‌ ‌allows‌ ‌

one‌ ‌to‌ ‌store‌ ‌a‌ ‌sequence‌ ‌of‌ ‌integers‌ ‌and‌ ‌add‌ ‌or‌ ‌remove‌ ‌elements‌ ‌from‌ ‌either‌ ‌end‌ ‌of‌ ‌the‌ ‌

sequence.‌ ‌ ‌

You‌ ‌should‌ ‌implement‌ ‌UnlimitedArray‌ ‌using‌ ‌a‌ ‌Java‌ ‌array‌ ‌of‌ ‌integers.‌ ‌ ‌

I‌ ‌would‌ ‌recommend‌ ‌that‌ ‌you‌ ‌start‌ ‌with‌ ‌a‌ ‌small‌ ‌size‌ ‌array‌ ‌

E.g.,‌ ‌start‌ ‌with‌ ‌an‌ ‌array‌ ‌of‌ ‌four‌ ‌integers‌ ‌

my_array‌ ‌=‌ ‌new‌ ‌int[4]‌ ‌

When‌ ‌you‌ ‌run‌ ‌out‌ ‌of‌ ‌space‌ ‌in‌ ‌your‌ ‌array,‌ ‌you‌ ‌should‌ ‌create‌ ‌a‌ ‌new,‌ ‌larger‌ ‌array‌ ‌

…‌ ‌then‌ ‌copy‌ ‌over‌ ‌your‌ ‌data‌ ‌into‌ ‌the‌ ‌new‌ ‌array‌ ‌

I‌ ‌would‌ ‌recommend‌ ‌that‌ ‌you‌ ‌put‌ ‌this‌ ‌code‌ ‌into‌ ‌a‌ ‌function‌ ‌called‌ ‌resize‌ ‌

Write‌ ‌two‌ ‌implementations‌ ‌of‌ ‌‌UnlimitedArray‌ ‌‌that‌ ‌are‌ ‌exactly‌ ‌the‌ ‌same‌ ‌except‌ ‌for‌ ‌the‌ ‌way‌ ‌they‌ ‌

handle‌ ‌”resizing”.‌ ‌In‌ ‌the‌ ‌first‌ ‌implementation‌ ‌‌UnlimitedArraySlow,‌ ‌‌every‌‌ ‌‌time‌ ‌you‌ ‌run‌ ‌out‌ ‌of‌ ‌

space,‌ ‌you‌ ‌should‌ ‌add‌ ‌one‌ ‌more‌ ‌spot‌ ‌to‌ ‌your‌ ‌array.‌ ‌(That‌ ‌is,‌ ‌go‌ ‌from‌ ‌size‌ ‌4,‌ ‌to‌ ‌size‌ ‌5,‌ ‌to‌ ‌size‌ ‌6,‌ ‌

etc).‌ ‌In‌ ‌the‌ ‌second‌ ‌implementation‌ ‌‌UnlimitedArrayFast,‌ ‌‌every‌ ‌time‌ ‌you‌ ‌run‌ ‌out‌ ‌of‌ ‌space,‌ ‌you‌ ‌

should‌ ‌double‌ ‌the‌ ‌size‌ ‌of‌ ‌the‌ ‌array.‌ ‌(That‌ ‌is,‌ ‌go‌ ‌from‌ ‌size‌ ‌4,‌ ‌to‌ ‌size‌ ‌8,‌ ‌to‌ ‌size‌ ‌16,‌ ‌etc)‌ ‌ ‌

Note:‌ ‌‌There‌ ‌is‌ ‌nothing‌ ‌special‌ ‌about‌ ‌doubling,‌ ‌if‌ ‌you‌ ‌want‌ ‌to‌ ‌try‌ ‌1.5‌ ‌times‌ ‌bigger,‌ ‌or‌ ‌tripling‌ ‌the‌ ‌

size‌ ‌that‌ ‌is‌ ‌fine.‌ ‌

Run‌ ‌the‌ ‌test‌ ‌code‌ ‌to‌ ‌make‌ ‌sure‌ ‌that‌ ‌the‌ ‌Stack‌ ‌and‌ ‌Queue‌ ‌work‌ ‌using‌ ‌your‌ ‌implementations‌ ‌of‌ ‌

UnlimitedArrayFast‌ ‌and‌ ‌UnlimitedArraySlow‌ ‌

Use‌ ‌the‌ ‌Part‌ ‌A‌ ‌timing‌ ‌code‌ ‌to‌ ‌get‌ ‌runtime‌ ‌measurements‌ ‌for‌ ‌both‌‌ ‌UnlimitedArraySlow‌‌ ‌and‌ ‌

UnlimitedArrayFast‌.‌ ‌Your‌ ‌goal‌ ‌is‌ ‌to‌ ‌observe‌ ‌that‌ ‌UnlimitedArraySlow‌ ‌has‌ ‌substantially‌ ‌worse‌ ‌

runtime‌ ‌growth‌ ‌(longer‌ ‌runtimes)‌ ‌than‌ ‌UnlimitedArrayFast.‌ ‌Depending‌ ‌on‌ ‌your‌ ‌computer,‌ ‌you‌ ‌

will‌ ‌need‌ ‌to‌ ‌pick‌ ‌sufficiently‌ ‌large‌ ‌values‌ ‌for‌ ‌the‌ ‌amount‌ ‌of‌ ‌data‌ ‌to‌ ‌observe‌ ‌these‌ ‌trends.‌ ‌ ‌

Please‌ ‌create‌ ‌a‌ ‌graph‌ ‌or‌ ‌chart‌ ‌that‌ ‌shows‌ ‌N‌ ‌on‌ ‌the‌ ‌X-axis‌ ‌and‌ ‌Runtime‌ ‌/‌ ‌N‌ ‌on‌ ‌the‌ ‌Y-axis.‌ ‌I‌ ‌

recommend‌ ‌Google‌ ‌Sheets‌ ‌or‌ ‌Excel‌ ‌or‌ ‌Open‌ ‌Office‌ ‌to‌ ‌produce‌ ‌this‌ ‌graph,‌ ‌but‌ ‌any‌ ‌tool‌ ‌is‌ ‌fine.‌ ‌ ‌

**Part‌ ‌B:**

The‌ ‌textbook‌ ‌(in‌ ‌the‌ ‌queue‌ ‌chapters)‌ ‌discusses‌ ‌creating‌ ‌”circular”‌ ‌array‌ ‌structure.‌ ‌The‌ ‌core‌ ‌idea‌ ‌

is‌ ‌the‌ ‌following:‌ ‌

Suppose‌ ‌the‌ ‌array‌ ‌is‌ ‌100‌ ‌long‌ ‌and‌ ‌the‌ ‌data‌ ‌is‌ ‌currently‌ ‌goes‌ ‌from‌ ‌slot‌ ‌50‌ ‌to‌ ‌100‌ ‌

…‌ ‌for‌ ‌example‌ ‌you‌ ‌had‌ ‌100‌ ‌items‌ ‌in‌ ‌the‌ ‌array‌ ‌and‌ ‌then‌ ‌removed‌ ‌50‌ ‌items‌ ‌from‌ ‌the‌ ‌front‌ ‌

Then‌ ‌if‌ ‌you‌ ‌add‌ ‌a‌ ‌new‌ ‌item‌ ‌to‌ ‌the‌ ‌end‌ ‌of‌ ‌the‌ ‌array,‌ ‌you‌ ‌don’t‌ ‌need‌ ‌more‌ ‌space‌ ‌

‌…‌ ‌You‌ ‌can‌ ‌just‌ ‌”wrap‌ ‌around”‌ ‌and‌ ‌use‌ ‌the‌ ‌empty‌ ‌spots‌ ‌at‌ ‌the‌ ‌beginning‌ ‌of‌ ‌the‌ ‌array‌ ‌

Write‌ ‌an‌ ‌implementation‌ ‌of‌ ‌‌UnlimitedArray‌ ‌‌called‌ ‌‌UnlimitedArrayCircle,‌ ‌‌that‌ ‌uses‌ ‌this‌ ‌

“wrap-around”‌ ‌approach.‌ ‌

Use‌ ‌the‌ ‌Part‌ ‌B‌ ‌timing‌ ‌code‌ ‌to‌ ‌get‌ ‌runtime‌ ‌measurements‌ ‌for‌ ‌both‌‌ ‌UnlimitedArrayFast‌‌ ‌and‌ ‌

UnlimitedArrayCircle‌.‌ ‌Again‌ ‌you‌ ‌should‌ ‌pick‌ ‌large‌ ‌sizes‌ ‌to‌ ‌try‌ ‌and‌ ‌see‌ ‌the‌ ‌difference‌ ‌between‌ ‌

the‌ ‌two‌ ‌approaches.‌ ‌

Please‌ ‌create‌ ‌a‌ ‌graph‌ ‌or‌ ‌chart‌ ‌that‌ ‌shows‌ ‌N‌ ‌on‌ ‌the‌ ‌X-axis‌ ‌and‌ ‌Runtime‌ ‌/‌ ‌N‌ ‌on‌ ‌the‌ ‌Y-axis.‌ ‌I‌ ‌

recommend‌ ‌Google‌ ‌Sheets‌ ‌or‌ ‌Excel‌ ‌or‌ ‌Open‌ ‌Office‌ ‌to‌ ‌produce‌ ‌this‌ ‌graph,‌ ‌but‌ ‌any‌ ‌tool‌ ‌is‌ ‌fine.‌ ‌ ‌

**Submission:**

After‌ ‌you‌ ‌have‌ ‌completed‌ ‌the‌ ‌assignment,‌ ‌please‌ ‌submit‌ ‌a‌ ‌zip‌ ‌file‌ ‌containing‌ ‌two‌ ‌java‌ ‌files:‌ ‌

* UnlimitedArraySlow.java‌

* UnlimitedArrayFast.java‌ ‌

* UnlimitedArrayCircle.java‌ ‌

* A‌ ‌file‌ ‌containing‌ ‌a‌ ‌graph/chart‌ ‌of‌ ‌your‌ ‌runtime‌ ‌measurements‌ ‌for‌ ‌Part‌ ‌A‌ ‌

* A‌ ‌file‌ ‌containing‌ ‌a‌ ‌graph/chart‌ ‌of‌ ‌your‌ ‌runtime‌ ‌measurements‌ ‌for‌ ‌Part‌ ‌B‌ ‌

Assignment #2 Solution
$30.00 $24.00