Exam 1 | Exam 2 | Final Exam |

• rules during Exam
  • IDs will be checked. Make sure to bring your ID.
  • SMART WATCH, tablets, are not allowed in the exam. REMOVE YOUR smart watch and earbuds. Put away all these devices.
  • Headphones / earbuds not allowed. Remove them.
  • Caps not allowed. If you have a reason why you have to wear one, talk to the instructor beforehand.
  • More logistics information will be added closer to the exam.
  • The Cheat sheet (1 page) from the Slides page will be provided by the instructor, along with the exam
  • Scantron not needed.
• "How should I study for this exam? What should I focus on?"
  1. Understand and know how to solve problems from the listed Weekly Quizzes. Some problems will be similar to those.
  2. Study the topics and practice problems from the Exams page.
  3. Study the hw problems.
  4. Study material covered in class (examples done in class, discussions from class).
  5. Make sure you are familiar with the format for the solutions for the problems. They will be worded in the exam the same way as in past assessments and examples (WQ, Hw, class examples, slides, sample problems posted on the Exams page). You should not be in the case where you do not know what you are supposed to fill in a table.
  6. Note that some tables in exam may have MORE rows/columns than needed so that you use as many as you need and not be guided by the number of rows or columns in your solution.
  7. Master writing code for the functions listed in the Code section for each exam. We will give some partial credit, but not as much and not if the logic is wrong. There is a 95% chance of having a coding problem in each exam and they will be from the list in the Code bullet.
  8. Know space and time complexity for all algorithms.
  9. Know how to solve TC for code (loops with tables), and for recursive functions with the tree method and the Master Theorem method (after they are covered). Be able to write the recurrence formula for a piece of code (after recurrence formulas are covered).

Midterm Exam 1 back to top

• Rules and logistics:
  • students must take the exam with their section. Note that even though Canvas shows section 001, you may be in section 002. Check MyMav to confirm your section, or see announcement in Canvas, or ask us.
  • NO CALCULATOR allowed. - Updated 9/19/25
• Practice problems:
  • W-quizzes
  • Understand and know how to solve problems similar to those in Homework 1 and Homework 2.
    You can find the sample_table_answer.pdf under Canvas->Modules->Resources - updated 9/19/'25
  • PRACTICE time complexity of loops, and Solution to a couple of problems (pdf, docx)
  • Growth of functions, summations ( Solution )
  • insertion sort, indirect sorting, binary search ( Solution)
  • count sort, radix sort, bucket sort practice, (Solution ) - bucket sort is not in the exam so all problems on bucketsort are not part of the exam.
  • Merge sort, Quick sort (Solution) - Quicksort is not in the exam.
  • Recurrences ( Solution ) - Master Theorem will not be part of this exam.
• Code - Given the function signature, continue to write code for
  • basic/"building block" algorithms over strings, 1D arrays, 2D arrays
    • find min or max. E.g. int get_min(int *arr, int N)
    • sum or product over array values. E.g. int sum_over_array(int *arr, int N)
    • answer none/some/all questions. E.g., int no_negatives(int arr[], int N) return 1 if every number is 0 or higher. Else (if at least one number is negative) return 0 .
    • check if one string is a substring of another string
  • binary search: int binary_search(int val, int N, int * A) // use the variable names from arguments
  • insertion sort: void insertion_sort(int * arr, int sz) // use the variable names from arguments
  • indirect sorting (using an array of pointers to strings, or an array of indexes) (- because it was part of the hw)
  • individual components of count sort:
    • counting keys
    • prefix sum (also known as cummulative sum)
  • void Mergesort(int *A, int left, int right) - from slides . This is just the Mergesort function. The code/pseudo code for Merge() function is not on this list.
  • pseudocode that was covered in lecture (can be found on the Quicksort document) for:
    void Quicksort(int *A, int start, int end) and
    int Partition(int *A, int start, int end) - updated 9/19/'25
