Question

I am still new to Java Language, so please comment out lines so I can understand easily! thank you so much

The RecursionP2 class will have only one class level variables: an ArrayList of Integers that will store a data set on which you will be performing different operations using recursive function. All these functions can also be done using iteration, however, you are restricted to only use recursion for full credit. Your program might be randomly checked and any non-recursive approach will be marked down.

The following non-static public methods have to be declared in your class:

• Constructor (1-arg)

  • The constructor will accept in an 1-D array of type int of unknown length and add every element to the class level ArrayList.

• reverseList(ArrayList)

  • The method will accept in an ArrayList of type Integer and return a new ArrayList of type Integer that has all the elements in the reverse order. You are only allowed to use recursion for this method.

• reverseList()

  • The method will use the class level ArrayList and return a new ArrayList of type Integer that has all the elements in the reverse order. You are only allowed to use recursion for this method.
  • Hint: This method is a special case of reverseList(ArrayList) and you are allowed to use that method if it helps.

• toOddList(ArrayList )

  • The method will use the class level ArrayList as a parameter and return a new ArrayList of type Integer that contains all the odd indexed numbered elements of the class level ArrayList. You are only allowed to use recursion for this method.

• toOddList()

  • The method will accept in an ArrayList of type Integer and return a new ArrayList of type Integer that contains all the odd indexed numbered elements of the class level ArrayList.
  • Hint: This method is a special case of toOddList(ArrayList) and you are allowed to use that method if it helps.

• toEvenRevList(ArrayList )

  • The method will accept in an ArrayList of type Integer as a parameter and return a new ArrayList of type Integer that contains all the even indexed numbered elements of the class level ArrayList in reverse order. You are only allowed to use recursion for this method.
  • You can use the reverseList() method as a helper method.

• toEvenRevList()

  • The method will use the class level ArrayList and return a new ArrayList of type Integer that contains all the even indexed numbered elements of the class level ArrayList in reverse order. You are only allowed to use recursion for this method.
  • Hint: You can use toEvenRevList(ArrayList) or reverseList(ArrayList) as a helper method.

• retPenultimate(ArrayList )

  • The method will accept in an ArrayList of type Integer and return an int which is the last element of the ArrayList.If the list is empty/null, it should return -1. As usual, you are only allowed to use recursion for this method and the use of reverseList() is prohibited.

• getList()

  • The method would return the class level ArrayList. The return type is ArrayList.

Example

Original: [2, 4, 6, 8, 10]
reverseList(): [10, 8, 6, 4, 2]
toOddList(): [4, 8]
toEvenRevList(): [10, 6, 2]
retPenultimate(): 10 

Answer 1

// do comment if any problem arises

// code

import java.lang.annotation.RetentionPolicy;

import java.util.*;

class RecursionP2 {

    // class variable

    ArrayList<Integer> array_list;

    // constructor

    RecursionP2(ArrayList<Integer> list) {

        // create arralist

        array_list = new ArrayList<>();

        // copy given list to arraylist

        for (int i = 0; i < list.size(); i++)

            array_list.add(list.get(i));

    }

    // reverse given list

    public ArrayList<Integer> reverseList(ArrayList<Integer> list) {

        if (list.size() == 0)

            return new ArrayList<>();

        // call reverselist

        ArrayList<Integer> temp = reverseList(new ArrayList<>(list.subList(1, list.size())));

        // append 1st element to temp

        temp.add(list.get(0));

        return temp;

    }

    // this function returns reversed list in current object

    public ArrayList<Integer> reverseList() {

        return reverseList(this.array_list);

    }

    // temporary helper variable

    boolean i = false;

    public ArrayList<Integer> toOddList(ArrayList<Integer> list) {

        if (list.size() == 0) {

            i = false;

            return new ArrayList<>();

        }

        i = !i;

        boolean j = i;

        ArrayList<Integer> temp = toOddList(new ArrayList<>(list.subList(1, list.size())));

        if (!j) {

            ArrayList<Integer> temp1 = new ArrayList<>();

            temp1.add(list.get(0));

            // copy temp to temp1

            for (int i = 0; i < temp.size(); i++)

                temp1.add(temp.get(i));

            // insert first element

            return temp1;

        }

        return temp;

    }

    public ArrayList<Integer> toOddList() {

        return toOddList(this.array_list);

    }

    // returns even list

    public ArrayList<Integer> toEvenRevList(ArrayList<Integer> list) {

        if (list.size() == 0) {

            i = false;

            return new ArrayList<>();

        }

        i = !i;

        boolean j = i;

        ArrayList<Integer> temp = toEvenRevList(new ArrayList<>(list.subList(1, list.size())));

        if (j) {

            temp.add(list.get(0));

        }

        return temp;

    }

    public ArrayList<Integer> toEvenRevList() {

        return toEvenRevList(array_list);

    }

    // returns last element

    public int retPenultimate(ArrayList<Integer> list) {

        if (list.size() == 1)

            return list.get(0);

        return retPenultimate(new ArrayList<>(list.subList(1, list.size())));

    }

    public ArrayList<Integer> getList() {

        return array_list;

    }

    public static void main(String[] args) {

        // testing above class

        RecursionP2 testing = new RecursionP2(new ArrayList<Integer>(Arrays.asList(2, 4, 6, 8, 10)));

        System.out.println("Original: " + (testing.getList()));

        System.out.println("reverseList(): " + (testing.reverseList()));

        System.out.println("toOddList(): " + (testing.toOddList()));

        System.out.println("toEvenRevList(): " + (testing.toEvenRevList()));

        System.out.println(

                "revPenultimate(): " + testing.retPenultimate(new ArrayList<Integer>(Arrays.asList(2, 4, 6, 8, 10))));

    }

}

Output: