Question

Consider the following loop nest:

int sum = 0;
for(int j = 0; j < N * N; j += 2)
   for(int i = 2*N; i > 0; i--)
      sum++;

What is the Big-O behavior?

Group of answer choices

O(1)

O(log N)

O(N)

O(N log N)

O(N²)

O(N³)

2.Consider the following loop nest:

int sum = 0;
for(int j = 1; j < N; j *= 2)
   for(int i = 0; i < N; i += 2)
      sum++;

What is the Big-O behavior?

Group of answer choices

O(1)

O(log N)

O(N)

O(N log N)

O(N²)

O(N³)

3.Consider the following loop nest:

int sum = 0;
for(int j = 0; j < N; j++)
   for(int i = 2*N; i > 0; i--)
      sum++;

What is the Big-O behavior?

Group of answer choices

O(1)

O(log N)

O(N)

O(N log N)

O(N²)

O(N³)

4.Which of the following step commands in Eclipse's debugger causes the code inside a method that is called to be skipped when examining the execution of a program?

Group of answer choices

step into

step over

step return

Fill in the blank: SimplePriorityQueue ___________ PriorityQueue.

Group of answer choices

is a

has a

is not related to

What should the Big-O behavior of the findMin method be?

public E findMin() throws NoSuchElementException;

/**
   * Retrieves, but does not remove, the minimum element in this priority
   * queue.
   *
   * @return the minimum element
   * @throws NoSuchElementException if the priority queue is empty
   */

Group of answer choices

O(1)

O(log N)

O(N)

O(N log N)

O(N²)

O(N³)

What should the Big-O behavior of the deleteMin method be?

public E deleteMin() throws NoSuchElementException;

/**
   * Retrieves and removes the minimum element in this priority queue.
   *
   * @return the minimum element
   * @throws NoSuchElementException if the priority queue is empty
   */

Group of answer choices

O(1)

O(log N)

O(N)

O(N log N)

O(N²)

O(N³)

Flag this Question

Recall that the insert method must maintain the descending, sorted order of the priority queue's backing array. Therefore, the method must first search for the correct location in which to place the new item, using a binary search. Then, the method must shift all array items at and beyond this location in order to make space for the new item.

What should the Big-O behavior of the binary search part of the insert method be?

   public void insert(E item);

   /**
   * Inserts the specified element into this priority queue.
   *
   * @param item - the element to insert
   */

Group of answer choices

O(1)

O(log N)

O(N)

O(N log N)

O(N²)

O(N³)

What should the Big-O behavior of the array element shifting part of the insert method be?

Group of answer choices

O(1)

O(log N)

O(N)

O(N log N)

O(N²)

O(N³)

Flag this Question

Question 101 pts

Combining the binary search and array shifting parts appropriately, what should the Big-O behavior of the entire insert method be?

Group of answer choices

O(1)

O(log N)

O(N)

O(N log N)

O(N²)

O(N³)

Answer 1

Ans: Answering first 4, if you need all the answers, post them in a set of 4

1) Let's find the complexity step by step

int sum = 0;

This loop has O(N²) as it goes from 0 to N*N and in each iteration j increases by 2 compared to its previous value

for(int j = 0; j < N * N; j += 2)     

 This is nested inside previous and has O(N), 2*N to 0 as in each iteration i decreases by 1
   for(int i = 2*N; i > 0; i--)    
      sum++;

Now the first loop is O(N²) and there is another nested loop with O(N),

So, overall Time Complexity = O(N²*N) = O(N³)

2) Let's go step by step

int sum = 0;
This loop has O(log2N) Complexity, as in each iteration j becomes 2 times of it's previous value
for(int j = 1; j < N; j *= 2) 

This loop is nested and has O(N) Complexity, as in each iteration i increases by 2 of it's previous value
   for(int i = 0; i < N; i += 2)
      sum++;

So, Overall Complexity = O(N*Log₂(N) )

3) Step-By-Step

int sum = 0;
This loop has O(N) Complexity, as in each iteration j increases by 1 of it's previous value
for(int j = 0; j < N; j++)

This is nested inside previous and has O(N), 2*N to 0 as in each iteration i decreases by 1
   for(int i = 2*N; i > 0; i--)
      sum++;

So, Overall Complexity = O(N²)

4) step into - It enters to the particular method and executes it

step over - It avoids the next method call and doesn't run any code inside it.

step return - It stops the execution wherever it's being called inside a method.

So, answer is step-return