• 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 achiesves 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".
    • more to be added
• Tree code from slides on BST:
  • TreeNodePT search(TreeNodePT nd, int v)
  • TreeNodePT insert(TreeNodePT root, int newVal) - note that this is the simple insertion (Naive) not the insertT that inserts the new node as the root by following with a rotation after the insertion.
• from Binary Trees (data structure, code)
  • int count(TreeNodePT nptr) // count number of nodes in tree
  • int compute height(TreeNodePT tree) // return the height of the tree
  • traversals to print the data from the nodes of the tree
    • void inorderPrint(TreeNodePT nd)
    • void preorderPrint(TreeNodePT p)
    • void postorderPrint(TreeNodePT t_node)
    • for the traversals you should print the node data. See the post function from slides for an example:

      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 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
• Amortized TC calculations - See video in Canvas and W4 quiz.
• Stacks
• Queues
• Heaps: build heap (bottom up, top down)
• top-k - find the top-k largest items in an array. Both methods: 1) using a max-heap, 2) using a min-heap
• heapsort
• Trees:
  • binary trees: traversals (inorder, preorder, postorder, level order).
  • binary search trees : search,
  • binary search trees : search, insert, range of values in a subtree of a BST, performance of a 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. - in exam 2 or exam 3 (final) depending on when we cover them depending on when we cover them
  • tree theory (full tree, complete tree, nearly complete tree and their properties)
  • binary trees, binary search trees, time and space complexity
  • 2-3-4 trees - typically gets to be part of exam 3

• W-quizzes
• Recurrences ( Solution )
• Heaps (Solution)
• Stacks, queues (Solution)
• Trees
  • Trees, BST, 2-3-4 (Solution)
  • more Trees, BST (Solution)

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.