Question

Java Program

Create a class to store an array of with enough space to store 10 integer values.

Using the principle of recursion, implement the following:

*getSize : returns the size of the array.

*get (i): returns the i-th element of the array. If the element does not exist, it throws a "NoSuchElementException” which is a subclass of Java class RunTimeException.

*add (val): inserts value as the last element of the array. If necessary, double the size of the current array to accommodate the new item.

*equals: Two MyArrays are equal if they have the same number of elements in the same order. Implement this overriding method recursively.

*sum: returns the sum of all elements of the array. Implement this recursively.

*max: returns the largest element of the array.  Implement this recursively.

*min: returns the smallest element of the array. . Implement this recursively.

*srch (elt): Searches for the element using the recursive binary search algorithm and returns the index of position where it is found, -1 if not found.

*sort: Sorts the array using the bubble sort algorithm.  Implement this recursively.

*invert: Inverts the order of elements in the array.  Implement this recursively

*toString: This must return a String which contains complete information about the array including how many elements it has and what are their values. Overrides the same method in the Object class.

To test the program, follow the instructions below:

Please use JOptionPane,  FileReader to read form a text input file and PrintWriterwrite to write to the output file

*Create a default MyArray MA1.

*Prompt the user for the name of the input and output files.

*Output the size of MA1.

*Read the number of elements to insert in MA1. Let this be n. [This is the first line of input from the file.]

*Now, read n integer values from the file and insert them in MA1 in that order.

*Output the size of MA1.

*Output MA1.

*Find and output the largest and smallest elements of MA1.

*Output the sum of all elements of MA1.

*Create another MyArray MA2 by copying MA1.

*Check and output if MA1 and MA2 are equal.

*Sort MA2 using the recursive bubble sort algorithm.

*Check and output if MA1 and MA2 are equal.

*Output MA2.

*Read the search elements from the input file (just continue to read the input file) till the end of the file, and for each element, output if that element exists in MA2. If it does, output its position; otherwise indicate that it does not exist in the array.

*Invert MA2.

*output MA2.

Input File:

13 // Number of elements to insert in the array

573

2739

76321

3873

73430

333

7293

38383

272

946

3832

8410

2583 // Last element for insertion - Search Elements follow

333

946

76321

26353

833

3832

123

573

765

2583

Answer 1

/**
 * @fileName MyArray.java
 * @author 
 * @since 14/3/17
 */


package myarray;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.Scanner;

public class MyArray {
    private int arr[];
    private int size;


    /**
     * This is default constructor
     */
    public MyArray() {
        arr = new int[10];
    }

    /**
     * This parametrized constructor
     *
     * @param size
     */
    public MyArray(int size) {
        arr = new int[size];
    }

    /**
     * This is copy constructor
     *
     * @param myArray
     */
    public MyArray(MyArray myArray) {
        this.arr = myArray.arr;
        this.size = myArray.size;
    }


    public static void main(String[] args) throws FileNotFoundException {
        MyArray MA1 = new MyArray();
        Scanner sc = new Scanner(System.in);
        System.out.print("enter the name of input file:");
        String inputFileName = sc.nextLine();
        System.out.print("enter the name of input file:");
        String outputFileName = sc.nextLine();

        sc.close();
        System.out.println(MA1.getSize());

        sc = new Scanner(new FileReader(inputFileName));
        int n = sc.nextInt();
        for (int i = 0; i < n; i++) {
            MA1.add(sc.nextInt());
        }


        System.out.println("Size of MA1:" + MA1.getSize());
        System.out.println("MA1:" + MA1);
        System.out.println("MAX:" + MA1.max());
        System.out.println("MIN:" + MA1.min());
        System.out.println("SUM:" + MA1.sum());


        MyArray MA2 = new MyArray(MA1);
        System.out.println(MA1.equals(MA2));
        System.out.println(MA2);
        MA2.recursiveBubbleSort();
        System.out.println(MA1.equals(MA2));
        while (sc.hasNext()) {
            int elem = sc.nextInt();
            int a = MA2.binarySearch(elem);
            if (a != -1) {
                System.out.println(a);
            } else {
                System.out.println(elem + " does not exist in array");
            }
        }

        MA2.reverse();
        System.out.println(MA2);


    }


