Write a method max() which take a generic singly linked list as an argument and returns the maximum element reference in the list. If the list is empty, please throw an empty collection exception. The method prototype is defined as follows. public static > T max(SingleLinkedList list) throws EmptyCollectionException You can use any of public methods in these following three classes: 1. The SingleLinkedList class diagram is as follows: SingleLinkedNode -SingleLinkedNode next -T element SingleinkedNode) +SingleLinkedNode(T elem) +SingleLinkedNode getNext) Yold setNext(SingleLinkedNode first SingleLinkedNode last int numNodes SingleLinkedist) O+void addFirst(T element)

Write a method max() which take a generic singly linked list as an argument and returns the maximum element reference in the list. If the list is empty, please throw an empty collection exception. The method prototype is defined as follows. public static > T max(SingleLinkedList list) throws EmptyCollectionException You can use any of public methods in these following three classes: 1. The SingleLinkedList class diagram is as follows: SingleLinkedNode -SingleLinkedNode next -T element SingleinkedNode) +SingleLinkedNode(T elem) +SingleLinkedNode getNext) Yold setNext(SingleLinkedNode first SingleLinkedNode last int numNodes SingleLinkedist) O+void addFirst(T element)

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

Given the MileageTrackerNode class, complete main() in the MileageTrackerLinkedList class to insert nodes into a linked list (using the insertAfter() method). The first user-input value is the number of nodes in the linked list. Use the printNodeData() method to print the entire linked list. DO NOT print the dummy head node. Ex. If the input is: 3 2.2 7/2/18 3.2 7/7/18 4.5 7/16/18 the output is: 2.2, 7/2/18 3.2, 7/7/18 4.5, 7/16/18 public class MileageTrackerNode { private double miles; // Node data private String date; // Node data private MileageTrackerNode nextNodeRef; // Reference to the next node public MileageTrackerNode() { miles = 0.0; date = ""; nextNodeRef = null; } // Constructor public MileageTrackerNode(double milesInit, String dateInit) { this.miles =…
Write a method replace to be included in the class KWLinkedList (for doubly linked list) that accepts two parameters, searchItem and repItem of type E. The method searches for searchItem in the doubly linked list, if found then replace it with repItem and return true. If the searchItem is not found in the doubly linked list, then insert repItem at the end of the linked list and return false. Assume that the list is not empty. You can use ListIterator and its methods to search the searchItem in the list and replace it with repItem if found. Do not call any method of class KWLinkedList to add a new node at the end of the list. Method Heading: public boolean replace(E searchItem, E repItem) Example: searchItem: 15 repItem: 17 List (before method call): 9 10 15 20 4 5 6 List (after method call) : 9 10 17 20 4 5 6
In the existing CircularlyLinkedList class, Write a non-static method named getMax for finding the maximum element in a circularly linked list. Write the testing code in the main method of the class CircularlyLinkedList. For this purpose, you must only use and update the CircularlyLinkedList.java file provided in Lesson3Examples posted in the eCentennialmodule "Lesson Examples (from textbook)" package exercise3; public class CircularlyLinkedList<E> { private static class Node<E> { private E element; private Node<E> next; public Node(E e, Node<E> n) { element = e; next = n; } public E getElement() { return element; } public Node<E> getNext() { return next; } public void setNext(Node<E> n) { next = n; } } private Node<E> tail = null; private int size = 0; public CircularlyLinkedList() { } public int size() { return size; } public boolean isEmpty() { return size == 0; } public E first() { if (isEmpty()) return null; return…
Trying this again since part of my question keeps disappearing Given main() in the ShoppingList class, define an insertAtEnd() method in the ItemNode class that adds an element to the end of a linked list. DO NOT print the dummy head node. Ex. if the input is: 4 Kale Lettuce Carrots Peanuts where 4 is the number of items to be inserted; Kale, Lettuce, Carrots, Peanuts are the names of the items to be added at the end of the list. The output is: Kale Lettuce Carrots Peanuts public class ItemNode { private String item; private ItemNode nextNodeRef; // Reference to the next node public ItemNode() { item = ""; nextNodeRef = null; } // Constructor public ItemNode(String itemInit) { this.item = itemInit; this.nextNodeRef = null; } // Constructor…
Write a method called changeQueue to be considered inside the ArrayQueue class and has one parameter item of type E. Your method will change the queue in such a way that if the the first element of the queue and the last element of the queue are equal, the first and last elements in the queue will be replaced with item, otherwise, do not do any change. Similarly, the same process is done for the second element in the queue and the element before the last in the queue and so on. Assume you have a non-empty queue with even number of elements. You are not allowed to call any method from the the ArrayQueue class. Do not use iterators. Method head: public void changeQueue(E item) Example1: Before run: front rear “this” queue: 10 29 2 2 5 10 Item1: 100 After run: front rear “this” queue: 100 29 100 100 5 100
To help manage the wizarding world, we need to write a reverse method. For the general purpose, let us write a generic reverse method. Namely, given an array of T objects, the reverse method would use a stack to reverse these T objects and return a new ArrayList with these T objects in reverse order. The generic method prototype is as follows: public <T> ArrayList<T> reverse(T[] wizards) throws Exception; To help reverse Hogwarts students' names, we can invoke the method as follows: reverse({"Harry Potter", "Ronald Bilius", "Hermione Jean Granger"}) , where {"Harry Potter", "Ronald Bilius", "Hermione Jean Granger"} is an array input and it will return an java.util.ArrayList instance, containing "Hermione Jean Granger" as the first element, "Ronald Bilius" as the second element, and "Harry Potter" as the third element. Task 1. Please use a Stack to implement the generic reverse method: public ArrayList reverse(T[] wizards) throws Exception First write…
Write a method called swapltems to be considered within the SingleLinkedList class that takes two parameters, index1 and index2 of type integer. The method swaps the data of the nodes at the given indexes. If any of the parameters indexes is invalid throw IndexOutOfBoundsException. Do not call any method of class SingleLinkedList in your method. Method heading: public void swapltems(int index1, int index2) Example: index1 = 2 index2 = 4 Before method call: list: 5 10 12 9 11 7 After method call: list: 5 10 11 9 12 7
Write a Program in Java programming: Support you have an ArrayList containing random integers. These integers can be any number, and each integer can appear more than once. For example, [2, 19, 21, 19, 21, 1, 3, 3, 6, 21, .....] Your job is to write a method called findEvenFrequentNumbers(ArrayList<Integer> list) that returns an ArrayList which has all the numbers appears in even frequency and in increasing order. e.g. list = [2, 19, 21, 19, 21, 1, 3, 3, 6, 21], should return [3, 19] list = [3, 3, 3, 1, 2, 2, 2, 2, 2], should return [] list = [1, 1, 1, 1, 1], should return [1] Note that you need to provide a class with the main function and also the imports.
Implement unique method that takes an ArrayList as input and returns an ArrayList withexactly a single occurrence of each element from the input list. For example, if the input listcontains 5, 6, 7, 6, 3, 5, 5, 4 then the output list should have 5, 6, 7, 3, 4.Note: (1) You may assume that the ArrayList has a specific type of elements in it. In the class, we assumedit to have String type values. (2) You may only work with ArrayList(s).
Your activity: write a same java program that will accept 20 integer in a list and returns the index of the first occurrence of the smallest element in the array. Also, write a program to test your method. Write a Java method, smallestIndex, that takes as its parameters an int array and its size, and returns the index of the (first occurrence of the) smallest element in the array. public class Array_labExercise2 { public static void main(String[] args) { int[] list = {56, 34, 67, 54, 23, 87, 66, 92, 15, 32, 55, 15, 88, 22, 30}; System.out.print("List elements: "); printArray(list); System.out.println(); System.out.println("Index of the (first occurenc of the) " + "smallest element in list is: " + smallestIndex(list)); System.out.println("Smallest element in list is: " + list[smallestIndex(list)]); } public static void printArray(int[] list) { int counter; for (counter = 0; counter < list.length; counter++) System.out.print(list[counter] + " ");…
Write a method called deleteMultipleNodes to be included in the class KWLinkedList (class for doubly linked list). The method has two parameters count of type int and direction of type char. The count is the number of nodes to be deleted in the specified direction. The direction can be either ‘f’ or ‘b’. The method returns false, if the list is empty or the number of nodes in the list is less than count. The method checks the direction, if direction is ‘f’, the method removes count number of nodes in the forward direction, otherwise, the method removes count number of nodes in the backward direction, and returns true. NOTE: You can use ListIterator and its methods. Example 1: Before run: head tail list: 20 50 70 90 33 89 count: 2 direction: ’f’ After run: head tail list: 70 90 33 89 Example 2: Before run:…
In the existing DoublyLinkedList class, write and test a non-static method named reverseList to reverse a doubly linked list. Write the testing code in the main method of the class DoublyLinkedList. For this purpose, you must only use and update the DoublyLinkedList.java file provided in Lesson2Examples posted in the eCentennial module “Lesson Examples (from textbook)” package Ex2; public class DoublyLinkedList<E> { private static class Node<E> { private E element; // reference to the element stored at this node private Node<E> prev; // reference to the previous node in the list private Node<E> next; // reference to the subsequent node in the list public Node(E e, Node<E> p, Node<E> n) {element = e;prev = p;next = n;} // public accessor methodspublic E getElement() { return element; } public Node<E> getPrev() { return prev; } public Node<E> getNext() { return next; } // Update methodspublic void setPrev(Node<E> p) { prev = p; }…