Disclaimer. CS130A Winter 2008 Final Review. Information on the final exam. Suggestions

Size: px

Start display at page:

Download "Disclaimer. CS130A Winter 2008 Final Review. Information on the final exam. Suggestions"

Isaac Murphy
6 years ago
Views:

1 Disclaimer CS0 Winter 008 Final Review Shuo Wu Provided as is. Humanitarian purpose. Only served as a guideline/self-test for final preparation. Only a sketch/summary of important materials. You need to understand the idea and figure out the details. Neither complete nor guaranteed to be on the final. Information on the final exam bout 0% on materials before midterm. 60% on new stuff. asically everything. Questions on the project cover about 0% of the full score. The same Teo-styled questions as the midterm. Eg: T/Fs; Run algorithms on examples; Give examples; C code reading/modification Suggestions Make sure you understand the concept/definition FIRST. Partially credit given based on this criterion. Eg: If asked a -Tree deletion, at least make sure the result is a valid -Tree. Understand the key properties of data structures and the idea of algorithms. How it works. Why it works. Much easier to remember if you understand the idea. Helpful when you forget details. Try practice on examples (in the slides). t least try one for each case of an algorithm. Review the Quizzes/Homeworks/Midterm Many old questions will reappear (maybe slightly different). sk Prof./Ts/Others if you have questions.

2 Outline asics Time/Space complexity Usually worst-case analysis. verage/mortized also useful. Is an O(n) algorithm O(nlogn)? Yes. Sorted/Unsorted, rray/linked List Insert/Delete/Membership. How? Complexity? (Dictionary.) What we ve learned so far? (not complete!) Data Structures Trees(ST, R-Tree, -Tree, Tries), Hashtables, Heaps(Regular, Skew), Graphs(djacency Matrix, djacency List), Union-Find lgorithms LZW, Sorting, Trees Search/Insert/Delete, Heap Insert/Delete/ExtractMin/Meld, DFS/FS, MST, Euler Circuit Data Structures: ST inary Search Tree (ST) Key: ST is ordered Search/Insert/Delete: O(h). Depends on height. ll Top-down. Search(x): Go to left/right according to key values Insert(x): Find tree path. Insert x as a leaf node. Delete(p): If leaf, directly remove it. If internal, exchange p with left subtree s largest or right subtree s smallest. Recursive. Data Structures: R-Trees () Red-lack Tree (R-Tree) Keys: ST with colors (R/) Root is No adjacent Rs ll paths have same # of s. (=rank(root)) Worst-case Search/Insert/Delete O(logn) guaranteed. Why? len(longest path) <= *len(shortest path). h <= log(n+) Search is same as ST. Insert: O(logn) CCs + O() ations Delete: O(logn) CCs + O(logn) ations Data Structures: R-Trees () R-Tree Insertion ottom-up. Every step move current pointer up one level. First insert as a RED node as if in ST, it s a leaf. When current node () is LCK...(otherwise move up) oth children are R: Color Change (CC). CC If the Root is red after CC, change it back to LCK. One child is R(nd not a valid R-Tree yet): or Double. Double 7 rent node and two reds are on a line: ation rent node and two reds form an angle: Double ation efore and after the operation, the root of subtree is always LCK. 7

3 Data Structures: R-Trees () R-Tree Deletion Top-down. Search the node(leaf) as if in ST. Every step move current pointer down along the search path. If current node () is LCK: Transform to RED case oth children are : Color Change (CC). If the Root is red after CC, change it back to LCK. Some child is R: Go down 7 Will go to the child, the other child is R: ation CC Will go to the R child: Directly go down the search path. Data Structures: R-Trees () R-Tree Deletion If current node () is RED oth children guaranteed to be : ll grand-children are : pply Color Change (CC) to children. Some grandchild is R: Direct Double efore and after the operation, the root of subtree is always RED. CC Data Structures: -Tree () -Tree Keys: m-way Search Tree(ordered, each node at most m children) Root at least children Internal nodes at least ceil(m/) children ll leaf nodes on the same level Search/Insert/Delete: O(log d n), d = ceil(m/). Data Structures: -Tree () -Tree Insertion ottom-up adjustment. First insert to leaf node along the search path. If current node overflows: Split current node Then insert middle key to parent Move up to resolve parent Ceil(m/)

