Sign up for FREE

Sort Search BigO Iterator M/C Test

Last updated about 2 years ago

40 questions

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

Question 1

1.

Question 2

2.

Question 3

3.

Question 4

4.

Question 5

5.

Question 6

6.

Question 7

7.

Question 8

8.

Question 9

9.

Question 10

10.

Question 11

11.

Question 12

12.

Question 13

13.

Question 14

14.

Question 15

15.

Question 16

16.

Question 17

17.

Question 18

18.

Question 19

19.

Question 20

20.

Question 21

21.

Question 22

22.

Question 23

23.

Question 24

24.

Question 25

25.

Question 26

26.

Question 27

27.

Question 28

28.

Question 29

29.

Question 30

30.

Question 31

31.

Question 32

32.

Question 33

33.

Question 34

34.

Question 35

35.

Question 36

36.

Question 37

37.

Question 38

38.

Question 39

39.

Question 40

40.

Which of the following sorts has a partition method that uses a pivot location?

bubble sort

merge sort

insertion sort

selection sort

quick sort

What is the bigO of the code below?
int n = //user input
for(int i=0; i<n; i++){
    for(int j=0; j<n; j++){
        System.out.println(i*j);
    }
}

O(N)

O(1)

O(N * log2N)

O(Log2N)

O(N*N)

What is the bigO of the code below?
int n = //user input
for(int i=0; i<n; i++){
     for(int j=1; j<n; j=j*2){
          System.out.println(i*j);
     }
}

O(N)

O(1)

O(N * log2N)

O(Log2N)

O(N*N)

What is output by the code below?
String[] s = "one two dog".split(" ");
ArrayList<String> words;
words = new ArrayList<String>(Arrays.asList(s));
String big = Collections.min(words);
out.println(big);

one

two

dog

one two dog

one two

Which of the these algorithms has a O(1) best case runtime and a O(N) worst case runtime?

Binary Search

Linear Search

Selection Sort

Insertion Sort

Quick Sort

Which of the these algorithms has a O(N) best case runtime and a O(N*N) worst case runtime?

Binary Search

Linear Search

Selection Sort

Insertion Sort

Quick Sort

Which of the these algorithms has a O(N*Log2N) best case runtime and a O(N*N) worst case runtime?

Binary Search

Linear Search

Selection Sort

Insertion Sort

Quick Sort

Which of the following sorts selects an item and then moves items around to put the selected item in the correct location?

merge sort

insertion sort

quick sort

selection sort

heap sort

Which of these is the correct BigO for searching a single linked linked-list?

O(N)

O(Log2N)

O(N * log2N)

O(1)

O(N2)

Which of the these algorithms has a O(N*N) best case runtime and a O(N*N) worst case runtime?

Binary Search

Linear Search

Selection Sort

Insertion Sort

Quick Sort

Which of the these algorithms has a O(1) best case runtime and a O(Log2N) worst case runtime?

Binary Search

Linear Search

Selection Sort

Insertion Sort

Quick Sort

 Which of these is the correct BigO for adding an item to the front of an array?

O(N)

O(Log2N)

O(N * log2N)

O(1)

O(N*N)

Which of these is the correct BigO for adding an item to the end of an array?

O(N)

O(Log2N)

O(N * log2N)

O(1)

O(N*N)

Which of these is the correct BigO for adding an item to the front of a Java LinkedList?

O(N)

O(Log2N)

O(N * log2N)

O(1)

O(N*N)

Which of these is the correct BigO for deleting any item from an ArrayList?

O(N)

O(Log2N)

O(N * log2N)

O(1)

O(N*N)

  Which of the following would correctly fill < blank 1 > ?
public static void sortOne( Comparable[] list )
{
     for(int i=0; i<list.length-1; i++)
     {
          int min = i;
          for(int j=i+1; j<list.length; j++)
          {
                if(list[j]. < blank 1 > (list[min])<0)
                  min = j;
          }
          if( min != i)
          {
                Comparable temp = list[min];
                list[min] = list[i];
                list[i] = temp;
           }
     }
}

compareTo

int

Comparable

String

Object

 Assuming <blank 1> is filled correctly, what sort is sortOne()?
public static void sortOne( Comparable[] list )
{
     for(int i=0; i<list.length-1; i++)
     {
           int min = i;
           for(int j=i+1; j<list.length; j++)
           {
                  if(list[j]. < blank 1 > (list[min])<0)
                   min = j;
            }
            if( min != i)
            {
                 Comparable temp = list[min];
                  list[min] = list[i];
                  list[i] = temp;
             }
      }
}

bubble sort

selection sort

insertion sort

binary search

merge sort

A

A

A

A

A

A

A

A

A

A

A

A

A

A

A

A

A

A

A

A

A

A

A