Step 1You need to run the JAVA programs in sections 3.3 and 3.5 for.pdf

•

0 likes•2 views

Step 1:You need to run the JAVA programs in sections 3.3 and 3.5 for selection sort and insertion sort. You need to attach the output results. Step 2: You need to modify these two programs, save them, submit them, and add some comments and explanations to them to sort the list elements from high to low value. The index should be IndexHighest instead IndexSmallest. Step3: Run the modified programs and print out the results and submit them. In the end, you need the running results for original JAVA programs (selection and insertion sort JAVA programs), the two modified programs to sort the values from high to low value for selection and insertion sorts, and the results for the modified programs. This program uses the selection sort algorithm to sort an array. The code has been modified to also calculate how many item comparisons are done. You can try running the program with different arrays to see how the total number of comparisons changes (or doesn't change). CODE 3.3 --- import java.util.Arrays; public class SelectionSortDemo { private static int selectionSort(int[] numbers) { // A variable to hold the number of item comparisons int comparisons = 0; for (int i = 0; i < numbers.length - 1; i++) { // Find index of smallest remaining element int indexSmallest = i; for (int j = i + 1; j < numbers.length; j++) { comparisons++; if (numbers[j] < numbers[indexSmallest]) { indexSmallest = j; } } // Swap numbers[i] and numbers[indexSmallest] int temp = numbers[i]; numbers[i] = numbers[indexSmallest]; numbers[indexSmallest] = temp; } return comparisons; } public static void main(String[] args) { // Create an array of numbers to sort int[] numbers = { 10, 2, 78, 4, 45, 32, 7, 11 }; // Display the contents of the array System.out.println("UNSORTED: " + Arrays.toString(numbers)); // Call the selectionSort method int comparisons = selectionSort(numbers); // Display the sorted contents of the array System.out.println("SORTED: " + Arrays.toString(numbers)); System.out.println("Total comparisons: " + comparisons); } } CODE 3.5 --- import java.util.Arrays; public class InsertionSortDemo { private static void insertionSort(int[] numbers) { for (int i = 1; i < numbers.length; i++) { int j = i; while (j > 0 && numbers[j] < numbers[j - 1]) { // Swap numbers[j] and numbers [j - 1] int temp = numbers[j]; numbers[j] = numbers[j - 1]; numbers[j - 1] = temp; j--; } } } public static void main(String[] args) { // Create an array of numbers to sort int[] numbers = { 10, 2, 78, 4, 45, 32, 7, 11 }; // Display the contents of the array System.out.println("UNSORTED: " + Arrays.toString(numbers)); // Call the insertionSort method insertionSort(numbers); // Display the sorted contents of the array System.out.println("SORTED: " + Arrays.toString(numbers)); } }.

Education

}
public static void main(String[] args) {
// Create an array of numbers to sort
int[] numbers = { 10, 2, 78, 4, 45, 32, 7, 11 };
// Display the contents of the array
System.out.println("UNSORTED: " + Arrays.toString(numbers));
// Call the selectionSort method
int comparisons = selectionSort(numbers);
// Display the sorted contents of the array
System.out.println("SORTED: " + Arrays.toString(numbers));
System.out.println("Total comparisons: " + comparisons);
}
}
CODE 3.5 ---
import java.util.Arrays;
public class InsertionSortDemo {
private static void insertionSort(int[] numbers) {
for (int i = 1; i < numbers.length; i++) {
int j = i;
while (j > 0 && numbers[j] < numbers[j - 1]) {
// Swap numbers[j] and numbers [j - 1]
int temp = numbers[j];
numbers[j] = numbers[j - 1];
numbers[j - 1] = temp;
j--;
}
}
}
public static void main(String[] args) {
// Create an array of numbers to sort
int[] numbers = { 10, 2, 78, 4, 45, 32, 7, 11 };

// Display the contents of the array
System.out.println("UNSORTED: " + Arrays.toString(numbers));
// Call the insertionSort method
insertionSort(numbers);
// Display the sorted contents of the array
System.out.println("SORTED: " + Arrays.toString(numbers));
}
}

1) Arrays allow storing and accessing multiple values of the same data type. They are declared with the data type, followed by square brackets and the array name. 2) Array components are accessed using their index number within square brackets after the array name. Index numbers start at 0. 3) The length property returns the number of components in the array, which must be considered to avoid accessing components outside the bounds of the array.

