CS201 Final Exam

Suppose that we have a circular array such as the one below, with capacity = 8 and size = 4, with the front of the array being the element A at index 2 and the back being the element D at index 5. index 0 1 2 3 4 5 6 7 A B C D Suppose that we perform a delete front, addEnd(E), addEnd(F), addEnd(G). At what index is the element G stored? Suppose we continue from here and perform three delete front operations and an addEnd(H) operation. At what indices are the elements at the [front] and [back] of the array?

1. 0 2. front: 6 back: 1

1. Start with a dynamic array that has storage for 8 elements with 4 elements "in use" by the user of the array. Suppose that the user performs 14 insert operations. Draw the resulting dynamic array and state the total storage space allocated for the dynamic array. 2. Perform 5 delete operations. How much total storage space allocated for the dynamic array now? 3. Now perform 4 insert operations. How much total storage space allocated for the dynamic array now? 4. Lastly, perform 12 delete operations. Draw the final array and state the total storage space allocated for the dynamic array.

1. 32 total with 18 in use 2. 32 storage 13 in use 3. 32 storage 17 in use 4. 16 storage, 5 in use

1. Suppose that we start with a dynamic array that has capacity for 16 elements with 9 elements "in use" by the user of the array. Suppose that the user performs 24 insert operations. The resulting dynamic array should have capacity for how many elements? 2. Continue from the first Dynamic Arrays question, if the user performs 10 delete operations, the resulting dynamic array should have capacity for how many elements? 3. Continuing from the Dynamic Array Delete: Suppose that the user now performs 10 more delete operations. The resulting dynamic array should have capacity for how many elements?

1. 64 2. 64 3. 32

You have a Binomial heap with B4 B2 B1 B0 tree and merge it with binomial tree with B3 B1 B0 What trees will result have? How many nodes?

1. B5 and B1 2. 34 nodes

Red Black Tree Properties

1. Every node is either red or black 2. The root is black 3. Every leaf (NIL) is black 4. If a node is red, then both its children are black 5. All simple paths from node to child leaves contain the same # of black nodes

If a 2-4 tree with one node has height 1, what is the maximum number of keys/values in a valid 2-4 tree of height 5?

1023 as height = log2(n+1) - 1 or 4 ^height - 1

Suppose that the majority element problem starts with the sequence of 1s, 2s and 3s: 1 3 2 2 3 3 1 2 1 3 1 1 1 1 What would the next sequence of values be?

2 3 1 1 idk how

2-4 Tree -> Red-Black Tree conversion

2 node = black w/ 2 black children 3 node = black w/1 red child 4 node = black w/ 2 red children

What is the expected height of a treap of size n = 50, 000 closest to?

2lg(N)

The worst case O(N) time selection algorithm finds its pivot element by finding the median of the medians of groups of size

5

Binary Search Tree

A data structure very similar to a tree with the following additional restrictions. Each node can have only 0, 1 or 2 leaf nodes. All left nodes and all of its descendants have smaller values that the root node, while all right nodes and all of its descendants have larger values than the root node.

Bubble Sort Algorithm

A sorting algorithm that makes multiple passes through the list from front to back, each time exchanging pairs of entries that are out of order

Dijkstra's algorithm

An algorithm for finding the shortest paths between nodes in a weighted graph. For a given source node in the graph, the algorithm finds the shortest path between that node and every other. It can also be used for finding the shortest paths from a single node to a single destination node by stopping the algorithm once the shortest path to the destination node has been determined. Doesn't know how to handle negative weights

Counting Sort

An algorithm for sorting a collection of objects according to keys that are small integers; that is, it is an integer sorting algorithm. It operates by counting the number of objects that have each distinct key value, and using arithmetic on those counts to determine the positions of each key value in the output sequence. Its running time is linear in the number of items and the difference between the maximum and minimum key values, so it is only suitable for direct use in situations where the variation in keys is not significantly greater than the number of items. However, it is often used as a subroutine in another sorting algorithm, radix sort, that can handle larger keys more efficiently.[1][2][3] Because counting sort uses key values as indexes into an array, it is not a comparison sort, and the Ω(n log n) lower bound for comparison sorting does not apply to it. Basically you'd make an array size max + 1 Say you 0 1's 2 2's 1 three 3 4's. You'd just input until each is empty. So you'd input the one and then minus it's count and if count >0 then input it again and count-- and if it count is zero then go to the next one

Amortized Analysis

Applies to worst-case sequences of operations Finds average running time per operation Cost per-operation over a sequence of operations

What's the best algorithim for a directed graph with negatives to find shortest path from V to all other vertices?

Bellman-Ford

Say you implement Dijkstra's Algorithim with a Fibonacci Heap, successful relaxation utilized which operation?

Decrease-key

Counting sort is a comparison based sorting algorithm

False

True/false In 2-4 trees, every time a 4-node is created, it's split

False

Master Theorem

