import java.util.*; class Collection_iterators { public static void main(String args[]) { LinkedList list = new LinkedList(); list.add(new Integer(2)); list.add(new Integer(8)); list.add(new Integer(5)); list.add(new Integer(1)); Iterator i = list.iterator(); Collections.reverse(list); Collections.sort(list); while(i.hasNext()) System.out.print(i.next() + " "); }

import java.util.*; class Collection_iterators { public static void main(String args[]) { LinkedList list = new LinkedList(); list.add(new Integer(2)); list.add(new Integer(8)); list.add(new Integer(5)); list.add(new Integer(1)); Iterator i = list.iterator(); Collections.reverse(list); Collections.sort(list); while(i.hasNext()) System.out.print(i.next() + " "); }

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

For the Queue use the java interface Queue with the ArrayDeque classFor the Stack use the java Deque interface with the ArrayDeque classFor the LinkedList, use the java LinkedList class Also, when you are asked to create and use a Queue, you can use only those methods pertaining to the general operations of a queue (Enqueue: addLast, Dequeue: removeFirst, and peek() Similarly, when you are asked to create and/or use a stack, you can use only those methods pertaining to the general operations of a Stack (push: addFirst, pop:removeFirst, and peek() ) Your code should not only do the job, but also it should be done as efficiently as possible: fast and uses no additional memory if at all possible Questions Write a method “int GetSecondMax(int[] array)” . this method takes an array of integers and returns the second max value Example: if the array contains: 7, 2, 9, 5, 4, 15, 6, 1}. It should return the value: 9
Apply the methods in the ListIterator interface to write a Java program in NetBeans that creates a LinkedList of four elements of type string, namely: Java, C#, PHP and Python.The program should then print out the elements initially in the original order, and then afterwards in reverse order using the ListIterator methods.
import java.util.LinkedList; public class IntTree { private Node root; private static class Node { public int key; public Node left, right; public Node(int key) { this.key = key; } } public void printInOrder() { printInOrder(root); } private void printInOrder(Node n) { if (n == null) return; printInOrder(n.left); System.out.println(n.key); printInOrder(n.right); } /* * Returns the number of nodes with odd keys. For example, the BST with level * order traversal 50 25 100 12 37 150 127 should return 3 (25, 37, and 127). */ public int sizeOdd() { // TODO throw new RuntimeException("Not implemented"); } • You are not allowed to use any kind of loop in your solutions. • You may not modify the Node class in any way• You may not modify the function headers of any of the functions already present in the file.• You may not add any fields to the IntTree…
import java.util.LinkedList; public class IntTree { private Node root; private static class Node { public int key; public Node left, right; public Node(int key) { this.key = key; } } public void printInOrder() { printInOrder(root); } private void printInOrder(Node n) { if (n == null) return; printInOrder(n.left); System.out.println(n.key); printInOrder(n.right); } /* * Returns the number of nodes with odd keys. For example, the BST with level * order traversal 50 25 100 12 37 150 127 should return 3 (25, 37, and 127). */ public int sizeOdd() { return sizeOddHelper(root) { } private int sizeOddHelper(Node odd) { // TODO throw new RuntimeException("Not implemented"); }
import java.util.LinkedList; public class IntTree { private Node root; private static class Node { public int key; public Node left, right; public Node(int key) { this.key = key; } } public void printInOrder() { printInOrder(root); } private void printInOrder(Node n) { if (n == null) return; printInOrder(n.left); System.out.println(n.key); printInOrder(n.right); } /* * Returns the number of nodes with odd keys. For example, the BST with level * order traversal 50 25 100 12 37 150 127 should return 3 (25, 37, and 127). */ public int sizeOdd() { // TODO throw new RuntimeException("Not implemented"); }
import java.util.LinkedList; public class IntTree { private Node root; private static class Node { public int key; public Node left, right; public Node(int key) { this.key = key; } } public void printInOrder() { printInOrder(root); } private void printInOrder(Node n) { if (n == null) return; printInOrder(n.left); System.out.println(n.key); printInOrder(n.right); } /* * Returns the number of nodes with odd keys. For example, the BST with level * order traversal 50 25 100 12 37 150 127 should return 3 (25, 37, and 127). */ public int sizeOdd() { // TODO throw new RuntimeException("Not implemented"); } • You are not allowed to use any kind of loop in your solutions. Only recursions. • You may not modify the Node class in any way• You may not modify the function headers of any of the functions already present in the file.• You may not add any fields…
COVID-19 has an effect on the whole world. People are interested in knowing the current situation of COVID-19. You are required to write JAVA-program for storing information in a Single way Linked List. Following JAVA classes are provided. // Node class public class COVIDDetail { public String country; public int activecases; public COVIDDetail next; } // linked List class public class COVIDList { COVIDDetail start=null; } You are required to add the following methods to COVIDList class void add(COVIDDetail n) this method receives a node as an argument and adds it to the given list. Nodes are arranged in descending order with respect to number of cases. Note that you are not required to sort the list in fact while adding first find its appropriate position and then add a given node to that position. void updateCases(String country_name , int cases) this method receives two-argument country names and cases (can have positive or negative value). Update…
Complete the method printSkipper below. Use a loop to print every other element of a linked list parameter words. Print a space after every word and a newline after all elements have been printed. For example, if the list contains the strings "A", "B", and "C", print A C import java.util.Iterator;import java.util.LinkedList; public class Lists{ public static void printSkipper(LinkedList<String> words) { Iterator<String> iter = words.iterator(); //code here System.out.println(); }}
/ This method takes as parameters a reference to the head of a linked list, a // position specified by n, and a key. It returns the number of occurrences // of the key in the linked list beginning at the n-th node. If n = 0, it means // you should search in the entire linked list. If n = 1, then you should skip // the first node in the list. public int numOccurrencesRec(LNode node, int n, int key) { // TODO: implement this method return 0; // replace this statement with your own return } } LNode Below: public class LNode{ // instance variables private int m_info; private LNode m_link; // constructor public LNode(int info) { m_info = info; m_link = null; } // member methods public void setLink(LNode link) { m_link = link; } public LNode getLink() { return m_link; } public int getInfo() { return m_info; } }
// This method takes as parameters a reference to the head of a linked list, a // position specified by n, and a key. It returns the number of occurrences // of the key in the linked list beginning at the n-th node. If n = 0, it means // you should search in the entire linked list. If n = 1, then you should skip // the first node in the list. public int numOccurrencesRec(LNode node, int n, int key) { // TODO: implement this method return 0; // replace this statement with your own return }}
Implement a method concatenate in class LinkedQueue. This method should take all the elements of a queue sourceQ and append them to the end of another queue targetQ. The operation should result in sourceQ being an empty queue. Test this method in the main method of LinkedQueue. package queues;public class LinkedQueue<E> implements Queue<E> { private SinglyLinkedList<E> list = new SinglyLinkedList<>(); // an empty list public LinkedQueue() { } // new queue relies on the initially empty list @Override public int size() { return list.size(); } @Override public boolean isEmpty() { return list.isEmpty(); } @Override public void enqueue(E element) { list.addLast(element); } @Override public E first() { return list.first(); } @Override public E dequeue() { return list.removeFirst(); } public String toString() { return list.toString(); }}
Implement Stack and Queue using LinkList class and compare the performance between StackArray,QueueArray and StackLinkList and QueueLinkList : class LinkList{ private Node first; // ref to first item on list public Node getFirst() // get value of first { return first; } public void setFirst(Node f) // set first to new link { first = f; } public LinkList() // constructor { first = null; } // no items on list yet public boolean isEmpty() // true if list is empty { return (first==null); } public void insertFirst(int dd) { // insert at start of list Node newLink = new Node(dd); // make new link newLink.next = first; // newLink --> old first first = newLink; //…