Question

In the USIntsArrayList Class, implement the USIntsArrayListInterface Interface (which is really just the UnSortedInts Class without the logic. All you are doing in this class is providing the same functionality as UnSortedInts, but using an ArrayList to hold the data. Document appropriately

Thank you,

package arrayalgorithms;

import java.util.ArrayList;

/**
* Title UnSorted Ints stored in an Array List
* Description: Implement all the functionality of the UnSortedInts
* class using an ArrayList
* @author Khalil Tantouri
*/
public class USIntsArrayList {
ArrayList<Integer> ints;
  
}

******Here's the UnSortedInts class, if that helps:

package arrayalgorithms;

/**
* Description: Holds an Array of unsorted ints
* @author Khalil Tantouri
*/
public class UnSortedInts {
private final int DEFAULT_SIZE = 10;
private int[] ints;
private int count;
  
// Constructor
  
public UnSortedInts() {
ints = new int[DEFAULT_SIZE];
count = 0;
}
  
public UnSortedInts(int size) {
ints = new int[size];
count = 0;
}
  
// addData
  
public void addData(int newInt) {
if (count == ints.length - 1) // If Count is at the last location
growData();
ints[count++] = newInt;
}
  
// removeData
// Given a val, it searches the Array for that val. If found
// it returns the val and removes the val from the list
// if not, it returns -1
public int removeData(int target) {
int location = findData(target);
if (location == -1)
return location;
else {
for (int i = location + 1; i < count; i++) {
ints[i-1] = ints[i];
}
count--;
return location;
}
}
  
// findData
// Write a method that searches the array for an int. Returns the location
// of that number. Returns -1 if not found
// Test Question. What kind of search is this?
public int findData(int target) {
for (int i = 0; i < count; i++) {
if (ints[i] == target)
return i;
}
return -1;
}
  
// cloneData
// Create a new array of the same size and copy the data into that array
// return that array
  
public int[] cloneData() {
int[] newInts = new int[count];
for (int i = 0; i < count; i++)
newInts[i] = ints[i];
return newInts;
}
  
// growData
// Write a method that creates a new array 10 ints larger
// then copies all the data to the new array
// THEN... sets the ints reference variable to point at the new array
private void growData() {
int[] newInts = new int[ints.length + 10];
for (int i = 0; i < count; i++) {
newInts[i] = ints[i];
}
ints = newInts; // Point our ints Instance Variable to reference
// the new array
  
}
  
// Sort Data
// How do we sort an Array. Let's use Selection Sort
// This method sorts our internal data and returns a clone of that
// data sorted
  
public int[] sortData() {
int[] clone;
for (int i = 0; i < count-1; i++) {
int smallest = findSmallest(i);
swap(i,smallest);
}
return cloneData();
}
  
public void swap(int val1, int val2) {
int temp = ints[val1];
ints[val1] = ints[val2];
ints[val2] = temp;
}
  
public int findSmallest(int startLoc) {
int smallest = startLoc;
for (int i = startLoc + 1; i < count; i++) {
if (ints[i] < ints[smallest])
smallest = i;
}
return smallest;
}
  
  
  
// toString
public String toString() {
String results = "";
for (int i = 0; i < count; i++) {
results += ints[i] + " ";
}
return results;
}
}

Answer 1

/* USIntsArrayListInterface.java */
package arrayalgorithms;

import java.util.ArrayList;

public interface USIntsArrayListInterface {
public void addData(int newInt) ;
public int removeData(int target);
public int findData(int target);
public ArrayList cloneData() ;
public void growData();
public ArrayList sortData();
public void swap(int val1, int val2);
public int findSmallest(int startLoc);
  
  
}

/* USIntsArrayList.java */

package arrayalgorithms;

import java.util.ArrayList;

public class USIntsArrayList implements USIntsArrayListInterface{
private ArrayList<Integer> ints;
private final int DEFAULT_SIZE = 10;
private int count;

public USIntsArrayList(){
ints = new ArrayList<>(DEFAULT_SIZE);
count = 0;
}
public USIntsArrayList(int size) {
ints = new ArrayList<>(size);
count = 0;
}
  
@Override
public void addData(int newInt) {
if (count == ints.size() - 1) // If Count is at the last location
growData();
ints.add(count++, newInt);
}

@Override
public int removeData(int target) {
int location = findData(target);
if (location == -1)
return location;
else {
for (int i = location + 1; i < count; i++) {
ints.add(i-1, ints.get(i));
}
count--;
return location;
}
}

@Override
public int findData(int target) {
for (int i = 0; i < count; i++) {
if (ints.get(i) == target)
return i;
}
return -1;
}

@Override
public ArrayList cloneData() {
ArrayList newInts = new ArrayList(count);
for (int i = 0; i < count; i++)
newInts.add(i,ints.get(i));

return newInts;
}

@Override
public void growData() {
ArrayList newInts = new ArrayList(ints.size() + 10);
for (int i = 0; i < count; i++) {
newInts.add(i,ints.get(i));
}
ints = newInts;
}

@Override
public ArrayList sortData() {
int n = ints.size();
  
// One by one move boundary of unsorted subarray
for (int i = 0; i < n-1; i++)
{
// Find the minimum element in unsorted array
int min_idx = i;
for (int j = i+1; j < n; j++)
if (ints.get(j) < ints.get(min_idx))
min_idx = j;
  
// Swap the found minimum element with the first
// element
int temp = ints.get(min_idx);
ints.add(min_idx,ints.get(i));
ints.add(i,temp);

}
return cloneData();
}

@Override
public void swap(int val1, int val2) {
int temp = ints.get(val1);
ints.add(val1, ints.get(val2));
ints.add(val2, temp);

}

@Override
public int findSmallest(int startLoc) {
int smallest = startLoc;
for (int i = startLoc + 1; i < count; i++) {
if (ints.get(i) < ints.get(smallest))
smallest = i;
}
return smallest;
}

@Override
public String toString() {
String results = "";
for (int i = 0; i < count; i++) {
results += ints.get(i) + " ";
}
return results;

}
  
}

/* PLEASE UPVOTE (THANK YOU IN ADVANCE) */