• Topics
  • logs that you must be able to answer without a calculator. Remember that lg() = log_2().
    • lg for: 1,2,4,8,16,32,64,128,256
    • log_3 for: 1,3,9,27,81
    • log_4 for 1,4,16,64
    • log_5 for: 1,5,25,125
    • log_6 for: 1,6,36
    • log_7 for: 1,7,49
    • log_8 for: 1,8,64
    • log_9 for: 1,9,81
    • log_10 for: 1,10,100, 1000,10000, (any power of 10)
  • time complexity (for loops, if statements, functions): Theta, dominant term(s), best case/worst case where applicable.
  • time complexity - short and long answers. For a long answer, be able to fill in all the steps for a detailed solution (like in the hw). E.g. for nested loops fill in all the information for all loops .
  • Growth of functions and summations
    • Θ, O, Ω, o,ω,
    • order functions by their growth,
    • e.g. know that if f(n) =Θg(n))=> f(n) = O(g(n)), but not viceversa
    • see practice problems above
  • Recurrences - updated 9/19/'25
    • code => recurrence formula (Given code, be able to write the recurrence formula for both the recursive case and the base case)
    • Tree method for solving recurences like the 2 we did in class:
      T(N) = T(N-1) + c with T(1) = T(0) = c
      T(N) = T(N/2) + c with T(1) = T(0) = c.
      An example of a recurrence NOT askes in the exam: T(N) = T(N-1) + N
    • know that problem size is written outside the node and local time complexity is written inside the node.
    • Be able to draw the tree and use the tree to compute the time complexity.
      • using the tree method to derive time complexity for Mergesort and other recursive functions
      • given recurrences, be able to give tree information at level i (number of nodes at level i, problem size for a node at level i, local time complexity for a node at level i) and number of levels in the tree.
  • sorting - selection sort. Be able to show array after each next min value is put in place, as done in class. - updated 9/19/'25
  • sorting - mergesort - be able to show the array after 1,2,3,... x calls to merge. Be able to compute the middle index m (it is the same as for binary search). Be able to write just code for Merge() (the recursive function) - updated 9/19/'25
  • recursive binary search - know that it uses space log_2(N) because of the recursive stack. Know that any recursive function will have space complexity also comming from the stack of function call frames.
  • be able to compare strings using alphabetical order
  • sorting - insertion sort, count sort, radix sort, bucket sort ,quicksort. For each of these algorithms know all the requirements listed below:
    • stable?, adaptive?,
    • time complexity, space complexity, data moves,
    • be able to show the data after each iteration of the [outer/inner] loop without seeing the code (see practice problems).
    • Know when (for what data and requirements) is an algorithm applicable and when not. When would you choose one algorithm over another (e.g. depending on system limitations for memory, or time requirements or some specific distribution of the data)?
    • If given code for a variation of one of the sorting algorithms, be able to analyze it: Is it stable? Is it adaptive? What time and space complexity does it have? Is it a direct or indirect sort?
    • for bucket sort study both formulas for computing the index: floor((elem-min)*N/(1+max-min)) and also the easier one : floor(elem*N) - updated 9/19/'25
  • Binary search
  • Indirect sort for insertion sort. E.g. given Data array, fill in values for the Index array after indirect sorting. Why/when would we use indirect sort?
  • Not included (not tested in the quiz):
    • proving that an algorithm is correct;
    • writing code for any algorithm not explicitly mentioned in the Code bullet

Midterm Exam 2 back to top

• exam in person, in the classroom, during lecture time for each section.
• No calculator allowed
• students must take the exam with their section. Note that even thought Canvas shows section 001, you may be in section 002. Check MyMav to confirm your section, see announcement in Canvas, or ask us.
• Practice problems:
  • W-quizzes
  • Merge sort, Quick sort (Solution)
  • Recurrences ( Solution )
  • Heaps (Solution)
  • Stacks, queues (Solution)
  • Trees
    • Trees, BST, 2-3-4 (Solution)
    • more Trees, BST (Solution)
