The following is a pseudocode representation of an algorithm that takes an array of integers and sorts them in ascending order. What is the order of this algorithm in the worst case?  Explain your answer in detail.  What is the order of the algorithm if anArray is already sorted? Justify your answer.   +sort (in anArray[]: integer) n: integer = length of anArray      temp: integer = 0;      for (i: integer = 0; i < n - 1; i++) {            for (j: integer = 0; j < n – i - 1; j++) {                   if (anArray[j] > anArray[j + 1]) {                        temp = anArray[j]                        anArray[j] = anArray[j + 1]                        anArray[j + 1] = temp              }          }      }

Consider the following algorithm, which may be called on an array that is not necessarily sorted. and returns the array in sorted form. GoofySort (A) : if (len (A) <= 3): SelectionSort(A) else: [len(A)/3] + GoofySort (A[1:2t]) GoofySort (A[t+1:n]) //sort the back 2/3rds + GoofySort (A[1:2t]) Let t + A[1:2t] //sort the front 2/3rds A[t+1:n] A[1:2t] //sort the front 2/3rds (a) Write a recurrence which captures the runtime of this algorithm. Your recurrence should be of the form T (n) =?. You can ignore any non-recursive operations (i.e. you only need to focus on operations in the last three lines). You do not need to handle base cases here. You can assumen is divisible by 3 for convenience. (b) Solve your recurrence using the substitution method. Show your work. You may assume a base case of T (1) = 1. State what the big-0 runtime is for this algorithm (hint: it should be a polynomial written in the form nº).

Quick sort the list L = {A, B, N, M, P, R}. What are your observations? How canthe observations help you in determining the worst-case complexity of quick sort?

Write a Java program to sort an array of given integers using Stooge Sort non-negative Algorithm.

One disadvantage of using a For-loop in sorting algorithms is that the body of theFor-loop is repeatedly executed even if it is no longer necessary. One example isBubble Sort:Input: Array A[1 . . . n]Output: Array A sortedfor i ←1 to (n −1) dofor j ←1 to (n −i) doif A[j] > A[j + 1] thenA[j] ↔A[j + 1]return AIn the array [2, 1, 3, 7, 9] we know that when 2 and 1 are interchanged, early on in theexecution of the algorithm, the array is now sorted, and all subsequent iterations ofthe outer loop are unnecessary.  *Write a version of Bubble Sort that avoids unnecessary comparisons*

Given an integer array nums sorted in non-decreasing order, return an array of the squares of each number sorted in non-decreasing order. Example 1: Input: nums = [-4,-1,0,3,10] Output: [0,1,9,16,100] Explanation: After squaring, the array becomes [16,1,0,9,100]. After sorting, it becomes [0,1,9,16,100]. Example 2: Input: nums = [-7, -3,2,3,11] Output: [4.9,9,49,121]

Please help me solve this problem

Bubble Sort is a popular, but inefficient sorting algorithm. It works by repeatedly swapping adjacent elements that are out of order. Prove the correctness of following Bubble Sort algorithm based on Loop Invariant. Clearly state your loop invariant during your proof.

Shell sort is an in-place comparison-based sorting algorithm which is based on insertion sort algorithm. It works as follow : It breaks the original list into a number of smaller sublists, each of which is sorted using an insertion sort. The unique way that these sublists are chosen is the key to the shell sort. Instead of breaking the list into sublists of contiguous items, the shell sort uses an increment i, sometimes called the gap, to create a sublist by choosing all items that are i items apart. n a) We say that the our initial gap is floor: when we divide our sequence into 2k n sublists where 2k k>0 be the number of passes that can be increment until the denominator not greater than n, n and then sorting the elements which are position away with insertion sort. We have three 2k passes for an array size of 8 to 15. Demonstrate the Shell algorithm on the input array A = [35,33,42,10,14,19,27,44] showing how even- %3D п tually the algorithm outputs the sorted array…

Quicksort is a powerful divide-and-conquer sorting algorithm that almost always runs in O(nlogn) time,though it can run in O(n^2) time for certain input arrays, depending on how we choose the pivot. For this question assume that the pivot isalwaysthe last (right-most) element of the input array.There are two main ways that we can code the PARTITION procedure: the Lomuto method and the Hoare method. Question: Clearly explain how the two partition methods work – the Lomuto method and the Hoare method, and how they are different. Finally apply both methods to partition the arrayA= [2, 8, 7, 1, 3, 5, 6, 4], using the pivot A[8] = 4.