In Java code, implement the HeapSort algorithm. Your function must t.pdf

•

0 likes•1 view

In a random sample of male and female graduates of the New York School for the Arts between the ages of 22-35 you know that: • the probability a man is a ballet dancer is 0.245. • the probability a woman is a musical performer is 0.365 • the probability a man is a musical performer, given that he\'s a ballet dancer is 0.250. • the probability a woman is an actress is 0.550. • the probability a woman is an actress, given that she\'s a musical performer is .785. Compute the following probabilities: A. P (man is a ballet dancer and a musical performer) B. P (woman is an actress and a musical performer) C. P (woman is an actress or a musical performer) Solution =0.245*(1-0.365)=0.155 b. P (woman is an actress and a musical performer) =0.365*0.55=0.2 c. P (woman is an actress or a musical performer) =P(woman is an actress)+P(musical performer)-P(actress or performer) =0.55+0.365-0.785*0.365=0.628.

Education

In Java code, implement the HeapSort algorithm. Your function must take an ArrayList as input
and output a sorted ArrayList. Allow the program to accept user input that becomes added to the
ArrayList, if no elements are added by the user, handle the exception.
Solution
Hi, Please find my program.
Please let me know in case of any issue.
import java.util.ArrayList;
import java.util.Scanner;
//Java program for implementation of Heap Sort
public class HeapSort
{
public void sort(ArrayList list)
{
int n = list.size();
// Build heap (relistangelistay)
for (int i = n / 2 - 1; i >= 0; i--)
heapify(list, n, i);
// One by one extract an element from heap
for (int i=n-1; i>=0; i--)
{
// Move current root to end
int temp = list.get(0);
list.set(0, list.get(i));
list.set(i, temp);
// call max heapify on the reduced heap
heapify(list, i, 0);
}
}
// To heapify a subtree rooted with node i which is
// an index in list[]. n is size of heap
void heapify(ArrayList list, int n, int i)
{
int largest = i; // Initialize largest as root

int l = 2*i + 1; // left = 2*i + 1
int r = 2*i + 2; // right = 2*i + 2
// If left child is larger than root
if (l < n && list.get(l) > list.get(largest))
largest = l;
// If right child is larger than largest so far
if (r < n && list.get(r) > list.get(largest))
largest = r;
// If largest is not root
if (largest != i)
{
int swap = list.get(i);
list.set(i, list.get(largest));
list.set(largest, swap);
// Recursively heapify the affected sub-tree
heapify(list, n, largest);
}
}
/* A utility function to print list of size n */
static void printlist(ArrayList list)
{
int n = list.size();
for (int i=0; i list = new ArrayList();
System.out.print("How many elements you want to sort: ");
int n = sc.nextInt();
System.out.println("Enter "+n+" integers: ");
for(int i=0; i

Similar to In Java code, implement the HeapSort algorithm. Your function must t.pdf

In this homework, you will write a program modify program you wrote in Homework3. 2) Modify the MyList class that you wrote for Programming challenge 1 so the type parameter T should accept any type that implements the Comparable interface. Test the class in a program that creates one instance of MyList to store Integers, and another instance to store Strings. Input two numbers from the user and insert them into the first instance of Modified MyList. Input name and City and insert the two strings into the second instance of modified MyList class. Then display the contents of the the two instances. here is the program to modify import java.util.ArrayList; import java.util.Scanner; public class Main { public static void main(String[] args) { // part 1 code. // creating a Number list MyList<Number> intList = new MyList<>(); // adding the numbers mentioned in the question intList.add(2); intList.add(5); intList.add(-13); intList.add(11); intList.add(12); // creating a Double list, adding double values to it MyList<Double> doubleList = new MyList<>(); doubleList.add(27.3); doubleList.add(5.7); doubleList.add(-23.9); doubleList.add(1.11); doubleList.add(5.12); System.out.println("PART 1"); // printing largest and smallest of both lists System.out.println("The Integer largest: \n" + intList.largest()); System.out.println("The Integer smallest: \n" + intList.smallest()); System.out.println("The Double largest: \n" + doubleList.largest()); System.out.println("The Double smallest: \n" + doubleList.smallest()); } } //MyList class, which is defined outside Generics1 class BUT still within Generics1.java file. class MyList<T extends Number> { // defining an array list as storage ArrayList<T> list; // constructor initializing list public MyList() { // initializing array list list = new ArrayList<>(); } // method to add a value to the list public void add(T value) { list.add(value); } // method to return the largest element on the list public T largest() { // assuming list is not empty, taking first value as largest T max = list.get(0); for (int i = 1; i < list.size(); i++) { // comparing element at i with max using doubleValue() of Number class if (list.get(i).doubleValue() > max.doubleValue()) { max = list.get(i); } } return max; } // method to return the smallest element on the list public T smallest() { // assuming list is not empty, taking first value as smallest T min = list.get(0); for (int i = 1; i < list.size(); i++) { // comparing element at i with min using doubleValue() of Number class if (list.get(i).doubleValue() < min.doubleValue()) { min = list.get(i); } } return min; } // returns the elemnt at a given position public T get(int index) { return list.get(index); } } Here is the sample input/outPut TestCase1: PART 2 Please enter a number: 30 Please another number: 20 Please enter your name: John Please enter your City: Los Angeles First number is 30 Second number is 20 Name is: John City is: Los Angeles TestCase2: PART 2 Please enter a number: .

In this homework- you will write a program modify program you wrote in.pdf

EvanpZjSandersony

Create a JAVA Program that traverses through an array recursively, rather than with a loop, and prints out each element in the array. Java only, this will be a short program. Solution public void dosomethingtoall(List list) { //begin recurssion dosomethingtoall(list,0); } private void dosomethingtoall(Last list,int index) { //break recurssion when to proceed entire list. if(index>=list.size()) return; //do what ever you want with the list. process(list.get(index)); //recursive step.process the next element. dosomethingtoall(list,index+1); } or by using traversal import java.util.Listiterator; import java.util.Arraylist; public class traverseforwordingusingListiteratorexample { public static void main(String args[]) { //create an array of object list Arraylist alist=new Arraylist(); //add elements to arraylist object alist.add(\"1\"); alist.add(\"2\"); alist.add(\"3\"); alist.add(\"4\"); alist.add(\"5\"); //get an object of Listiterator using listiteratot() Listiterator listiterator=alist.listiterator(); /*traverse arraylist in forward direction using hasNext and next methods of listiterator.hasNEXT Returns true if Listiterator has more elements to traverse in forwrd direction.next methid returns next element in the list*/ Sysytem.out.println(\"traversing arraylist in forward direction using Listiterator\"); while(listiterator.hasNext()) system.out.println(listiterator.next()); } } .

Create a JAVA Program that traverses through an array recursively- rat.docx

mrichard5

Write a program that will test a name) method no sorting routine from.docx

ajoy21

DAA Lab Work.docx

Deepusri2000Srivasta

(Unordered Sets) As explained in this chapter, a set is a collection of distinct elements of the same type. Design the class unorderedSetType, derived from the class unorderedArrayListType, to manipulate sets. Note that you need to redefine only the functions insertAt, insertEnd, and replaceAt. If the item to be inserted is already in the list, the functions insertAt and insertEnd output an appropriate message. Similarly, if the item to be replaced is already in the list, the function replaceAt outputs an appropriate message.Include the set operations of union and intersection in your class. Also write a program to test your class. (C++) #ifndef UNORDEREDARRAYLISTTYPE_H #define UNORDEREDARRAYLISTTYPE_H #include \"arrayListType.h\" class unorderedArrayListType : public arrayListType { public: void insertAt(int location, int insertItem); // Function to insert an item at a particular location // Postcondition: The item has been added to the list and the length has // been increased by 1. void insertEnd(int insertItem); // Function to insert an item at the end of the list // Postcondition: The item has been added at the end of the list and the // length has been increased by 1. void replaceAt(int location, int repItem); // Function to replace an item in the list. // Postcondition: repItem overrwrites the item at the specified location // in the list. The length of the list is unchanged. int seqSearch(int searchItem) const; // Function to search the list for searchItem. Note that this is an // abstract function. //Postcondition: If the item is found, returns the location in the array // where the item is found; otherwise, returns -1. void remove(int removeItem); // Function to remove an item from the list // Postcondition: If the item is found in the list, it is removed and the // length of the list is decreased by 1; if the item is not in the list // an appropriate message is displayed. void removeAll(int removeItem); // Function to remove all occurrences of an item from the list // Postcondition: If the item is found in the the list, all occurrences are // removed and the length of the list is decreased accordingly. If the // item is not in the list an appropriate message is displayed. unorderedArrayListType(int size = 100); //Constructor. }; #endif // UNORDEREDARRAYLISTTYPE_H #include \"UnorderedArrayListType.h\" #include using namespace std; void unorderedArrayListType::insertAt(int location, int insertItem) { if (location < 0 || location >= maxSize) cout<<\"The position of the item to be inserted is out of range.\"<= maxSize) //list is full cout << \"Cannot insert in a full list\" << endl; else { for (int i = length; i > location; i--) list[i] = list[i - 1]; //move the elements down list[location] = insertItem; //insert the item at the specified position length++; //increment the length } } //end insertAt void unorderedArrayListType::insertEnd(int insertItem) { if (length >= maxSize) //the list is full cout << \"Cannot insert in a full list.\.

(Unordered Sets) As explained in this chapter, a set is a collection.pdf

ssuserc77a341

// Table.java: Huffman code frequency table import java.io.*; import java.util.TreeSet class Table { public final int MAXT = 100; // maximum number of different symbols public int currTableSize; // current size as table is constructed public Entry[] tab; // the table array, not allocated private Reader in; // internal file name for input stream String file = ""; // the whole input file as a String private boolean fileOpen = false; // is the file open yet? private String fileName; // name of input file, if present private int totalChars = 0; // total number of chars read char markerChar = '@'; // sentinal at end of file // Table: constructor, input parameter: input file name or null public Table(String f) { fileName = f; currTableSize = 0; tab = new Entry[MAXT]; } // dumpTable: debug dump of contents of Table public void dumpTable() { int i; System.out.println("\nDump of Table ----->"); System.out.println(" Size: " + currTableSize); for (i = 0; i < currTableSize; i++) { System.out.println("Entry " + i + ". Symbol: " + tab[i].symb + ", Weight: " + tab[i].weight + ", Representation: " + tab[i].rep); } System.out.println("----> End Dump of Table\n"); } // getNextChar: fetches next char. Also opens input file private char getNextChar() { char ch = ' '; // = ' ' to keep compiler happy if (!fileOpen) { fileOpen = true; if (fileName == null) in = new InputStreamReader(System.in); else { try { in = new FileReader(fileName); } catch (IOException e) { System.out.println("Exception opening " + fileName); } } } try { ch = (char)in.read(); } catch (IOException e) { System.out.println("Exception reading character"); } return ch; } // buildFromFile: read file and build the map of the character frequencies private void buildFromFile(File file) throws FileNotFoundException { // Map<String, Integer> freqMap = new BSTMap<String, Integer>();Scanner scanner = new Scanner(file); scanner.useDelimiter(""); String character; while (scanner.hasNext()){ character = scanner.next(); Integer count = freqMap.get(character); if (count == null){ count = Integer.valueOf(0); } freqMap.put(character, count+1); } // for each key, make a tree and load it into the priority queue PriorityQueue<BinaryTree<CountPair>> treeQueue = new PriorityQueue<BinaryTree<CountPair>>(freqMap.keySet().size(), new CountPairTreeComparator BinaryTree<CountPair> tmpTree; for (String key: freqMap.keySet()){ int frequency = freqMap.get(key); tmpTree = new BinaryTree<CountPair>(null, new CountPair(key, frequency), null); treeQueue.add(tmpTree); } Public interface Map<K extends Comparable<K>,V> { //This should load the value value into the map at the location //associated with the key, ...

Table.java Huffman code frequency tableimport java.io.;im.docx

MARRY7

FOR MORE CLASSES VISIT www.tutorialoutlet.com Below is a given ArrayList class and Main class in search algorithms. Please modify the existing program so it can time the sequential search and the binary search methods several times each for randomly generated values, and record the results in a table. Do not time individual searches, but groups of them. For example, time 100 searches together or 1,000 searches together. Compare the running times of these two search methods that are obtained during the experiment.

Below is a given ArrayList class and Main class Your Dreams Our Mission/tuto...

davidwarner122

Javathis is my current code i need help to implement public void s.pdf

eyelineoptics

Write a java class \"LIST\" that outputs: //main: public class AssignmentThree { public static void main(String[] args) { List myList = new List(15); // Cause List Empty Message myList.removeFront(); myList.removeRear(); myList.removeItem(\"a\"); // Cause Not found message myList.addToFront(\"x\"); myList.removeItem(\"y\"); myList.removeItem(\"x\"); myList.addAfterItem(\"x\", \"z\"); myList.addBeforeItem(\"x\", \"z\"); // Normal behavior myList.addToFront(\"not.\"); myList.addToFront(\"or\"); myList.addToRear(\"is\"); myList.addToRear(\"try.\"); myList.addAfterItem(\"is\", \"no\"); myList.addBeforeItem(\"is\", \"There\"); myList.addToFront(\"Do\"); myList.addAfterItem(\"or\", \"do\"); myList.print(\"Original list\"); myList.printSorted(\"Sorted Original List\"); sop(\"\ Front is \" + myList.getFront()); sop(\"Rear is \" + myList.getRear()); sop(\"Count is \" + myList.askCount()); sop(\"Is There present? \" + myList.isPresent(\"There\")); sop(\"Is Dog present? \" + myList.isPresent(\"Dog\")); myList.addToFront(\"junk\"); myList.addToRear(\"morejunk\"); myList.addAfterItem(\"or\", \"moremorejunk\"); myList.print(\"List with junk\"); sop(\"Count is \" + myList.askCount()); myList.removeFront(); myList.removeRear(); myList.removeItem(\"moremorejunk\"); myList.print(\"List with junk removed\"); sop(\"Count is \" + myList.askCount()); sop(\"\"); // Cause List Full message for(int ii = 0; ii < 10; ++ii) { myList.addToFront(DUMMY); } myList.addToRear(DUMMY); myList.addBeforeItem(\"no\", DUMMY); myList.addAfterItem(\"There\", DUMMY); myList.print(\"After filling List\"); sop(\"Count is \" + myList.askCount()); while(myList.isPresent(DUMMY)) myList.removeItem(DUMMY); myList.print(\"After removing \" + DUMMY ); sop(\"Count is \" + myList.askCount()); } private static void sop(String s) { System.out.println(s); } private static final String DUMMY = \"dummy\"; } //Class List: public class List { public List(int size) { } public void addToFront(java.lang.String item) { } public void addToRear(java.lang.String item) { } public void addBeforeItem(java.lang.String beforeItem, java.lang.String item) { } public void addAfterItem(java.lang.String afterItem, java.lang.String item) { } public java.lang.String getFront() { } public java.lang.String getRear() { } public boolean isPresent(java.lang.String item) { } public int askCount() { } public void removeFront() { } public void removeRear() { } public void removeItem(java.lang.String item) { } public void print(java.lang.String title) { } public void printSorted(java.lang.String title) { } } Solution The List is the base interface for all list types, and the ArrayList and LinkedList classes are two common List’s implementations. Besides ArrayList and LinkedList, Vector class is a legacy collection and later was retrofitted to implement the Listinterface. Vector is thread-safe, but ArrayList and LinkedList are not. The following class diagram depicts the inheritance tree of the List collections. It’s a good practi.

Write a java class LIST that outputsmainpublic class Ass.pdf

ebrahimbadushata00

In inline heapsort we use only single array throughout the program to decrease the running time, where as, in simple heap sort we use external data structure memory usage of more than O(1) at a time. Please consider the below inline heap program which prints out the running time, which is lesser to the the simple heap sort. //program class heapsort { private final int array[]; // The array being sorted heapsort(int array[], int N) { this.array = array; int Last = N-1; // its children are at elements 2*I+1 and 2*I+2. // phase 1: form heap // Construct heap bottom-up, starting with small trees just above leaves // and coalescing into larger trees near the root. for( int Top = Last/2; Top >= 0; Top-- ) { adjust(Top, Last); } // phase 2: use heap to sort // Move top element (largest) out of heap, swapping with last element // and changing the heap boundary, until only one element remains. while( Last > 0 ) { swap(0, Last); adjust(0, --Last); } } /** * adjust(Top, Last) adjusts the tree between Top and Last **/ void adjust(int Top, int Last) { int TopVal = array[Top]; // Set aside top of heap int Parent, Child; for( Parent = Top; ; Parent = Child ) // Iterate down through tree { Child = 2*Parent+1; // Child means left child if( Child > Last ) break; // Left child non-existent if( Child+1 <= Last // Right child exists && array[Child] < array[Child+1] ) // and right child is larger Child++; // Child is the larger child if( TopVal >= array[Child] ) break; // Location for TopVal found array[Parent] = array[Child]; // Move larger child up in tree } array[Parent] = TopVal; // Install TopVal in place } //swapping void swap(int i, int j) { int temp = array[i]; array[i] = array[j]; array[j] = temp; } public static void main(String[] args) { int N = 0; // number of elements in array int array[] = {43,65,12,89,11,5,1,88,123,999,233,18,553,332,144,98,452,7663,111,23,654,8735,998}; //initialising array N=array.length; System.err.println(\"Sorting started\"); long startTime = System.nanoTime(); new heapsort(array, N); // sorting long endTime = System.nanoTime(); long totalTime = endTime - startTime; for( int i = 0; i < N; i++ ) { System.out.print(array[i] + \" \"); } System.out.println(); System.out.println(\"Time in nanos\"+totalTime); } } //runn the above program for inline heap sort. Solution In inline heapsort we use only single array throughout the program to decrease the running time, where as, in simple heap sort we use external data structure memory usage of more than O(1) at a time. Please consider the below inline heap program which prints out the running time, which is lesser to the the simple heap sort. //program class heapsort { private final int array[]; // The array being sorted heapsort(int array[], int N) { this.array = array; int Last = N-1; // its children are at elements 2*I+1 and 2*I+2. // phase 1: form heap // Construct heap bottom-up, starting with small trees just above leaves // and coalescing into larger trees near the root. for( int T.

In inline heapsort we use only single array throughout the program t.pdf

anuragperipheral

#ifndef MYLIST_H_ #define MYLIST_H_#includeiostream #include.docx

ajoy21

When we first examined the array based and node based implementations.docx

ajoy21

Array list

vishal choudhary

Implement a function called getElements() that takes in two lists. T.pdf

arracollection

I need to implement in c++ this non-List member function: void printList(List& theList, bool forward) is a non-member function that prints a list either forwards (by default -- from head to tail) when forward is true, or backwards (from tail to head) when forward is false. You must use your ListItr class to implement this function. I attached my ListItr class I\'m not sure how to implement this method help. This is one of the classes needed to implement a doubly linked list Solution #ifndef LISTITR_H #define LISTITR_H #include #include \"stdafx.h\" // This is the content of the .h file, which is where the declarations go class ListNode{ public: ListNode* previous; int value; ListNode* next; ListNode(); }; class ListItr { public: ListNode* current; ListItr(ListNode* theNode); void Insert(int value) const; bool isPastEnd() const; bool isPastBeginning() const; void moveForward() ; void moveBackward() ; int retrieve() const; }; // This is the end of the header guard #endif // stdafx.h : include file for standard system include files, // or project specific include files that are used frequently, but // are changed infrequently // #pragma once #include \"targetver.h\" #include #include #include #include \"ListItr.h\" // TODO: reference additional headers your program requires here #include \"stdafx.h\" /* for this first you need a class named ListNode */ using namespace std; ListNode::ListNode() { previous=NULL; next=NULL; } ListItr:: ListItr(ListNode* theNode){ current = theNode; } bool ListItr:: isPastEnd() const{ if (current->next==NULL) return true; else return false; } bool ListItr:: isPastBeginning() const{ if (current->previous==NULL) return true; else return false; } void ListItr:: moveForward(){ if (!isPastEnd()) current=current->next; //cout << current; } void ListItr:: moveBackward(){ if (!isPastBeginning()) current=current->previous; //cout << current; } int ListItr:: retrieve() const{ return current->value; } void ListItr::Insert(int value) const{ ListNode* theNode; theNode->value=value; while(!isPastEnd()) { moveForward(); }//loop ends when current-> next is null current->next = theNode;//inserts value at the end of the list theNode->previous=current;//defines previous pointer theNode->next=NULL;//defines next pointer } //Startnode is the first node of the list void printList(ListNode* Startnode, bool forward){ // if(forward==true){ // moveForward(); // } // if(forward == false){ // moveBackward(); // } //object of class ListItr ListItr list(Startnode); if(forward==true) { while(!list.isPastEnd()) { cout<.

I need to implement in c++ this non-List member function void print.pdf

FORTUNE2505

USING JAVA: There are at least two types of \"nearly sorted\" arrays: k-exchanges and k-distance, where k is an integer. An array is called a k-exchanges array if the array becomes sorted by performing at most k exchanges. For example, sorting.java uses 100-exchanges for nearly sorted arrays. An array is called a k-distance array if, for each element, the distance from its initial position to its position in the sorted array is no more than k. A k-distance array can be created from a sorted array by randomly shuffling each subarray of size k. www.sorting-algorithms.com uses 1-distance for nearly sorted arrays.compare the performances of quicksort (choosing the best quicksort you have), heapsort, mergesort, natural mergesort, and insertion sort on k-exchanges and k-distances arrays for various k values. Create a method called task4, which takes k = 10, 20, 30, ..., until quicksort becomes a clear winner, create 100 k-distance arrays of size 10,000,000, run in turn the chosen sorting methods on each array, and collect running times. Then for k = 100, 200, 300, ..., until quicksort becomes a clear winner, create 100 k-exchange arrays of size 10,000,000, run in turn the chosen sorting methods on each array, and collect running times. I have the code for all the algorithms done correctly, so just call them by quicksort(), heapsort(), mergesort(), naturalmergesort(), insertionsort(). I can figure out how to deal with differing sizes but what I don\'t understand is how to create k-distance and k-exchanges nearly sorted arrays. Solution void insertionSort(int A[], int size) { int i, key, j; for (i = 1; i < size; i++) { key = A[i]; j = i-1; /* Move elements of A[0..i-1], that are greater than key, to one position ahead of their current position. This loop will run at most k times */ while (j >= 0 && A[j] > key) { A[j+1] = A[j]; j = j-1; } A[j+1] = key; } } he inner loop will run at most k times. To move every element to its correct place, at most k elements need to be moved. So overall complexity will be O(nk) We can sort such arrays more efficiently with the help of Heap data structure. Following is the detailed process that uses Heap. 1) Create a Min Heap of size k+1 with first k+1 elements. This will take O(k) time (See this GFact) 2) One by one remove min element from heap, put it in result array, and add a new element to heap from remaining elements. Removing an element and adding a new element to min heap will take Logk time. So overall complexity will be O(k) + O((n-k)*logK) #include using namespace std; // Prototype of a utility function to swap two integers void swap(int *x, int *y); // A class for Min Heap class MinHeap { int *harr; // pointer to array of elements in heap int heap_size; // size of min heap public: // Constructor MinHeap(int a[], int size); // to heapify a subtree with root at given index void MinHeapify(int ); // to get index of left child of node at index i int left(int i) { return (2*i + 1); } // to get index of right chil.

USING JAVAThere are at least two types of nearly sorted array.pdf

lohithkart

Swift 3.0 で変わったところから、興味の湧いた 13 項目を、自分が開催する "カジュアル Swift 勉強会" の紹介も兼ねつつ、Swift 愛好会で発表してきました。少し前に iPhone Dev Sapporo 勉強会で話した内容から、項目数は減らしつつも、新たな項目を紹介したり、紹介済みの項目についても内容を少し膨らませたりしています。

Swift 3.0 で変わったところ - 厳選 13 項目 #love_swift #cswift

Tomohiro Kumagai

JAVA help Need bolded lines fixed for it to compile. Thank you! public class PersonSort { // Test file. Format is \"STRING int int int\" static final String PERSON_FILE = \".\\\\src\\\\Persons.txt\"; public static void main(String[] args) throws FileNotFoundException { // Create new ArrayList and populate from test file ArrayList list1 = new ArrayList(); populate(list1); // Create new array with same people ArrayList list2 = new ArrayList(list1); insertionSort(list1); // Print result of sort System.out.println(\"INSERTION SORT\"); // *** foreach Person p in list1 { System.out.println(p.toString()); } selectionSort(list2); System.out.println(); System.out.println(\"SELECTION SORT\"); // *** foreach Person p in list2 { System.out.println(p.toString()); } } /* * populate - this method reads the Persons.txt file and creates an array list * */ public static ArrayList populate(ArrayList list) throws IOException { // Scan in the file File people = new File(PERSON_FILE); Scanner ppl = new Scanner(people); // While we have a next line, create a new Person and add it to the list while (ppl.hasNextLine()) { String name = ppl.next(); int month = ppl.nextInt(); int day = ppl.nextInt(); int year = ppl.nextInt(); list.add(new Person(name, month, day, year)); } ppl.close(); return list; } /** * * Sorts an ArrayList based on the insertion sort algorithm. Modified code based * on insertion sort from Sort.java in Lesson3SourceCode. * */ // *** change double[] to ArrayList public static void insertionSort (double[] list) { // Temporary variable for the next item to be inserted // *** change double to Person double valueToInsert; int insertPos = 0; // Iterate through the array taking each array element in turn // as the next one to be inserted in its correct position. // This element is placed in its correct position in the array of // previously sorted elements contained in the lower array indices. for (int i = 1; i < list.size(); i++) { // Hold the next element to be inserted, // until we find the correct spot valueToInsert = list.get(i); insertPos = i; // Find the correct place to insert this element // in the lower array indices of already sorted elements while ((insertPos > 0) && (list.get(insertPos - 1).compareTo(valueToInsert) > 0)) { // Move elements up the array // and insert position down list.set(insertPos, list.get(insertPos - 1)); insertPos--; } // We are at the correct position, so insert the element list.set(insertPos, valueToInsert); } } /** * * Sorts an ArrayList based on the selection sort algorithm. Modified code based * on selection sort from Sort.java in Lesson3SourceCode. * */ // *** change double[] to ArrayList public static void selectionSort (double[] list) { for (int i = 0; i < list.size(); i++) { // Find the minimum in the ArrayList through [i..list.length-1] // *** change double to Person double currentMin = list[i]; int currentMinIndex = i; for (int j = i + 1; j < myList.size(); j++) { if (currentMin.compareTo(list.get(j)) > 0) { curr.

JAVA helpNeed bolded lines fixed for it to compile. Thank you!pu.pdf

suresh640714

This class maintains a list of 4 integers. This list .docx

Komlin1

week-19x

KITE www.kitecolleges.com

Similar to In Java code, implement the HeapSort algorithm. Your function must t.pdf (20)