Algorithms Final

What is the time complexity of the Insertion/Bubble Sort?

BigO: n^2 BigOmega: n

What is the time complexity of the Selection Sort?

BigO: n^2 BigOmega: n^2

What is the time complexity of Mergesort?

BigO: nlogn BigOmega: logn

What is the time complexity of Quicksort?

BigO: nlogn BigOmega: n^2

Why do we sometimes use linear search instead of binary search?

Binary search requires the dataset to be sorted

The average search time in separate chaining depends heavily on the load factor. What is the ideal and not ideal case?

Ideal Case (λ ≤ 1): Each linked list has a length of 1 or less. This scenario leads to constant time (O(1)) search operations Non-Ideal Case (λ > 1): Searching through these longer lists increases the average search time. Traversing longer lists incurs a linear time (O(λ)) cost in the worst case.

BigO of heap insert/delete

O(logn)

Time complexity of MOST AVL tree operations (insert, delete, search, findMin, findMax, etc)

O(logn)

Best case & worst case for BST & AVL Tree

O(logn) O(n)

Time complexity of BST operations (insert, delete, search, etc)

O(n)

Time complexity of tree operations: deleteTree() & copyTree()

O(n)

building heap

O(n)

Preorder traversal

ROOT, left, right

In order traversal

left, ROOT, right

Postorder traversal

left, right, ROOT

In separate chaining, hash table elements point to _________ of records associated with the index

linked lists

How long in the worst case does it take to find an element within a dataset of size n using binary?

logN (the search algorithm would have to divide the list the max amount of times if the element is not the element the marks the split until it is the last left)

use case for preorder

making a copy of a tree

what does increaseKey (p, △) do?

moves node down the tree

what does decreaseKey(p, △) do?

moves node up the tree

Rank the time complexities

n!, 2^n, n^2, nlogn, n, logn, 1

how do you insert a value into a heap?

place in next available position, percolate up until it is in the right position (while x < parent(x) and x!=root, swap)

A min / max heap is essentially a

priority queue

what does remove(p) do?

removes node at p

Why is pass by constant reference sometimes used instead of pass by value?

used to avoid copying data while ensuring the original value cannot be modified by the function.

code for recursive function to perform an in order traversal on a binary tree

void BST:: printInOrder(Node *node) const { if (node == nullptr) { return; } printInOrder(node->leftChild) cout << node ->value printInOrder(node->rightChild) }

rules for heap

children not sorted, children are larger than parents in min heap, parents larger in max heap. not a BST

full tree

internal nodes have 2 children, each nodes subtrees are the same height

f(i) for separate chaining

0

Lamda for Linear & Quadratic Probing

0.5

How do you rehash?

1. Make new Table. TableSize = FindNextPrime( TableSize * 2 ) 2. Take every element from the old table and hash it into new table 3. Destroy old table itself

Hashtable's goal is constant time lookup. What key elements work to ensure this?

1. Prime table size!! - reduces chance of collisions 2. Lamda Thresholds (load factor) 3. Hash functions

Lamda for Separate Chaining

1.0

Using an array, with the first element located at index 1, we can access the left child of a node located at index i with:

2i

Using an array, with the first element located at index 1, we can access the right child of a node located at index i with:

2i + 1

When we put the const keyword on a function definition, we force it to become an...

Accessor (doesn't change data members of the class)

T/F A complete binary tree cannot have an additional node added without increasing the height of the tree.

False

T/F All Binary trees are also heaps

False

T/F All heaps are full binary trees

False

T/F We can use the same insert functions on both heaps and binary search trees because they are so similar the algorithm is the same

False

Given all the ways we could analyze algorithm performance, why do we focus on Big-O?

It describes the worst case scenario by analyzing the end behavior of a program. Instead of testing many different numbers or conditions manually, big-O helps us figure out this more efficiently.

Best way to pick a pivot for quicksort?

Median of 3, choosing number in the middle of the list allows the algorithm to make less swaps

Three ways to pick a pivot for quicksort?

Median of three, random, largest/smallest

Load factor (lamda) equation

N / TS represents the average number of elements per linked list (separate chaining) in the hash table

Is selection sort stable?

No

Hashing stores records in (optimally) _____ time for: Access, Insert, Search

O(1)

What do we do if two elements hash to the same index?

Separate Chaining/Probing

Why don't we use radix sort everywhere?

Space Inefficiency: requires additional space. Not an in-place sorting algorithm as it requires extra space for output.

What is a good reason to use empirical testing

To test that your algorithms are functioning as intended. Also allows you to get a clear/specific idea of how your algorithm is performing.

T/F Any binary tree can be represented as an array

True

T/F The left child and right child of a node in a heap do not have any ordering to one another

True

What does it mean when a sort is stable?

When the objects are sorted, objects of the same value will be in order.

Is the Insertion Sort/Bubble Sort stable?

Yes

hash table chronology

data key --> hash function --> index/hash key --> bucket

use case for post order

deleting trees

balanced tree

each node's L & R subtrees differ by less than abs(1)

complete tree

full at level n-1, level n filled L-->R

use case for in order

getting non decreasing order of tree

To insert terms using hash tables:

hi(X) = (hash(X) + f(i)) % TS

f(i) for linear probing

i

Using an array, with the first element located at index 1, we can access the parent of a child node located at index i with:

i/2 (round down)

f(i) for quadratic probing

i^2

pseudocode for insert (hash table)

insert(x) 1. get hash of x 2. check if that spot is free 3. if spot is free, put x there - itemCount++ - update lamda (item count/table size) - rehash if needed 4. if no spot, rehash (but there should be a spot)

Simple Hash Integer Function

int hash( const int key, int tableSize ) { return( key % tableSize ); }