• Code
  • Basic algorithms and coding
    • basic coding: be able to write code (e.g. in main() ) to call a function given its signature. Be able to write function calls with both hardcoded data and with variables updated with user input.
    • be able to work with data of type: char, int, float
    • all listed under Exam1
    • basic string processing algorithms :
      • For all the basic algorithms (from Exam1 and below)The answer cannot be just calling the corresponding string function. The purpose of the question is for you to write the code that achieves the required result (using loops).
      • The sample problems stated here for strings, can be asked for arrays of int or float as well. E.g. int isEqual_2(const int *arr1, int N1, const int * arr2, int N2) returns 1 if the 2 arrays have the same elements (not the same address).
      • For string problems, unless stated otherwise by the problem, uppercase and lowercase characters are considered different for the problems below (to make the work easier)
      • int isEqual(const char *s1, const char * s2) - return 1 if s1 and s2 have the same string, 0 otherwise.
      • int isSubstring(const char *sBig, const char * sSmall) - returns 1 is sSmall is a substring of sBig. Returns 0 otherwise. E.g. for "abcdef" the string "cde" is a valid subsequence but "acd" is not (a and c are not consecutive) and "dce" is not because the letters are not in the same order as in the big string.
      • int isPrefix(const char *sBig, const char * sSmall) - returns 1 is sSmall is a prefix of sBig. E.g. for "abcd" the strings "a", "ab", "abc" and "abcd" are valid prefixes.
      • int isSuffix(const char *sBig, const char * sSmall) - returns 1 is sSmall is a suffix of sBig. E.g. for "abcd" the strings "bcd", "cd", "d" and "abcd" are valid suffixes.
      • int isSubsequence(const char *sBig, const char * sSmall) - returns 1 is sSmall is a subsequence of sBig. Returns 0 otherwise. A subsequence of a string sBig, is a string formed of letters of sBig that are in the same order as in sBig, but are not necessarily at consecutive indexes. E.g. for "abcdef" the string "bef" is a valid subsequence but "ebf" and "feb" are not.
      • void replace(char *s, char oldCh, char newCh) - in s replace every occurrence of oldCh with newCh. E.g. if s is "survival" and oldCh is v and newCh is H s becomes "surHiHal".
      • void toUpper(char *s) - change every character in s with its uppercase. E.g. if s is "survival" s becomes "SURVIVAL".
      • variations or combinations of these problems. E.g.:
        • turn to uppercase every other character in s. If s is "survival" s becomes "SuRvIvAl".
        • given an array find the smalles positive number in it.
        - Added 10/22/2025
  • code from Binary Trees (data structure, code)
    • count nodes in a tree, both versions:
      • int count_1(TreeNodePT nptr) // returns the count
      • void count_2(TreeNodePT nptr, int &ct) // use pass by reference to update a variable from the caller function, e.g. main()
    • int compute height(TreeNodePT tree) // return the height of the tree - student self study. See code in slides
    • traversals to print the data from the nodes of the tree
      • void inorderPrint(TreeNodePT nd)
      • void preorderPrint(TreeNodePT p)
      • void postorderPrint(TreeNodePT t_node)
      • be able to write code that enhances these traversals and also prints the level for each node, in addition to its data. - Added 10/23/25
      • Here is an example of a function that prints only the data in the nodes (not the level). It is the post() function from slides

        void post(TreeNodePT h){ 
           if (h == NULL) return; 
           post(h->left); 
           post(h->right); 
           printf("%d, ", h->data); 
        }	
        	

    • Remember to handle cases when the tree is NULL for all these functions.
    • Given the struct for the tree node and the type def for the pointer, and a function signature, continue to write code for the function
    • struct for the tree node will be provided. If not, you can assume:

      typedef struct TreeNode* TreeNodePT; 
      
      struct TreeNode{ 
         int data; 
         TreeNodePT left; 
         TreeNodePT right; 
      };			
      			

• Topics:
  • topics from exam 1
    • know what sorting algorithm to use in a specific case and what it's time complexity is (e.g. se insertion sort of data is almost sorted or if need O(1) space, use Merge sort if need guaranteed TC of NlgN)
    • still need to know the log calculations from exam 1 (e.g. log_2(32) = ???)
    • Θ, O, Ω, o,ω - as they apply to analysis of code. E.g. search or insert is O(height), but print tree is Θ(N)
  • time complexity of loops and if statements: Theta, dominant term(s), best case/worst case where applicable.
  • time complexity - short and long answers. For a long answer, be able to fill in all the steps for a detailed solution (like in the hw). E.g. for nested loops fill in all the information for all loops .
  • Recurrences
    • code <=> recurrence formula
    • Master Theorem
    • Tree and table method for recurrences:
      • know that problem size is written outside the node and local time complexity is written inside the node.
      • Be able to draw the tree and use the tree to compute the time complexity.
        • using the tree method to derive time complexity for Mergesort and other recursive functions
        • given recurrences, be able to give tree information at level i (number of nodes at level i, problem size for a node at level i, local time complexity for a node at level i) and number of levels in the tree.
  • Mergesort - know time and space complexity, stable? adaptive?. You will NOT be asked to simulate it on paper (e.g. no question like give the array after the 3rd call to Merge())
  • Quicksort - simulate on paper, best, avg, worst space and time complexity, stable? adaptive?
  • QuickSelect (return k-th smallest item) - NOT included in this exam
  • Amortized TC calculations - See lecture and W4 quiz.
  • Stacks - usage/application, operations (insert, remove) - TC, SC, simulate on paper
  • Queues - usage/application, operations (insert, remove) - TC, SC, simulate on paper
  • Heaps: usage/application, properties (order, shape), index calculation, build heap (bottom up, top down), insert, remove, sink_down, swim_up, - TC, SC, simulate on paper,
  • top-k - find the top-k largest items in an array. Both methods: 1) using a max-heap, 2) using a min-heap
  • heapsort - main idea, TC, SC, stable, adaptive?
  • Trees:
    • binary trees: traversals (inorder, preorder, postorder, level order).
      • Be able to write the nodes on paper given a tree.
      • know their time and space complexity for the functions discussed in class.
    • tree theory (full tree, complete tree, nearly complete tree and their properties)
    • binary trees in general - height
    • binary search trees - the topics covered Thursday 10/23 in lecture
      • binary search trees : min, max, search, insert, range of values in a subtree of a BST, valid path in a BST. All on paper (no code).
      • Be able to answer/simulate these for a tree on paper and also know the TC and SC of the methods that implement them.