Given T(n) = aT(n/b) + f(n), where a = # subproblems, n/b = size of subproblems, and f(n) = time complexity of subproblems (minus the recurrence part): If f(n) = O(n^(logb(a) - e)) for e > 0, then T(n) = θ(n^(logb(a))) If f(n) = θ(n^(logb(a))) then T(n) = θ(n^(logb(a)) * log(n)) If f(n) = Ω(n^(logb(a) + e) for e > 0 AND af(n/b) <= cf(n) for any constant c then T(n) = θ(f(n)) simpler terms: T(N) = a T(n/b) +d if log b (a) < d, run time = O(n^d) if log b (a) = d, run time = O(n^d log n) if log b (a) > d, run time = (n ^ (log b (a)))

2-4 Tree Insertion

Insert into it's place in order. If Node it's inserting into is a 4 node, bring the middle node up

Dijkstra's time complexity

Its time complexity is O(E + VlogV) for fibonacci heaps, where E is the number of edges and V is the number of vertices. V^2 for unordered array

Does the root list change on merge of Fib-Heap?

No, only on decrease-key and extract-min

radix sort

Non-comparative integer sorting algorithm that sorts data with integer keys by grouping keys by the individual digits which share the same significant position and value. Two classifications of radix sorts are least significant digit (LSD) radix sorts and most significant digit (MSD) radix sorts. First sort by one's place, then tens and so forth. If they're equal don't swap

Red-Black tree Rotation Time complexity

O(1)

Array Runtimes

O(1) Amortized time per operation. • O(N) worst case time for any single operation.

binomial heap run times (wc)

O(1)- Make-Heap + isEmpty O(log N)- Insert, Extract-Min, Decrease-Key, Delete, meld, Find-Min

binary heap run times

O(1)- Make-Heap + isEmpty +FindMin O(log N)- Insert, Extract-Min, Decrease-Key, Delete O(N)- meld

Fibonacci Heap amortized run times

O(1)- Make-Heap + isEmpty, Decrease-Key, Insert, meld, Find-Min O(log N)- Extract-Min, Delete

What is the running time of the following code fragment: for(i=1; i<N; i++) for (k=1; k<=N; k *= 2) z++;

O(N lg N)

Pre-Order/Post-Order/In-Order run times

O(N)

WC time to extract-min on N node Fibonacci heap

O(N)

What is the max number of B0 trees in fib heap with n nodes?

O(N)

What is the running time of the following code fragment: for (k=1; k<=N; k *= 2) for(i=1; i<k; i++) z++;

O(N)

for (k=1; k<=9999*n; k+=10) z++;

O(N)

Median of Medians time complexity

O(N) for everything

linked list heap run times

O(N) for extract-min and Find-Min O(1) for everything else

Given a list of N integers in the range 0...K, what is the running time of counting sort on these values?

O(N+K)

Given a list of N integers in the range 0...N2, what is the running time of counting sort?

O(N^2)

O(N^2 + N) is basically?

O(N^2)

Suppose we are performing the quickselect algorithm, and every time we pick a partition element we are very unlucky, picking the smallest or the largest value remaining in the set. What would the running time of this worst case behavior be?

O(N^2)

What is the solution to the recurrence : T(N) = 8 T(N/4) + O(N^2)

O(N^2)

for (i=1; i<=n*n; i++) z++;

O(N^2)

What is the solution to the recurrence : T(N) = 27 T(N/3) + O(N^3)

O(N^3 lg N)

Worst Case time to merge 2 Binomial Heaps

O(lg N)

What is the Worst Case time to add element to N node binomial heap?

O(lgN)

Binary search runtime

O(log n)

Red-Black tree Height max

O(logN)

Quick Sort Worst Case

O(n^2) In Place: yes Stable: no

Bubble Sort Worst Case

O(n^2), reverse sorted array

Quick Sort Average Case

O(nlogn)

Merge Sort Time Complexity, stable? in-Place?

O(nlogn) in all cases stable- yes in-place- no

Linked lists struggle with?

Ordered Lists

Majority Element Algorithim

Phase 1: Use divide-and-conquer to find candidate value M • Phase 2: Check if M really is a majority element, θ(n) time, simple loop

Red Black Tree violation when insert

Red Uncle: colorflip, Red parent with two black children (red parent will be new nodes grandparent) Black Uncle: rotate, Black parent with two red children

2-4 Tree Deletion

Search the node whose value needs to be deleted. If the node is a leaf node then remove the required value from that node and decrease the data elements by 1. If the node is not a leaf node then:Find the successor of that node. A successor of a node is the smallest element among the ones which are greater than it or the largest element among the ones that are smaller than it.Swap the successor with the current node and delete that node in the leaf.

Merge Sort Algorithm

Sorts an array by cutting the array in half, recursively sorting each half, and then merging the sorted halves

Strassen's algorithim

Strassen's matrix multiplication (MM) has benefits with respect to any (highly tuned) implementations of MM because Strassen's reduces the total number of operations. Strassen algorithm is a recursive method for matrix multiplication where we divide the matrix into 4 sub-matrices of dimensions n/2 x n/2 in each recursive step.