4 Data Structures: -Tree () -Tree Deletion If not leaf, exchange key to leaf as if in ST. ottom-up adjustment. Delete the key in leaf. If current node underflows, could it borrow from right/left sibling? Yes. Redistribute keys. No. Merge sibling and parent keys. Move up to resolve parent Tries Data Structures: Tries Efficient to store a set of words and fast on asking membership. Can be thought as an m-letters dictionary. m = size of alphabet. Eg. 6 for lowercase english words. Can be turned into a inary Tree. Use left-child-right-sibling representation. Data Structures: Heap Heap inary Tree/rray Representation Key (for Min-Heap): For any node v and its parent p, p->key <= v->key FindMin: O(). Insert/Delete/ExtractMin: inary Tree: O(h). rray rep: O(logn), and stores no pointers. Must be an almost complete binary tree. Insert: Put at the end of the array. ottom-up. Delete/ExtractMin: Replace the parent with the smaller child. Top-down. Data Structures: Skew Heap Skew Heaps Insert/Delete/ExtractMin implemented with Meld(x,y), which merges two skew heaps. Insert(x) = Meld(root, x) Delete/ExtractMin = Remove first. Then meld two subtrees. mortized complexity for each operation: O(logn). Meld Idea: Top-down Merge along the right path(don t remove duplicate elements) Exchange left/right child along the merging path. You can do this after the first pass of merging is complete.

5 Data Structures: Union-Find Union-Find Used to maintain equivalent classes. Union(x,y): Group x and y into one class. Initially each element is a class. N different classes in total. Find(x): Returns the representative of x s class. If x and y belongs to same class, Find(x) == Find(y) inary Tree/rray Representation. Two optimizations: For Union: Weighted Union For Find: Path compression Complexity: oth operations are O(α(m,n)). Caveats: In theory, not O()! Practically <=. Data Structures: Hashtables Hash function maps key to bucket id. h(x) in {0,,...,D-} Commonly used: h(x) = x % D. Insert/Delete/Membership: O() desired. Collision Resolution: Open ddessing Linear probing: Linearly probe the next availble bucket. How to insert/delete? Random probing: etter average Un when heavy loaded. Chaining: Change one bucket to an linked list. Universal Hashing Idea: Randomly choose hash functions from a family to improve average performance. Definition: hash family H is universal if any pair of different keys: x, y. There are H /D hash functions in H which make h(x)=h(y). In other words, randomly pick a hash function h from H, the probability of h(x)=h(y) is /D. D should be a prime number. Data Structures: Graph Graph G=(V,E) Representations: djacency Matrix djacency List Concepts: Connectedness(Undirected graph): ny pair of vertices (u,v), there exists a undirected path between them. Strongly connectedness(directed graph): ny pair of vertices (u,v), there exists a directed path from u to v. (Thus also exists one from v to u) i-connectivity: Remove one vertex(and adjacent edges), the rest is still connected. rticulation point: Vertex whose removal disconnects the graph. ipartite: ll vertices can be separated into two groups such that no egde is within one group. lgorithm: DFS/FS DFS: O(n+m), n = V, m = E Go deeper whenever possible. Use stack to store path. Do backtracking. Concepts: DFS Tree DFS Number ackedge pps: Test connectedness/strongly connectedness. Find connected components Test bipartiteness Find articulation points Find strongly connected components (in directed graph) FS: O(n+m), n = V, m = E Get current node from a queue, then put every possible move from it into the queue. pps: Find shortest path Find radius of (undirected) graph

6 lgorithm: LZW Encoding (Try: abbba) Longest Prefix Matching(eg. matched string x) in the code table. Output the code for x. dd a new entry for string xc, c is a char. Move pointer to c s position. Repeat. Decoding (Try: 0 0) Read current code, search in code table. If entry exists, with corresponding string s (complete). Output s. dd a new entry for string s_, The last char is unknown yet. If entry exists, with incomplete string s_ (must be the last entry): Complete it and output t = s_ = s+firstchar(s). dd a new entry for string t_, The last char is unknown yet. Otherwise invalid code. Move to next code. Repeat. lgorithm: Sorting Naive: O(n ) est of Comparison sorting: O(nlogn) MergeSort (stable, space O(n)) HeapSort (non-stable, space O(n)) QuickSort (non-stable, space O(n), worst time O(n )) Space can be made O(logn). How? Lower bound Omega(nlogn) proof by Decision Tree. est of Non-comparison sorting: O(n) ucketsort(use elements as indices, map them into an array. Then scan the array.) RadixSort(Sort from lowest digit. For each digit, sort all elements using bucket sort.) lgorithm: Euler Circuit Euler Circuit Start from a vertex v, travel all edges exactly once and come back to v. Euler theorem: If the degree of any vertex is even, the graph exists an EC. arnard s algorithm Euler(v) For vertex w that is adjacent to v and (v,w) is not marked»mark(v,w)» Path = (v,w) + Euler(w) + Path Return Path lgorithm: MST Minimum (Cost) Spanning Tree (MST) Definition: Spanning Tree: n vertices, n- edges, NO cycle. Minimum sum of edge costs in all spanning trees. Kruskal algorithm Idea: From an empty graph, keep adding edge with minimum cost as long as no cycle (skip edge that results in forming cycles). Use Union-Find to test if there will be cycle. Can we just mark vertices? No. Counterexample. O( E log E ) Equivalent to O( E log V ). Why?

CSci 231 Final Review

CSci 231 Final Review Here is a list of topics for the final. Generally you are responsible for anything discussed in class (except topics that appear italicized), and anything appearing on the homeworks.