Final exam back to top

• Instructor will provide order of choosing winner in case of ties for DP problems (on front sheet of exam or cheat sheet)
• Code
  • int hash(char *s, int M) - hash function from slides that computes a hash value for a string using a process similar to the base conversion for numbers.
  • int hash(char *s, int M, int a) - same as above, but with a passed as an argument.
  • int knapsack01(int W, int n, int * v, int * w) (0/1 Knapsack iterative solution)
  • int js_iter(int* v, int*p, int n) (Job Scheduling - iterative/bottom up)
  • int Fib_iter(int N) ( iterative version that uses array )
  • int Fib(int N) ( recursive version , but not memoized)
  • code for the LCS algorithm (pseudocode) and backtracking algorithm (pseudocode) from slides.
  • basic/"building block" algorithms
    • old: all "basic algorithms" from Exam 2
    • new: basic algorithms over 2D arrays (e.g. find val, min, max, sum). Be able to iterate over the entire 2D array or over just one row or just one column.
• Practice problems
  • Trees, BST, 2-3-4 (Solution) - see 2-3-4 tree problems (P3 and P4) and BST problems for on topics that are for this exam.
  • Hashing (Solution)
  • Gredy, DP practice ( Solution)
  • Graphs practice ( Solution) - C/F edges are not part of this exam. Tree edges (that connect/dicover a new vertex)and backward edges (that indicate a cycle) are part of the exam.
  • Recurrences ( Solution )
• Topics:
  • Past topics:
    • TC of loops (with tables) as in Exam1 and Exam 2
    • Recurrences
      • code <=> recurrence formula
      • Master Theorem
      • Tree method/tree table
    • sorting, linear and binary search as components to other methods. Know the TC and SC of linear search, binary search and insertion sort (good when data is almost sorted) and a sorting alg that has good TC performance (e.g. mergesort with O(NlgN) TC and O(N) SC) .
  • BST - valid path in a BST, min, max, orderwise predecessor/successor, rotations (left and right rotations at a node). Be able to answer/simulate these for a tree on paper and also know the TC and SC of the methods that implement them.
    (The tree topics that were part of exam 2, e.g. inorder traversal, are NOT part of the Final exam.)
  • 2-3-4 trees
    Summary for 2-3-4 trees and Hash Tables, prepared by Carl
  • Hash tables
    • youtube video on Hash Tables and Hash Functions and lecture
    • Given a hash function, be able to compute the index for hashing a given key (for integers and for strings)
    • separate chaining and open addresing (linear probing, +3 rehash, quadratic hashing, double hashing)
    • primary clustering, secondary clustering (
    • load factor and resizing a hash table
    • operations in hash tables: search, insert, delete,
  • Greedy: Knapsack , Job Scheduling
  • Dynamic Programming: Job Schedulling, 0/1 Knapsack, Fibonacci, counting paths in a 2D matrix, Edit Distance (ED), Longest Common Subsequence (LCS) and Longest Increasing Subsequence (LIS),
  • Graphs and all the Graph-related topics we covered
    • neighbors must be processed in increasing order (consistent with Matrix representation and SORTED linked list representation of edges.
    • directed, undirected
    • degree of a vertex, (out degree, in degree for directed graphs)
    • representation: adjacency list, adjacency matrix (and space requirement for each representation),
    • BFS, DFS,
    • edges (tree, backward ),
    • detect if a directed graph is acyclic or not,
    • topological sorting,
    • Strongly Connected Components ,
    • Minimum Spanning Trees - solved with the table as in class/slides
    • Shortest Path (Shortest Path Spanning Tree, All-pairs shortest paths) - solved with the table of dist/pred as in class/slides
    • Time and space complexity and application for each algorithm.
    • The colors and notations used in the slides are referenced in the exam. If a question on that topic is in the exam, it will use the colors from the slide, e.g. WHITE/GRAY/BLACK for nodes.