Suppose that the number of recursive calls in Strassen's matrix multiplication algorithm could be reduced from 7 to 6. What would the recurrence relation for this new algorithm be?

T(N) = 6 T(N/2) + O(N^2)

Strassen's Algorothim Reccurrence relation

T(n) = 7 T(n/2) + θ(n2) 7 = # of recursive calls

If the input to buble sort is given in already sorted order, buble sort will do n-1 comparisons and finish. Why does this not break the sorting lower bound?

The lower bound is for the worst case performance of sorting algorithms.

Median of medians algorithm

The median-of-medians algorithm is a deterministic linear-time selection algorithm. The algorithm works by dividing a list into sublists and then determines the approximate median in each of the sublists. Then, it takes those medians and puts them into a list and finds the median of that list ideally uses groups of size 5

counting sort runtime

The time complexity of counting sort algorithm is O(n+k) where n is the number of elements in the array and k is the range of the elements. Counting sort is most efficient if the range of input values is not greater than the number of values to be sorted.

radix sort run time

The time complexity of radix sort is given by the formula,T(n) = O(d*(n+b)), where d is the number of digits in the given list, n is the number of elements in the list, and b is the base or bucket size used, which is normally base 10 for decimal representation

Quick Sort Algorithm

This uses a divide and conquer algorithm. First the pivot value which is the first item in the list is selected. Then the remainder of the list is divided into two partitions, the elements less than the pivot is in the first partition and the greater elements in the second.

Reminder: In a 2-4 Tree, a 2 node where each of it's children are 2 nodes will compress into a 4 node when you delete. Is this true?

True

true or false? all leaves are the same depth in a 2-4 tree

True

Which of the following characteristics are typical of divide and conquer solutions?

Use recurrence relations to analyze running times. Uses recursive solutions to subproblems. Sometimes require work to combine solutions of smaller problems.

Inserting 1, 2, 3, 4... into a 2-4 tree creates?

a balanced tree

Red-Black Tree -> 2-4 Tree conversion

a black node with two black children is a 2 node, a black node with one red child is a 3 node, and a black node with two red children is a 4 node

Binary Search

a search algorithm that starts at the middle of a sorted set of numbers and removes half of the data; this process repeats until the desired value is found or all elements have been eliminated. so compare val to middle, if < then take left array, if right take right array

Red-Black tree

a self-balancing binary tree in which nodes are "colored" red or black. The longest path from the root to a leaf is no more than twice the length of the shortest path.

How many bits does it take to represent ? (I promise this is related to sorting)

at most (lg(n+1))/2

2-4 tree top-down insertion

automatically break up every 4 node you enter

2-4 Trees

consists of 2, 3, 4 nodes where it's a self balancing binary tree that prevents worst case run times of O(N)- think if you just keep insert bigger values so it's just a chain on the right side

Given a list of N integers in the range 0...N2, suppose we consider the values as having two "digits" (not base 10 digits :)) and make two passes of counting sort using the low order digit first. What is the time taken by each pass of counting sort O([A]) and what is the total time for the sort O([B])?

each pass: O(N) total time: O(N) IDK why this is true

2-4 tree top-down deletion

idk

Describe an efficient algorithm to find the K smallest values from an unordered list of N values. Give the running time in terms of N and K. You may invoke any algorithm presented in class without repeating a step by step description of the algorithm.

idk

2-4 Tree Run Times

insertion, deleting and searching of this tree is O(lgn)

Post-Order Traversal

left, right, root

In-Order Traversal

left, root, right

for (i=1; i<=100*n; i++) z++;

o(N)

for (k=1; k<=n; k+=2) z++;

o(N)

for (i=1; i<=n; i++) for (j=n; j>i; j--) z++;

o(N^2)

for (i=1; i<=n*n*n*n; i+=n) z++;

o(N^3)

for (j=1; j<=n*n; j++) for (k=1; k<=n; k++) p++;

o(N^3)

for (k=1; k<=n; k+=k) z++;

o(lg N)

What color is a node when it gets inserted

red nodes

Red/Black Tree deletion

replace with predecessor/successor depending on method asked for and then rebalance

Pre-Order Traversal

root, left, right.

Red Black Tree Time Complexities

search, insert, remove O(logN) space complexity O(N)

True/false Let:f(n) be g(n) be f(n) is O(g(n)) and g(n) is Ω(f(n))

true

When do we resizie an array?

when it's full on insert double it, when it has at or less than 25% then you half the size

Predecessor Replacement

when you extract the root from the binary search tree you replace it with it's predecessor which is one previous to it. O(lg N) - run time as you have to search for predecessor

Successor Replacement

when you extract the root from the binary search tree you replace it with it's successor which is one previous to it. O(lg N) - run time as you have to search for successor

int max(int items[], int size) { int largest = items[0]; for(int i=0; i<size; i++) if (items[i] > largest) largest = items[i]; return largest; } •What is the running time of the max function if items has N values?

•2N + 2 ? •O(N)