Lab 5 Please use JAVA In this lab assignment, we will compare our sorted doubly-linked list class, from lab 04, and develop an array-based alternative. These two implementations will then be compared for performance. Instructions In the previous lab assignment, you were tasked with writing a sorted doubly-linked list class to store a number of Warrior instances, keeping them sorted by the speed stat (highest to lowest). Implement the same behaviour in a class, called SortedArray, and add operating counting to both classes. Operation counting should focus only on assignment operations, and in both cases merely updating a public instance variable will be sufficient. The driver code that follows can be used to compare your two implementations: import java.util.Random; public class ComparisonDriver { public static void main(String[] args) { SortedDoublyLinkedList list = new SortedDoublyLinkedList(); SortedArray array = new SortedArray(); // insert 100 elements into both lists (randomly generated) for (int i = 0; i < 100; i++) { Warrior newWarrior = new Warrior("Generic", genStat(50), genStat(50), genStat(200)); list.insert(newWarrior); array.insert(newWarrior); } // compare the number of assignment operations: System.out.println("Linked List assignmentCount: " + list.assignmentCount); System.out.println("Sorted Array assignmentCount: " + array.assignmentCount); } public static int genStat(int max) { // randomly choose an integer between 1 and max Random rand = new Random(); return rand.nextInt(max) + 1; } } Run the driver code multiple times, and summarize the results. Try to come up with an explanation for why the test produced the values that it did. Attached below are the code from lab 4. Bolded are different classes used to run sorted doubly linked list class //sorted doubly linked list public class SortedDoublyLinkedList implements LinkedList { // Inner class private class Node { private Warrior warrior; private Node prev; private Node next; //warrior code public Node(Warrior warrior) { this.warrior = warrior;} // set warrior public void setWarrior(Warrior warrior) { this.warrior = warrior; } //get warrior public Warrior getWarrior() { return warrior; } // returns prev public Node getPrev() { return prev; } //next code public Node getNext() { return next; } //set previus public void setPrev(Node prev) { this.prev = prev; } //sets node public void setNext(Node next) { this.next = next; } //returns string public String toString() { return warrior.toString(); } } // Instance variables for SortedDoublyLinkedList private Node head; private int inc; //default constructor public SortedDoublyLinkedList() { this.head = null; this.inc = 0; } //add new warrior to list public void insert(Warrior warrior) { // Create new node Node newNode = new Node(warrior); // Last node Node lastNode = null; // Check if list is null if (this.inc == 0) { // Set newNode as the head this.head = newNode; } else { // If list is not null boolean inputed = false; // Get the head node Node node = this.head; while (!inputed && (node != null)) { // Compare warrior's speed with the warrior at node int res = warrior.getSpeed() - node.getWarrior().getSpeed(); if (res >= 0) { // If warrior's speed is greater than or equal to the warrior's speed at node // Check if node is the head node if (node.prev == null) { // Set new node as head this.head = newNode; } else { // Set newNode.prev as node.prev newNode.prev = node.prev; // Set node.prev.next as newNode node.prev.next = newNode; } // Set node.prev as newNode node.prev = newNode; // Set newNode.next as node newNode.next = node; inputed = true; } // Set last node if (node.next == null) lastNode = node; // Go to next node node = node.next; } // Check if node was not added if (!inputed) { // Set lastNode.next as newNode lastNode.next = newNode; // Set newNode.prev as lastNode newNode.prev = lastNode; } } // Increment count this.inc += 1; } //Returns the warriors contained in this doubly linked list sepearated by space. public String toString() { StringBuffer space = new StringBuffer("[ "); // Check if list is not null if (this.inc > 0) { // Get the head node Node node = this.head; while (node != null) { space.append(node + " "); // Go to next node node = node.getNext(); } } // Append closing bracket space.append("]"); return space.toString(); } } public class LinkedListDriver { public static void main(String[] args) { LinkedList list = new SortedDoublyLinkedList(); System.out.println(list); Warrior krogg = new Warrior("Krogg", 30, 50, 200); list.insert(krogg); System.out.println(list); Warrior gurkh = new Warrior("Gurkh", 40, 45, 180); list.insert(gurkh); System.out.println(list); Warrior brynn = new Warrior("Brynn", 45, 40, 190); list.insert(brynn); System.out.println(list); Warrior dolf = new Warrior("Dolf", 20, 65, 210); list.insert(dolf); System.out.println(list); Warrior zuni = new Warrior("Zuni", 50, 35, 170); list.insert(zuni); //interface public interface LinkedList { void insert(Warrior warrior); String toString(); } public class Warrior { private String name; private int speed; private int strength; private int hp; public Warrior(String name, int speed, int str, int hp) { this.name = name; this.speed = speed; this.strength = str; this.hp = hp; } public String getName() { return this.name; } public int getSpeed() { return this.speed; } public int getStrength() { return this.strength; } public int getHp() { return this.hp; } public String toString() { return this.name + "(" + this.speed + ")"; } }