•Depth: length of the alone way from root to node

•Height: length of the longest way from the node to a leaf •Keep kids in a linked list

•Preorder traverse: work at the node is done before its kids are processed •Postorder traverse: work at a node is performed after its kids are evaluated •Binary tree: no node can hold more than two kids

oAverage deepness is O ( rootN ) . O ( logN ) for binary hunt tree

oCan maintain mentions to kids cuz there’s merely 2

•Example of a binary tree: look tree

oLeaves are operands. other nodes contain operators

oInorder traverse: recursively print left kid. so parent. so right •O ( N )

oPostorder traverse: recursively print left subtree. right subtree. so operator > O ( N )

oPreorder traverse: print operator. so recursively publish the left and right subtrees

oConstructing an look tree from a postfix look: read one symbol at a clip ; if operand. make a one-node tree and push it onto a stack. If operator. dad two trees T1. T2 from stack. and organize a new tree whose root is the operator. and whose left and right kids are T2 and T1 ; push new tree onto stack •Binary hunt tree: binary tree with the belongings that for every node X. the value of all points in its left subtree are & lt ; X and the value of all points in the right subtree are & gt ; X oContains: Uses O ( logN ) stack infinite

ofindMin. findMax: crossbeam all the manner left or right from the root oinsert: track down tree as would with contains. lodge it at the terminal oremove: easy if foliage or has one kid ; if two kids ; replace informations in node with smallest informations of right subtree. and recursively cancel that node oLazy omission: if expected figure of omissions is little. merely tag the node as deleted but don’t really do anything ; little clip punishment as deepness doesn’t truly increase oRunning clip of all operations on a node is O ( deepness ) . and the mean deepness is O ( logN ) oIf input is presorted. inserts takes O ( N^2 ) since there are no left kids •AVL Trees

oBinary hunt tree with a balance status: guarantee deepness is O ( logN ) by necessitating that for every node in the tree. the tallness of the left and right subtrees can differ by at most 1 ( tallness of empty tree is -1 ) oMinimum figure of nodes S ( H ) of an AVL tree of tallness H is S ( H ) = S ( h-1 ) + S ( h-2 ) + 1 where S ( 1 ) = 2

oAll operations O ( logN ) except perchance interpolation

oRebalancing:

•Violation after infixing into left subtree of left kid. or right subtree of right kid > individual rotary motion •Violation after infixing into right subtree of left kid or left subtree of right kid > dual rotary motion •Splay Trees

oAmortized O ( logN ) cost per operation

oMove accessed nodes to root

oZig-zag: node is a left kid and its parent is a right kid or frailty versa oZig-zig: node and its parent are both left or right kids •Level-order traverse: all nodes at deepness vitamin D processed before any node at d+1 ; non done recursively. it uses a queue alternatively of stack recursion •Set interface: alone operations are insert. take. and search oTreeset maintains order. basic operations take O ( logN ) worst instance •Map interface: aggregation of entries dwelling of keys and their values O.K.s are alone. but several keys can map to the same values oSortedMap: keys maintained in sorted order

oOperations include isEmpty. clear. size. containsKey. acquire. set oNo iterator. but:

• Set keySet ( )

•Collection values ( )

•Set entrySet ( )

oFor an object of type Map. Entry. available methods include •KeyType getKey ( )

•ValueType getValue ( )

•ValueType setValue ( ValueType newValue )

•TreeSet and TreeMap implemented with a balanced binary hunt tree

Ch. 5 Hashing

•Hashing is a technique for infixing. deleting and seeking in O ( N ) norm. so findMin. findMax and publishing the tabular array in order aren’t supported •Hash map maps a key into some figure from 0 to TableSize – 1 and topographic points it in the appropriate cell •If the input keys are whole numbers. so normally Key ( mod TableSize ) works •Want to hold TableSize be premier

•Separate chaining: keep a list of all elements that hash to the same value •Load factor = mean length of a list = figure of elements in table/size oIn an unsuccessful hunt. figure of nodes to analyze is O ( burden ) on norm ; successful hunt requires ~ 1 + ( load/2 ) links to be traversed •Instead of holding linked lists. usage H ( x ) = ( hash ( x ) + degree Fahrenheit ( I ) ) ( mod Tablesize ) where degree Fahrenheit is the hit declaration scheme oGenerally. maintain burden below. 5 for these “probing hash tables” oLinear examining: degree Fahrenheit ( I ) = I ; try cells consecutive with wraparound •Primary bunch: even if tabular array is comparatively empty. blocks of occupied cells signifier which makes hashes near them bad oQuadratic probing ; f ( I ) = i^2