    /**
     * This method return the count of element
     *
     * @return
     */
    public int getSize() {
        return this.size;
    }

    /**
     * This method return the value at given index, index start from 0
     *
     * @param index
     * @return
     */
    public int get(int index) {
        if (index >= size) {
            throw new NoSuchElementException();
        } else {
            return this.arr[index];
        }
    }

    /**
     * This method will add the given value at the end of array
     *
     * @param val
     */
    public void add(int val) {
        if (size >= this.arr.length) {
            int[] arr = new int[this.arr.length * 2];
            for (int i = 0; i < this.arr.length; i++) {
                arr[i] = this.arr[i];
            }
            this.arr = arr;
            this.arr[size] = val;
        } else {
            this.arr[size] = val;
        }
        size++;

    }

    public int max() {
        return max(0);
    }

    public int max(int index) {
        if (index != size) {
            return Math.max(this.arr[index], max(index + 1));
        } else {
            return this.arr[0];
        }
    }

    public int min() {
        return min(0);
    }

    public int min(int index) {
        if (index != size) {
            return Math.min(this.arr[index], min(index + 1));
        } else {
            return this.arr[0];
        }
    }

    public int sum() {
        return sum(0);
    }

    private int sum(int index) {
        if (index == size) {
            return this.arr[index - 1];
        } else {
            return this.arr[index] + sum(index + 1);
        }
    }


    public int binarySearch(int target) {
        return binarySearch(this.arr, 0, size - 1, target);
    }

    public int binarySearch(int[] a, int start, int end, int target) {
        int middle = (start + end) / 2;
        if (end < start) {
            return -1;
        }

        if (target == a[middle]) {
            return middle;
        } else if (target < a[middle]) {
            return binarySearch(a, start, middle - 1, target);
        } else {
            return binarySearch(a, middle + 1, end, target);
        }
    }


    public int[] recursiveBubbleSort() {
        return recursiveBubbleSort(size);
    }

    public int[] recursiveBubbleSort(int n) {
        if (n == 1) {
            return this.arr; //finished sorting
        }

        int temp;
        for (int i = 0; i < n - 1; i++) {
            if (this.arr[i + 1] < this.arr[i]) {
                temp = this.arr[i];
                this.arr[i] = this.arr[i + 1];
                this.arr[i + 1] = temp;
            }
        }
        return recursiveBubbleSort(n - 1);
    }


    public void reverse() {
        reverse(0, size - 1);
    }

    public void reverse(int start, int end) {
        if (start < end) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            reverse(start + 1, end - 1);
        }
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        MyArray myArray = (MyArray) o;

        if (size != myArray.size) return false;
        return Arrays.equals(arr, myArray.arr);
    }

    @Override
    public int hashCode() {
        int result = Arrays.hashCode(arr);
        result = 31 * result + size;
        return result;
    }


    @Override
    public String toString() {
        String s = "Size:" + size + " Elements: ";
        for (int i = 0; i < size; i++) {
            s += arr[i] + " ";
        }
        return s;

    }
}

output:

enter the name of input file:inputint.txt enter the name of input file:output. txt 03 Size of MA1: 13 MA1:Size:13 Elements: 573 2739 76321 3873 73430 333 7293 38383 272 946 3832 8410 2583 MAX:76321 MIN: 272 SUM:221571 true Size: 13 Elements: 573 2739 76321 3873 73430 333 7293 38383 272 946 3832 8410 2583 true 12 26353 does not exist in array 833 does not exist in array 123 does not exist in array 765 does not exist in array 4 Size: 13 Elements: 76321 73430 38383 8410 7293 3873 3832 2739 2583 946 573 333 272 Process finished with exit code 0