create a non-recursive procedure that is able to reverse a single linked list of n elements, and also runs in O(n) time. Can the same be achieved in Ω(n) time? If so, create it.

java code will need to return the traversal of the nodes in DFS order, wherethe traversal starts from Node/Vertex 0.When you follow the traversal process as specified - the complexity of the solution will be linear as shown below.Time Complexity: O(V + E), where V is the number of Vertices andE is the number of Edges respectively.Space Complexity: O(V )The linear space complexity would come from the recursion (AKA ”recursionstack”) you employ to traverse the Graph.

Use a recursion tree to determine a good asymptotic upper bound on therecurrence T(n) = 3T(n/2) + n. Use the substitution method to prove your answer.

Apply quicksort to sort the list E, X, E, R, C, I, S, E in alphabetical order.Draw the tree of the recursive calls made.

Very confused about this problem. Any help is appercaited

Implement the remove(u) method, that removes the node u from a MeldableHeap. This method should run in O(log n) expected time. Use c++

Redesign the topsort algorithm below so that it selects the last node in each iteration rather than the first. Please use python ad show all work so I can better understand the problem. def topsort(G): count = dict((u, 0) for u in G) for u in G: # The in-degree for each node for v in G[u]: count[v] += 1 Q = [u for u in G if count[u] == 0] S = [] while Q: u = Q. pop() S.append (u) for v in G[u]: count[v] -- 1 if count[v] # Count every in-edge # Valid initial nodes # The result # While we have start nodes... # Pick one # Use it as first of the rest # "Uncount" its out-edges # New valid start nodes? 0: == Q. append (v) # Deal with them next return S

Consider the following variation on MergeSort: instead of dividing a list (say, of integers) evenly (that is, half and half or half and half plus 1) at all levels of recursion, we choose to divide a list this way - a left list that consists of exactly one integer and a right list that consists of the remaining integers. The time-complexity of this variation of MergeSort is: (a) O(n log n) (b) O(n²) (c) O(n) (d) none of the above

Use a recursion tree to determine a good asymptotic upper bound on the recurrence T(n)=4T(n/2+2)+n. Use the substitution method to verify your answer.

Use the recursion tree method to solve the following recurrence T(n) by finding the tightest function f(n) such that T(n) = O(f(n)). T(n) ≤ 4.T(n/3) +0(n³)