•No warrant of happening an empty cell if tabular array is & gt ; ? full ( or before if size isn’t prime ) •Secondary bunch: elements hashed to same place investigation same alternate cells oDouble Hashing: degree Fahrenheit ( I ) = ihash_2 ( x ) so probe hash_2 ( x ) . 2hash_2 ( ten ) . … •Hash_2 ( x ) = R – x ( mod R ) with R premier & lt ; size is good

oRehash: construct new tabular array. twice every bit large. hash everything with new map •O ( N ) : N elements to rehash. table size about 2N. but really non that bad because it’s infrequent ( must hold been N/2 ) interpolations prior to last rehash. so it basically adds a changeless cost to infix •Can rehash when half full. after failed interpolation. or at certain burden •Standard Library has HashSet and HashMap ( they use separate chaining ) •HashTable utile for:

o1. Graph theory job where nodes have names alternatively of Numberss o2. Symbol tabular array: maintaining path of declared variables in beginning codification o3.

Plans that play games

o4. Online enchantment draughtss

•But they require an estimation of the figure of elements to be used

Ch. 7 Screening

•Bubble kind: O ( N^2 ) but O ( N ) if presorted

•Insertion kind: P base on ballss. at each base on balls move component P left until in right topographic point oO ( N^2 ) norm. O ( N ) on presorted

•Shellsort: increment sequence h1. h2. … . h_t

oAfter a stage. all elements spaced h_k apart are sorted

oWorst-case O ( N^2 )

oHibbard’s sequence 1. 3. 7. … . 2^k – 1 gives worst-case O ( N^3/2 ) •Heapsort: construct a minHeap in O ( N ) . deleteMin N times so O ( NlogN ) for all instances oUses an excess array so O ( N ) infinite

•Mergesort: O ( NlogN ) worst instance. but uses O ( N ) extra space/memory •Quicksort: usage median of left/right/center elements. kind elements smaller and larger than pivot. so unify oPartitioning scheme: move I right. skip over elements smaller than pivot. travel J left. skip over elements larger than pivot oWorst-case pivot is little component = O ( N^2 ) . happens on near-sorted informations oBest-case pivot is in-between = O ( NlogN )

oAverage-case O ( NlogN )

Ch. 8 The Disjoint Set Class

•The equality job is to look into for any a. B if a~b

•Find: returns the name of the equality category incorporating a given component •Add a relation a~b: perform find on a. B so brotherhood the categories •Impossible to make both operations in changeless worst-case. but can make either •Quick-find: array entry of node is name of its category ; makes brotherhood O ( N ) •We start with a wood of singleton trees ; the array representation contains the name of the parent. with -1 for no parent oUnion: merge two trees by doing the parent nexus of one tree’s root nexus to the root of the other tree. O ( 1 ) oFind is relative to depth of the node so worst-case is O ( N ) . or O ( manganese ) for m back-to-back operations oAverage instance depends on the theoretical account but is by and large O ( manganese )

•Union-by-size: do the smaller tree a subtree of the larger. interrupt ties any manner oDepth of a node is ne’er more than logN > discovery is O ( logN ) oHave the array entry of each root contain the negative of the size of its tree. so ab initio all -1. After a brotherhood. the new size is the amount of the old •Requires no excess infinite

oMost theoretical accounts show M operations is O ( M ) norm clip

•Union-by-height: maintain height alternatively of size of tree. and during brotherhoods make the shoal tree a subtree of the deeper one oAlso guarantees depth = O ( logN )

oEasy: tallness merely goes up ( by 1 ) when every bit deep trees are unioned oStore the negative of the tallness. minus an extra 1 ( once more start at -1 ) •Problem: worst instance O ( MlogN ) occurs often ; if there are many more discoveries than brotherhoods the running clip is worse than the quick-find algorithm •Path Compaction

oAfter discovery ( ten ) . every node on the way from ten to root has its parent changed to the root oM operations requires at most O ( MlogN ) clip ; unknown mean oNot compatible with brotherhood by tallness since it changes highs •When we use both union-by-size and path compaction. about additive worst instance oTheta ( M*Ackerman’s map ) . where Ackerman’s is merely somewhat faster than changeless. so it’s non rather additive oBook proves any M union/find operations is O ( Mlog*N ) where log*N = figure of times needed to use log to N until N