Create a menu-driven program that will accept a collection of non-ne.pdf

rajeshjangid1865

Create a menu-driven program that will accept a collection of non-negative integers from the keyboard, calculate the mean and median values and display those values on the screen. Your menu should have 6 options: 1. Add a number to the array 2. Display the mean 3. Display the median 4. Print the array to the screen 5. Print the array in reverse order 6. Quit Program particulars: Use an array of type int to store the integers entered by the user. There must be error checking on the input integer. If it is negative, the program will print an error message and re-prompt. This process will continue until a non-negative integer is entered. You must use a try-catch structure to trap both types of input errors (like letters where numbers should go) and range errors (like -1). You must write your own selectionSort utility method to sort your array. Place the method in an external file named SortSearchUtil.java. There must be error checking on the menu choice entered. If the user enters a choice not on the menu, the program will print an error message, re-display the menu and re-prompt. This process will continue until a valid option value is entered. Your solution must be modular. The design of your methods is up to you, but the rules of “highly cohesive” and “loosely coupled” must be followed. Your program should be well-documented. Explain what you’re doing in your code. Be sure to include the usual name and assignment notes. Note your program will have to sort your array before you can find the median. Include your SortSearchUtil.java file which will contain your sort method. This is what my project looks like already: Please fix it thanks. The SortSearchUtil will also be included. import java.util.Scanner; public class ArraySorting { public static void main(String[] args) { int option; int integer = 0; int optionOne; int optionTwo; int optionThree; int optionFour; int optionFive; int[] numbers = new int[5]; Scanner kb = new Scanner(System.in); System.out.println(\"Please enter a non-negative integer: \"); integer = kb.nextInt(); while((integer < 0)) { System.out.println(\"I am sorry that is not a non-negative integer.\"); System.out.println(\"\"); System.out.println(\"Please enter a non-negative integer: \"); integer = kb.nextInt(); } option = displayMenu(kb); while (option != 6) { switch (option) { case 1: optionOne(numbers); System.out.println(\"\"); break; case 2: optionTwo(numbers); System.out.println(\"\"); case 3: //optionThree(); System.out.println(\"\"); break; case 4: //optionFour(); System.out.println(\"\"); break; case 5: //optionFive(); System.out.println(\"\"); break; } option = displayMenu(kb); } if (option == 6) { System.out.println(); System.out.println(\"Thank you. Have a nice day.\"); } } private static int displayMenu(Scanner kb) { int option = 0; while (option != 1 && option != 2 && option != 3 && option != 4 && option !=5 && option !=6) { System.out.println(\"\\t\\t1. Add a number to the array\ \\t\\t2. Display the mean\ \\t\.

Computer programming 2 Lesson 13

MLG College of Learning, Inc

Arrays allow storing multiple values of the same type in a single variable. An array is declared by specifying the data type, followed by square brackets containing the array name. Individual elements in the array are accessed using their index number within square brackets after the array name. The Arrays class contains methods for sorting, searching, comparing, and filling arrays that are overloaded for all primitive data types.

Ch08

Arriz San Juan

This document discusses one-dimensional and two-dimensional arrays in C. It covers array initialization, passing arrays to functions, and common errors. Key topics include declaring and initializing one-dimensional arrays, accessing array elements using indexes, initializing two-dimensional arrays in row-major order, and calculating the memory location of elements in two-dimensional arrays based on row and column indexes. Examples are provided to demonstrate computing averages and standard deviations of arrays.

Getting StartedCreate a class called Lab8. Use the same setup for .pdf

info309708

Getting Started Create a class called Lab8. Use the same setup for setting up your class and main method as you did for the previous assignments. Be sure to name your file Lab8.java. Additionally, make another file called Arrays.java. This file will be an object, so simply start it off by declaring an Arrays class. You can copy the following skeleton and fill in the appropriate code below each of the comments: public class Arrays { / Instance Variables // Constructors // findMin 1 // findMax // calcSum // calcAverage // toString } Task Overview Your task for this lab is to create a class called Arrays with some array processing methods. This class will maintain an array and the number of elements present in it. Additionally, methods will be available to display the current min and max elements along with the average of all of them. Finally, a toString() method will be available to cleanly display all the array elements. Finally, you will write a simple driver class to test out the above Arrays class. Part 1: Instance Variables for Arrays The first thing to do for the Arrays class is to set up its instance variables. Declare the following (private) instance variables: • An int array called array ? this will be the array we will be writing methods for. • An int called count - this represents the number of valid elements in the array. Part 2: Constructors for Arrays The Arrays class will have two constructors. The first constructor takes the maximum size of the array as input as a parameter and initializes the array instance variable appropriately. It also sets count to size. Finally, it will initialize all of the array elements to some values between 0 and 10, inclusive. To create this constructor, follow these steps: • Import java.util.Random to make use of the random number generator. • Create a constructor with the following header: public Arrays(int size) • Initialize your array variable and set its size to size (see the chart on page 252 for reference on initializing arrays). Be very careful that you are setting the value of your array instance variable, as opposed to creating a new variable called array. • Set the value of the count variable to size because we will be populating the entire array. • Copy the following code to the constructor in order to generate random values between 0 and 10, inclusive: Random rand = new Random(); for (int i = 0; i < count; i++) { array[i] = (rand.nextInt(10)); } Next, create another constructor with the following header: public Arrays(int[] arr). This constructor will initialize the class by using the passed arr argument in order to fill its instance variables. The following things need to be done inside of this constructor: • Set the array variable equal to arr. • Set the count variable equal to the length of the array. Part 3: Displaying the Output findMin() The first method of this class will search the array for the minimum element. Copy the following code for the findMin method. Note how the count i.

Generics Collections

phanleson

The document discusses generics in .NET and how they provide type safety and code reuse. It explains that generics allow defining methods and classes that can work with different data types. This is done by specifying type parameters that act as placeholders for the actual types. Some key generic concepts covered include generic methods, classes, interfaces, and common collection classes like List, Stack, Queue and how they allow storing and manipulating different types of data.

CP PPT_Unit IV computer programming in c.pdf

saneshgamerz

Generics collections

Yaswanth Babu Gummadivelli

This document discusses generics and collections in .NET. It introduces generics as a way to write reusable code for different data types. Generic methods and classes are covered, allowing a single definition to work with multiple types. The document also discusses collection classes like ArrayList, HashTable, Stack and Queue, which provide common data structures. It notes the benefits of generic collections over non-generic ones in terms of type safety and efficiency.

This document provides an introduction and overview of arrays in C++. It defines what an array is, how to declare and initialize arrays, and how to access, insert, search, sort, and merge array elements. Key points covered include: - An array is a sequenced collection of elements of the same data type. Elements are referenced using a subscript index. - Arrays can be declared with a fixed or variable length. Elements are initialized sequentially in memory. - Common array operations like accessing, inserting, searching, sorting and merging are demonstrated using for loops and examples. Searching techniques include sequential and binary search. Sorting techniques include selection, bubble and insertion sort. - Arrays are passed

07+08slide.pptx

MURADSANJOUM

The document discusses arrays in Java. It begins by defining an array as a data structure that holds a collection of the same type of data. It then covers topics such as declaring and creating arrays, accessing array elements using indexes, default values, passing arrays to methods, returning arrays from methods, and two-dimensional arrays. Examples are provided throughout to illustrate key concepts related to working with arrays in Java programs.

Arrays and function basic c programming notes

GOKULKANNANMMECLECTC

The document discusses arrays and functions in C programming. It defines arrays as collections of similar data items stored under a common name. It describes one-dimensional and two-dimensional arrays, and how they are declared and initialized. It also discusses strings as arrays of characters. The document then defines functions as sets of instructions to perform tasks. It differentiates between user-defined and built-in functions, and describes the elements of functions including declaration, definition, and calling.

Object Oriented Programming Using C++: C++ STL Programming.pptx

RashidFaridChishti

6_Array.pptx

shafat6712

This document provides information on arrays in Java. It begins by defining an array as a collection of similar data types that can store values of a homogeneous type. Arrays must specify their size at declaration and use zero-based indexing. The document then discusses single dimensional arrays, how to declare and initialize them, and how to set and access array elements. It also covers multi-dimensional arrays, providing syntax for declaration and initialization. Examples are given for creating, initializing, accessing, and printing array elements. The document concludes with examples of searching arrays and performing operations on two-dimensional arrays like matrix addition and multiplication.

Chapter2pp

J. C.

This document discusses using variables and constants in Java, including: - Declaring and initializing different variable types like int, float, and String - Assigning values to variables and constants - Using methods like getText() and setText() to work with text fields and text areas - Adding buttons and adding listeners to buttons to detect click events - Getting the system date using the Calendar class

An Introduction to Programming in Java: Arrays

Martin Chapman

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

ajoy21

The document describes a Java program that uses an ArrayList to test a selection sort algorithm. It prompts the user to enter a number, fills the ArrayList with that many randomly generated integers from 1 to 50, prints the original ArrayList, calls a selection sort method to sort the ArrayList, and prints the sorted ArrayList. The selection sort method uses nested for loops to find the minimum element in the unsorted section and swap it with the current element being considered.

Array assignment

Ahmad Kamal

An array is a contiguous block of memory that stores elements of the same data type. Arrays allow storing and accessing related data collectively under a single name. An array is declared with a data type, name, and size. Elements are accessed via indexes that range from 0 to size-1. Common array operations include initialization, accessing elements using loops, input/output, and finding highest/lowest values. Arrays can be single-dimensional or multi-dimensional. Multi-dimensional arrays represent matrices and elements are accessed using multiple indexes. Common array applications include storing student marks, employee salaries, and matrix operations.

arrays-120712074248-phpapp01

Abdul Samee

This document discusses arrays in C#, including declaring and creating arrays, accessing array elements, input and output of arrays, iterating over arrays using for and foreach loops, dynamic arrays using List<T>, and copying arrays. It provides examples of declaring, initializing, accessing, reversing, and printing arrays. It also covers reading arrays from console input, checking for symmetry, and processing arrays using for and foreach loops. Lists are introduced as a resizable alternative to arrays. The document concludes with exercises for practicing various array techniques.

[ITP - Lecture 15] Arrays & its Types

Muhammad Hammad Waseem

Comp 122 lab 6 lab report and source code

pradesigali1

ch07-arrays.ppt

Mahyuddin8

This document provides an overview of arrays in Java, including how to declare, initialize, access, and manipulate array elements. It discusses key array concepts like indexes, the length field, and for loops for traversing arrays. Examples are provided for common array operations like initialization, accessing elements, and passing arrays as parameters or returning them from methods. Limitations of arrays are also covered.

Develop a system flowchart and then write a menu-driven C++ program .pdf

leventhalbrad49439

Develop a system flowchart and then write a menu-driven C++ program that uses user-defined functions arrays, and a random number generator. Upon program execution, the screen will be cleared and the menu shown below will appear at the top of the screen and centered. The menu items are explained below. Help Smallest Largest Quit H or h ( for Help ) option will invoke a function named help() which will display a help screen. The help screen(s) should guide the user how to interact with the program, type of data to be used, and what results would the program produce. Each help screen should remain on the monitor until the user strikes any key. Once the user completes reading the help() screens, striking any key will clear the screen and the menu is displayed again. The main() function will declare an array of 60 elements. The elements are of type double. The menu options S and L, will ask the user for the actual number of elements for the array. The program must verify that the actual number of elements does not exceed 60 and is not a negative number or 0. Your code must check for these. S or s ( for Smallest ) option will invoke a function named smallest( ) which will prompt the user for the number of elements for the array to be examined using the function sizeOfArray( ) which will read and validate the desired array elements and returns it to the calling function. The program will then use the returned size of the array to fill the array using the number generator functions shown at the end of this assignment. Your program will ask the user for the range of values for the elements of the array and uses these numbers in a random generator function to fill the array. Once the array is filled, the program will call the function findSmallest( ) which will find and return the smallest number in the array to the calling function. The program will then call the function frequency(), that will compute and return the frequency of occurrence of the smallest number. The program will then display the array elements, the smallest number, and its frequency of occurrence using the function display( ), in the format shown below. The output shown is for an array of six elements with an array identifier a. a[0] = xxxx.xx a[1] = xxxx.xx a[2] = xxxx.xx a[3] = xxxx.xx a[4] = xxxx.xx a[5] = xxxx.xx Smallest no. = xxxx.xx Frequency = xx Note that for the array elements, two digits after the decimal point is required (i.e., 365.24) and the frequence of occurrence is of type integer. The function prototypes to be used are as follows: void smallest(double s[], int size); where s is the original array declared in the main() function and size is the maximum array size specified (60 elements in our case). //gets the desired array size and returns it int sizeOfArray(void); //finds the smallest number in the array and returns it via the return statement. double findSmallest(double s[], int myS); //where s is the specified array name and myS is the desired size of the array.

Intro to C# - part 2.pptx emerging technology

worldchannel

COM1407: Arrays

Hemantha Kulathilake

16-sorting.ppt

18Gunaalanpg

object oriented programming java lectures

MSohaib24

This document provides an overview of object oriented programming topics including arrays and Java operators. It discusses single and multi-dimensional arrays, how to declare, create, initialize, and index arrays. It also covers the different types of Java operators such as assignment, arithmetic, relational, logical, and bitwise operators. Examples are provided to demonstrate how to use arrays and each type of operator in Java code.

Write a method called uniqueNumbers that takes an int array as param.pdf

fashioncollection2

Write a method called uniqueNumbers that takes an int array as parameter, and returns a different int array, which only contains the list of unique numbers in the original array. Hint: Use the isPresent method defined below to accomplish your here is the code we need to add too Solution solution package com.mt.classes; import java.util.ArrayList; import java.util.List; public class Lab8e { public static void main(String[] args) { int[] numbers = new int[20]; // Generate random numbers between 0 and 99 and fill up the array for (int i = 0; i < numbers.length; i++) { numbers[i] = (int) (Math.random() * 50); } System.out.println(\"The list is:\"); printNumbers(numbers); // Task 1 System.out.println(\"The smallest number in the list is \" + smallestNumber(numbers)); // Task 2 System.out.println(\"The largest number in the list is \" + largestNumber(numbers)); // Task 3 System.out.println(\"The average of numbers in the list is \" + averageOfNumbers(numbers)); // Task 4: Extra Credit. Uncomment the following // two lines if you complete this task. System.out.println(\"The list of unique numbers is:\"); uniqueNumbers(numbers); } private static void uniqueNumbers(int[] numbers) { for (int i = 0; i < numbers.length; i++) { boolean isDuplicate = false; for (int j = 0; j < i; j++) { if (numbers[i] == numbers[j]) { isDuplicate = true; break; } } if (!isDuplicate) { System.out.print(numbers[i] + \" \"); } } } public static void printNumbers(int[] list) { for (int i = 0; i < list.length; i++) { System.out.print(list[i] + \" \"); } System.out.println(); } // 1. Write a method called smallestNumber that // takes an int array as parameter, and returns the // smallest number public static int smallestNumber(int[] list) { int small = 100; for (int i = 0; i < list.length; i++) { if (list[i] < small) { small = list[i]; } } return small; } // 2. Write a method called largestNumber that // takes an int array as parameter, and returns the // largest number public static int largestNumber(int[] list) { int large = 0; for (int i = 0; i < list.length; i++) { if (list[i] > large) { large = list[i]; } } return large; } // 3. Write a method called averageOfNumbers that // takes an int array as parameter, and returns the // average of the numbers public static double averageOfNumbers(int[] list) { double average = 0.0; for (int i = 0; i < list.length; i++) { average = average + list[i]; } average = average / list.length; return average; } public static boolean isPresent(int[] list, int target) { boolean found = false; for (int i = 0; i < list.length && !found && list[i] != 0; i++) { if (list[i] == target) { found = true; } } return found; } } output The list is: 16 14 11 31 7 8 18 49 27 43 9 39 38 18 6 16 8 30 32 15 The smallest number in the list is 6 The largest number in the list is 49 The average of numbers in the list is 21.75 The list of unique numbers is: 16 14 11 31 7 8 18 49 27 43 9 39 38 6 30 32 15.

Java Programming

Nanthini Kempaiyan

Java arrays allow storing multiple elements of the same type in contiguous memory locations. Arrays can have one or more dimensions. Some key points about Java arrays include: - Elements are accessed via an integer index from 0 to length-1. - Arrays have a fixed size set at creation time. - Common operations include initialization, traversal, passing to methods, and returning from methods. - Exceptions like ArrayIndexOutOfBoundsException may occur if invalid indexes are used.

Starware Software was founded last year to develop software for gami.pdf

Step 1You need to run the JAVA programs in sections 3.3 and 3.5 for.pdf

Recommended

Recommended

More Related Content

Similar to Step 1You need to run the JAVA programs in sections 3.3 and 3.5 for.pdf

Similar to Step 1You need to run the JAVA programs in sections 3.3 and 3.5 for.pdf (20)

More from aloeplusint

More from aloeplusint (20)

Recently uploaded

Recently uploaded (20)

Step 1You need to run the JAVA programs in sections 3.3 and 3.5 for.pdf