CS 251 Midterm Set
Prime number
A whole number that has exactly two factors, 1 and itself.
priority queue
Each element of a priority queue has an associated priority.
Dynamic Programming Example
Fibonacci numbers with array
System dependent effects
Hardware (CPU, memory), Software (compiler, interpreter), System (OS, network, other apps). Determine the constant a in power law
How to prove correctness of greedy algorithm?
you have to prove that choosing the local optimum based on that greedy choice will always produce a global optimum. Proof by contradiction
Bubble Sort Average Case
N^2
Bubble Sort Worst Case
N^2
Selection Sort Average Case
N^2
Selection Sort Best Case
N^2
Selection Sort Worst Case
N^2
Ternary Tree
every node has at most 3 children
Full binary tree
every node other than the leaves has two children
Brute Force
exhaustively search all the possibilities. Often useful as a starting point
Order of growth example
1, logN, N, NlogN, N^2, N^3, 2^N
given a complete ternary tree of height 7 how many internal nodes are there are level 3
27
What is the maximum number of leaves a tree can have
2^h
if there are e external nodes how many nodes total are there
2e - 1
given a ternary tree of height h what is the max number of leaves it can have
3^h
Max heap
A binary tree that maintains the simple property that a node's key is greater than or equal to the node's children's keys
Log-log plot
A graph where both the x-axis and the y-axis represent the logarithm of the respective data points. Straight line identifies power law.
What makes a good algorithm?
Accuracy: you want to be sure there is a correct output for given input Efficient: you don't want to waste time or space
Bubble Sort
Moving through a list repeatedly, swapping elements that are in the wrong order.
Prune and Search example
Binary Search
What do we care about with sorting methods?
Certification, runtime, extra memory, types of data
Divide and Conquer
Done recursively, divides a problem into subproblems and combine solutions to subproblems to form solution to original problem
Bubble Sort Best Case
N
Brute Force Example
Linear Search
Divide and Conquer Example
MergeSort, Quicksort
Bubble Sort Extra Space
O(1)
Selection Sort Extra Space
O(1)
array look up operation time
O(1)
linked list look up tim
O(N)
amortized cost of push in array
O(N) for total cost for N pushes -> O(1) for average cost per push
Reasons to Analyze Algorithms
Predict performance, compare algorithms, provide guarantees, understand theoretical basis
Selection sort
Repeatedly select the smallest item and put it into the next unsorted spot
Greedy Algorithm example
Scheduling problem
Average case
expected cost for random input. Need a model for "random" input. provides a way to predict performance
Binary search recurrence relationship
T(N) <= T(N/2) + 1 for N > 1 with T(1) =1 . T(1) is for te first compare or if there is only one element. The N/2 is because you divide the array into halves
Power law
T(N) = a * N^b where a = 2^c
Worst Case
Upper bound on cost. Determined by "most difficult" input. provides a guarantee for all inputs
Arrays
a collection of items stored in a contiguous memory location and addressed using one or more indices
Abstract Data Type
a description of operations on a data type that could have multiple possible implementations. Specifies data, operations, and error conditions
Doubly Linked list
a linked list in which each element has both forward and backward pointers.
Algorithm
a process or set of rules to be followed (instructions) typically with an end goal
Linked List
a sequence of records, where each record contains a link to the next one.
Comparable Interface
a useful Java interface for writing generic sorting methods
Bag operations
add, isEmpty, size, (iterate)
frequency depends on...
algorithm, input data
System independent effects
algorithm, input data. Determine the exponent b in power law
Bags
allow any type of data in any order
key
an abstraction, must be something that can be ordered
Postorder
an order of processing a tree in which the children before parents
Preorder
an order of processing a tree in which the parent node is processed before its children.
How to implement a stack
array or linked list. array you may need to resize
amortized analysis
average running time per operation over a worst case sequence of operations
Dynamic Programming
combines optimal solutions to form an optimal solution and keeps track of subsolution to avoid repetitive statements
Cost of operations depend on...
compiler, machine
data structure
data organization, management, and storage format that enables efficient access and modification. More precisely, a data structure is a collection of data values, the relationships among them, and the functions or operations that can be applied to the data.
Queue
data stored in First in first out order
Stacks
data stored in first in last out order
if a program uses queue...
dealing with data stored and processed in fifo order
if a program uses stack...
dealing with data that needs to be put in FILO/LIFO order
lazy approach
do work until later
eager approach
do work up front
Barnes-Hut Algorithm
enables new research
FFT Algorithm
enables new technology
queue operations
enqueue(e), dequeue(), size(), isEmpty()
Big-Theta notation
establishes a "TIGHT" bound. (both upper and lower) f(n) is Theta(g(n)) if there is a constants c` and c`` > 0 such that c`g(n) <= f(n) <= c``g(n)
Big-Omega Notation
establishes a LOWER bound. f(n) is Omega(g(n)) if there is a constant c> 0 such that f(n) >= cg(n)
Binary Tree
every node has at most 2 children
swimming
go from bottom up and exchange values based on what type of heap it is
sink
go from top to bottom exchanging values based on what type of heap it is
Rooted Tree
hierarchical structure that has a parent-child relationship
Value of defining a narrow adt
how an operation is implemented matters, encourages discipline, thinks about what is essential
if there are i internal nodes, how may external nodes are there
i + 1
Array resizing in stacks and queues
if it is full double the array size, if less than 1/4 of array is used decrease size by half
Heap as an array
if node is at index k (zero based). Left child is 2k+1, right child is 2k+2, parent is the floor of (k-1)/2
Tilde notation
ignore lower order terms, and keep the constant for the largest time and highest term
priority queue operations
inser, removeMax, removeMin
Insertion Sort
insert current item into its proper place in the sorted part of the array (on the left)
inorder
left, root, right
if there are e external nodes what is the minimum height
log (e) base 2
Best case
lower bound on cost. determined by "easiest" input. Provides a goal for all inputs
Why do we study data structures with algorithms?
need to understand how data structures operate because this will effect runtime of an algorithm
Runtime Cost Model for Sorting
number of compares and exchanges, if there are no exchanges, use array accesses
Discrete Fourier Transform Success
previously solved in N^2 steps, with FFT algorithm, now solvable in NlogN
stack operations
push, pop, peek
doubling hypothesis
quick way to estimate b in a power law relationship
Properties of selection sort
runtime is insensitive to input, data movement is minimal (O(N) exchanges), anything left of the current index is sorted and in final position
Properties of insertion sort
runtime is sensitive to input, works well for tiny arrays and partially sorted arrays (number of inversions is low)
Prune and Search
similar to divide and conquer but recursively prune the search space (reduce the size) by a constant factor
Greedy
solving an optimization problem where we attempt to find a global optimal solution by choosing the optimal value locally
N body simulation
stimulate gravitational interactions among N bodies previously in N^2 steps, now NlogN.
Total running time
sum of cost * frequency for all operations
if f(n) is theta(g(n))...
then f(n) is O(g(n)) and f(n) is omega g(n) meaning g(n) is o(f(n)) and g(n) is omega f(n))
If f(n) is theta(g(n))...
then g(n) is theta(f(n))
if a program uses a bag...
then the order of data stored doesn't matter
3-sum problem
total possible number of triplets C(N,3)
Big-Oh Notation
used to classify UPPER bound. f(n) is O(g(n)) is there exists a positive constant c such that f(n) <= cg(n)
Algorithm paradigm
way of approaching a problem. No paragidm is better than another, success is depending on the context of the problem you are trying to solve
