IX: {Selection problem!inefficient algorithms for|(}     	{2}
IX: {Selection problem!inefficient algorithms for|)}     	{2}
IX: {Exponents!formulas for|(}       	{3}
IX: {Exponents!formulas for|)}       	{3}
IX: {Logarithms!formulas for|(}       	{3}
IX: {Logarithms!formulas for|)}       	{4}
IX: {Series|(}        	{4}
IX: {Series!geometric|(}        	{4}
IX: {Series!geometric|)}        	{4}
IX: {Series!arithmetic|(}        	{4}
IX: {Series!arithmetic|)}        	{5}
IX: {Series!sum of \x'0'\f2\s11k\v'-44u'\s-3€th\s+3€\v'44u'\s11\f(01 power}     	{5}
IX: {Series!harmonic|(}        	{5}
IX: {Euler's constant}       	{5}
IX: {Series!harmonic|)}        	{5}
IX: {Series|)}        	{5}
IX: {Modular arithmetic|(}       	{5}
IX: {Modular arithmetic|)}       	{5}
IX: {Proofs!by induction|(}       	{5}
IX: {Fibonacci numbers!properties of|(}      	{6}
IX: {Fibonacci numbers!properties of|)}      	{6}
IX: {Proofs!by induction|)}       	{6}
IX: {Proofs!by contradiction|(}       	{7}
IX: {Proofs!by contradiction|)}       	{7}
IX: {Recursion!principles of|(}       	{7}
IX: {Recursion!printing out numbers|(}      	{9}
IX: {Recursion!printing out numbers|)}      	{10}
IX: {Recursion!four basic rules|(}      	{10}
IX: {Recursion!four basic rules|)}      	{10}
IX: {Recursion!principles of|)}       	{10}
IX: {Fibonacci numbers!properties of|(}      	{11}
IX: {Fibonacci numbers!properties of|)}      	{11}
IX: {Hutchinson, J. P.}      	{12}
IX: {Albertson, M. O.}      	{12}
IX: {Bavel, Z.}       	{12}
IX: {Brualdi, R. A.}      	{12}
IX: {Burge, W. H.}      	{12}
IX: {Dijkstra, E. W.}      	{12}
IX: {Patashnik, O.}       	{12}
IX: {Knuth, D. E.}      	{12}
IX: {Graham, R. L.}      	{12}
IX: {Gries, D.}       	{12}
IX: {Veroff, R.}       	{12}
IX: {Helman, P.}       	{12}
IX: {Wirth, N.}       	{12}
IX: {Jensen, K.}       	{12}
IX: {Plauger, P. J.}      	{12}
IX: {Kernighan, B. W.}      	{12}
IX: {Knuth, D. E.}      	{12}
IX: {Koffman, E. B.}      	{12}
IX: {Roberts, E.}       	{12}
IX: {Roberts, F. S.}      	{12}
IX: {Tucker, A.}       	{12}
IX: {Analysis of algorithms|(}      	{13}
IX: {Growth rate!of functions|(}      	{14}
IX: {Big-Oh notation|(}       	{14}
IX: {Big-Omega notation|(}       	{14}
IX: {Little-Oh notation|(}       	{14}
IX: {Theta notation|(}       	{14}
IX: {Big-Oh notation|)}       	{16}
IX: {Big-Omega notation|)}       	{16}
IX: {Little-Oh notation|)}       	{16}
IX: {Theta notation|)}       	{16}
IX: {Growth rate!of functions|)}      	{16}
IX: {Maximum subsequence sum problem|(}     	{17}
IX: {Maximum subsequence sum problem|)}     	{17}
IX: {Analysis of algorithms!basic rules|(}     	{17}
IX: {Analysis of algorithms!basic rules|)}     	{20}
IX: {Analysis of algorithms!recursive procedures|(}     	{20}
IX: {Fibonacci numbers!bad use of recursion|(}    	{20}
IX: {Fibonacci numbers!bad use of recursion|)}    	{21}
IX: {Analysis of algorithms!recursive procedures|)}     	{21}
IX: {Maximum subsequence sum problem|(}     	{21}
IX: {Analysis of algorithms!recursive procedures|(}     	{23}
IX: {Divide and conquer|(}      	{23}
IX: {Divide and conquer!maximum subsequence sum|(}    	{23}
IX: {Recursion|see also divide and conquer}    	{23}
IX: {GCD|see Euclid's algorithm}      	{23}
IX: {Analysis of algorithms!recursive procedures|)}     	{26}
IX: {Divide and conquer|)}      	{26}
IX: {Divide and conquer!maximum subsequence sum|)}    	{26}
IX: {Maximum subsequence sum problem|)}     	{27}
IX: {On-line algorithms!maximum subsequence sum problem}    	{27}
IX: {Logarithms!in running time|(}      	{27}
IX: {Analysis of algorithms!logarithmic running times|(}    	{27}
IX: {Binary search|(}       	{27}
IX: {Binary search|)}       	{27}
IX: {Euclid's algorithm|(}       	{28}
IX: {Euclid's algorithm|)}       	{29}
IX: {Recursion!exponentiation|(}        	{29}
IX: {Exponentiation|(}        	{29}
IX: {Exponentiation|)}        	{30}
IX: {Recursion!exponentiation|)}        	{30}
IX: {Logarithms!in running time|)}      	{30}
IX: {Analysis of algorithms!logarithmic running times|)}    	{30}
IX: {Analysis of algorithms!empirical confirmation|(}     	{30}
IX: {Analysis of algorithms!empirical confirmation|)}     	{32}
IX: {Shellsort}        	{32}
IX: {Disjoint sets}       	{32}
IX: {Analysis of algorithms!lower bound proofs}    	{32}
IX: {Cryptography|(}        	{32}
IX: {Cryptography|)}        	{32}
IX: {Random permutation generator|(}      	{33}
IX: {Random permutation generator|)}      	{34}
IX: {Horner's rule|(}       	{34}
IX: {Horner's rule|)}       	{34}
IX: {Primality test|(}       	{34}
IX: {Primality test|)}       	{35}
IX: {Majority problem|(}       	{35}
IX: {Majority problem|)}       	{35}
IX: {Binary search|(}       	{36}
IX: {Binary search|)}       	{36}
IX: {Maximum subsequence sum problem|(}     	{36}
IX: {Divide and conquer!maximum subsequence sum|(}    	{36}
IX: {Divide and conquer|(}      	{36}
IX: {Maximum subsequence sum problem|)}     	{36}
IX: {Divide and conquer!maximum subsequence sum|)}    	{36}
IX: {Divide and conquer|)}      	{36}
IX: {Ullman, J. D.}      	{36}
IX: {Hopcroft, J. E.}      	{36}
IX: {Aho, A. V.}      	{36}
IX: {Bentley, J. L.}      	{36}
IX: {Bentley, J. L.}      	{36}
IX: {Bentley, J. L.}      	{36}
IX: {Knuth, D. E.}      	{36}
IX: {Knuth, D. E.}      	{36}
IX: {Knuth, D. E.}      	{36}
IX: {Knuth, D. E.}      	{36}
IX: {Analysis of algorithms|)}      	{36}
IX: {Abstract data type|(}      	{38}
IX: {Modularity|(}        	{38}
IX: {Modularity|)}        	{38}
IX: {Abstract data type|)}      	{38}
IX: {List|see also linked list}     	{38}
IX: {Linked list|(}       	{38}
IX: {Lists!array implementation|(}       	{39}
IX: {Lists!array implementation|)}       	{39}
IX: {Linked list!implementation of|(}      	{39}
IX: {Linked list!header cell|(}      	{40}
IX: {Short-circuit operation|(}       	{42}
IX: {Short-circuit operation|)}       	{42}
IX: {Linked list!header cell|)}      	{46}
IX: {Linked list!common errors|(}      	{46}
IX: {Linked list!common errors|)}      	{46}
IX: {Linked list!implementation of|)}      	{46}
IX: {Linked list!doubly linked list|(}     	{46}
IX: {Linked list!doubly linked list|)}     	{47}
IX: {Linked list!circularly linked list|(}     	{47}
IX: {Linked list!circularly linked list|)}     	{47}
IX: {Linked list!for polynomial arithmetic|(}     	{48}
IX: {Polynomial ADT|(}       	{48}
IX: {Linked list!for polynomial arithmetic|)}     	{49}
IX: {Radix sort|(}       	{49}
IX: {Bucket sort|(}       	{49}
IX: {Sorting!bucket sort|(}       	{49}
IX: {Sorting!radix sort|(}       	{49}
IX: {Radix sort|)}       	{51}
IX: {Bucket sort|)}       	{51}
IX: {Sorting!bucket sort|)}       	{51}
IX: {Sorting!radix sort|)}       	{51}
IX: {Polynomial ADT|)}       	{51}
IX: {Linked list!multi-list|(}       	{51}
IX: {Linked list!circularly linked list|(}     	{51}
IX: {Linked list!multi-list|)}       	{52}
IX: {Linked list!circularly linked list|)}     	{52}
IX: {Linked list!cursor implementation|(}      	{52}
IX: {Linked list!cursor implementation|)}      	{56}
IX: {Linked list|)}       	{56}
IX: {Stack|(}        	{56}
IX: {Stack!fundamental operations|(}       	{56}
IX: {Stack!fundamental operations|)}       	{56}
IX: {Stack!list implementation|(}       	{57}
IX: {Linked list|(}       	{57}
IX: {Linked list!implementation of a stack|(}    	{57}
IX: {Stack!list implementation|)}       	{58}
IX: {Linked list|)}       	{58}
IX: {Linked list!implementation of a stack|)}    	{58}
IX: {Stack!array implementation|(}       	{58}
IX: {Stack!array implementation|)}       	{62}
IX: {Stack!balancing parenthesis|(}       	{63}
IX: {On-line algorithms!symbol balancing|(}      	{63}
IX: {Stack!balancing parenthesis|)}       	{63}
IX: {On-line algorithms!symbol balancing|)}      	{63}
IX: {Postfix expression|(}       	{63}
IX: {Postfix expression!evaluation of|(}      	{63}
IX: {Postfix expression!evaluation of|)}      	{65}
IX: {Infix to postfix conversion|(}     	{65}
IX: {Infix expression|(}       	{65}
IX: {Infix expression|)}       	{65}
IX: {Infix to postfix conversion|)}     	{67}
IX: {Postfix expression|)}       	{67}
IX: {Stack!and recursion|(}       	{67}
IX: {Activation record|(}       	{68}
IX: {Stack frame|(}       	{68}
IX: {Tail recursion|(}       	{68}
IX: {Recursion!tail recursion|(}       	{68}
IX: {Recursion!bad uses|(}       	{68}
IX: {Tail recursion|)}       	{69}
IX: {Recursion!tail recursion|)}       	{69}
IX: {Activation record|)}       	{69}
IX: {Stack frame|)}       	{69}
IX: {Stack!and recursion|)}       	{69}
IX: {Recursion!bad uses|)}       	{69}
IX: {Stack|)}        	{69}
IX: {Queue|(}        	{69}
IX: {Queue!basic operations|(}       	{69}
IX: {Queue!basic operations|)}       	{69}
IX: {Queue!array implementation of|(}      	{70}
IX: {Queue!array implementation of|)}      	{71}
IX: {Queue!line printer|(}       	{72}
IX: {Queue!line printer|)}       	{72}
IX: {Queueing theory|(}       	{72}
IX: {Simulation|(}        	{72}
IX: {Queueing theory|)}       	{73}
IX: {Simulation|)}        	{73}
IX: {Queue|)}        	{73}
IX: {Josephus problem|(}       	{74}
IX: {Josephus problem|)}       	{75}
IX: {Self adjusting data structure!list|(}     	{75}
IX: {Self adjusting data structure!list|)}     	{75}
IX: {Lazy deletion!linked lists|(}      	{76}
IX: {Lazy deletion!linked lists|)}      	{76}
IX: {Queue|(}        	{76}
IX: {Queue!double-ended|(}        	{76}
IX: {Deque|see queue(double-ended)}       	{76}
IX: {Queue!double-ended|)}        	{76}
IX: {Queue|)}        	{76}
IX: {Tree|(}        	{77}
IX: {Recursion!trees|(}        	{77}
IX: {Binary search tree|(}      	{78}
IX: {Tree!definitions|(}        	{78}
IX: {Tree!definitions|)}        	{79}
IX: {Tree!left child/right sibling implementation|(}     	{79}
IX: {Tree!left child/right sibling implementation|)}     	{79}
IX: {File system|(}       	{79}
IX: {Tree!traversals|(}        	{79}
IX: {Preorder traversal|(}       	{80}
IX: {Preorder traversal|)}       	{81}
IX: {Postorder traversal|(}       	{81}
IX: {Postorder traversal|)}       	{82}
IX: {Tree!traversals|)}        	{82}
IX: {File system|)}       	{82}
IX: {Tree!binary tree|(}       	{82}
IX: {Expression tree|(}       	{85}
IX: {Tree!traversals|(}        	{85}
IX: {Inorder traversal|(}       	{85}
IX: {Postorder traversal|(}       	{85}
IX: {Infix expression|(}       	{85}
IX: {Postfix expression|(}       	{85}
IX: {Prefix form|(}       	{85}
IX: {Preorder traversal|(}       	{85}
IX: {Prefix form|)}       	{85}
IX: {Preorder traversal|)}       	{85}
IX: {Expression tree|)}       	{87}
IX: {Tree!binary tree|)}       	{87}
IX: {Inorder traversal|)}       	{87}
IX: {Infix expression|)}       	{87}
IX: {Postorder traversal|)}       	{87}
IX: {Postfix expression|)}       	{87}
IX: {Tree!binary search tree|(}      	{87}
IX: {Tree!traversals|)}        	{87}
IX: {Binary search tree!basic operations|(}     	{88}
IX: {Binary search tree!basic operations|)}     	{91}
IX: {Binary search tree!deletion|(}      	{91}
IX: {Lazy deletion!binary search trees|(}     	{91}
IX: {Binary search tree!deletion|)}      	{93}
IX: {Lazy deletion!binary search trees|)}     	{93}
IX: {Analysis of algorithms|(}      	{93}
IX: {Analysis of algorithms!average case analysis|(}    	{93}
IX: {Binary search tree!average running time|(}    	{93}
IX: {Binary search tree!average running time|)}    	{96}
IX: {Analysis of algorithms|)}      	{96}
IX: {Analysis of algorithms!average case analysis|)}    	{96}
IX: {Tree!AVL tree|(}       	{96}
IX: {AVL tree|(}       	{96}
IX: {AVL tree!properties|(}       	{96}
IX: {AVL tree!properties|)}       	{97}
IX: {AVL tree!insertion|(}       	{97}
IX: {AVL tree!single rotation|(}      	{97}
IX: {AVL tree!single rotation|)}      	{100}
IX: {AVL tree!double rotation|(}      	{100}
IX: {AVL tree!double rotation|)}      	{104}
IX: {AVL tree!insertion|)}       	{105}
IX: {AVL tree!deletion|(}       	{105}
IX: {Lazy deletion!AVL tree|(}      	{105}
IX: {AVL tree!deletion|)}       	{105}
IX: {Lazy deletion!AVL tree|)}      	{105}
IX: {AVL tree|)}       	{105}
IX: {Tree!AVL tree|)}       	{105}
IX: {Tree!splay tree|(}       	{105}
IX: {Splay tree|(}       	{105}
IX: {Splay tree!self adjustment|(}      	{105}
IX: {Self adjusting data structure!splay tree|(}    	{105}
IX: {Self adjusting data structure!move to root heuristic|(}  	{105}
IX: {Amortized analysis|(}       	{105}
IX: {Amortized analysis|)}       	{108}
IX: {Self adjusting data structure!move to root heuristic|)}  	{110}
IX: {Splay tree!splay steps!zig|(}      	{110}
IX: {Splay tree!splay steps!zig-zag|(}      	{110}
IX: {Splay tree!splay steps!zig-zig|(}      	{110}
IX: {Splay tree!self adjustment|)}      	{116}
IX: {Splay tree!splay steps!zig|)}      	{116}
IX: {Splay tree!splay steps!zig-zig|)}      	{116}
IX: {Splay tree!splay steps!zig-zag|)}      	{116}
IX: {Splay tree!splay steps!implementation of|(}     	{116}
IX: {Splay tree!splay steps!implementation of|)}     	{117}
IX: {Splay tree!deletion|(}       	{117}
IX: {Splay tree!deletion|)}       	{118}
IX: {Splay tree!analysis of|(}      	{118}
IX: {Splay tree!analysis of|)}      	{118}
IX: {Tree!splay tree|)}       	{118}
IX: {Self adjusting data structure!splay tree|)}    	{118}
IX: {Splay tree|)}       	{118}
IX: {Tree!binary search tree|)}      	{118}
IX: {Binary search tree|)}      	{118}
IX: {Tree!traversals|(}        	{118}
IX: {Inorder traversal|(}       	{118}
IX: {Inorder traversal|)}       	{120}
IX: {Postorder traversal|(}       	{120}
IX: {Postorder traversal|)}       	{120}
IX: {Preorder traversal|(}       	{120}
IX: {Preorder traversal|)}       	{120}
IX: {Level-order traversal|(}       	{120}
IX: {Queue}        	{120}
IX: {Level-order traversal|)}       	{120}
IX: {Tree!traversals|)}        	{120}
IX: {B-tree|(}        	{120}
IX: {Tree!B-tree|(}        	{120}
IX: {two-three tree@2-3 tree|(}      	{121}
IX: {Tree!2-3 tree|(}       	{121}
IX: {Tree!B-tree|)}        	{125}
IX: {B-tree|)}        	{125}
IX: {Tree!2-3 tree|)}       	{125}
IX: {two-three tree@2-3 tree|)}      	{125}
IX: {Sorting!tree sort|(}       	{126}
IX: {Sorting!tree sort|)}       	{126}
IX: {Tree!B*-tree|(}        	{130}
IX: {Tree!B*-tree|)}        	{130}
IX: {Selection problem!in a binary search tree}   	{131}
IX: {Tree!threaded|(}        	{131}
IX: {Tree!threaded|)}        	{131}
IX: {Binary search tree!k-d tree|(}     	{131}
IX: {Tree!k-d tree|(}       	{131}
IX: {K-d tree|(}       	{131}
IX: {Computational geometry!k-d tree|(}      	{131}
IX: {Binary search tree!k-d tree|)}     	{131}
IX: {Tree!k-d tree|)}       	{131}
IX: {K-d tree|)}       	{131}
IX: {Computational geometry!k-d tree|)}      	{131}
IX: {Tree!red black}       	{132}
IX: {Tree!weight-balanced}        	{132}
IX: {Landis, E. M.}      	{133}
IX: {Adelson-Velskii, G. M.}      	{133}
IX: {Ullman, J. D.}      	{133}
IX: {Hopcroft, J. E.}      	{133}
IX: {Aho, A. V.}      	{133}
IX: {Munro, J. I.}      	{133}
IX: {Allen, B.}       	{133}
IX: {Baeza-Yates, R. A.}      	{133}
IX: {Baeza-Yates, R. A.}      	{133}
IX: {McGreight, E. M.}      	{133}
IX: {Bayer, R.}       	{133}
IX: {Bentley, J. L.}      	{133}
IX: {Bentley, J. L.}      	{133}
IX: {Friedman, J. H.}      	{133}
IX: {Bitner, J. R.}      	{133}
IX: {Comer, D.}       	{133}
IX: {Munro, J. I.}      	{133}
IX: {Culberson, J.}       	{133}
IX: {Munro, J. I.}      	{133}
IX: {Culberson, J.}       	{133}
IX: {Wood, D.}       	{133}
IX: {Ottman, T.}       	{133}
IX: {Culik, K.}       	{133}
IX: {Wood, D.}       	{133}
IX: {Melhorn, K.}       	{133}
IX: {Gonnet, G. H.}      	{133}
IX: {Ziviana, N.}       	{133}
IX: {Eisenbath, B.}       	{133}
IX: {Eppinger, J. L.}      	{133}
IX: {Odlyzko, A.}       	{133}
IX: {Flajolet, P.}       	{133}
IX: {Gonnet, G. H.}      	{133}
IX: {Tsur, S.}       	{133}
IX: {Gudes, E.}       	{133}
IX: {Sedgewick, R.}       	{133}
IX: {Guibas, L. J.}      	{133}
IX: {Hibbard, T. H.}      	{133}
IX: {Knuth, D. E.}      	{133}
IX: {Jonassen, A. T.}      	{133}
IX: {Kaehler, E. B.}      	{134}
IX: {Scroggs, R. E.}      	{134}
IX: {Fuller, S. H.}      	{134}
IX: {Karlton, P. L.}      	{134}
IX: {Knuth, D. E.}      	{134}
IX: {Knuth, D. E.}      	{134}
IX: {Melhorn, K.}       	{134}
IX: {Melhorn, K.}       	{134}
IX: {Reingold, E. M.}      	{134}
IX: {Nievergelt, J.}       	{134}
IX: {Thornton, C.}       	{134}
IX: {Perlis, A. J.}      	{134}
IX: {Tarjan, R. E.}      	{134}
IX: {Sleator, D. D.}      	{134}
IX: {Thurston, W. P.}      	{134}
IX: {Tarjan, R. E.}      	{134}
IX: {Sleator, D. D.}      	{134}
IX: {Smith, H. F.}      	{134}
IX: {Tarjan, R. E.}      	{134}
IX: {Yao, A. C.}      	{134}
IX: {Tree|)}        	{134}
IX: {Recursion!trees|)}        	{134}
IX: {Hash table|see hashing}      	{135}
IX: {Hashing|(}        	{135}
IX: {Hashing!table size|(}       	{136}
IX: {Hashing!table size|)}       	{137}
IX: {Hashing!hash function|(}       	{137}
IX: {Hashing!table size}       	{137}
IX: {Hashing!hash function|)}       	{139}
IX: {Hashing!collision resolution|(}       	{139}
IX: {Collision resolution|see hashing}      	{139}
IX: {Hashing!collision resolution|)}       	{139}
IX: {Hashing!open hashing|(}       	{139}
IX: {Load factor|see hashing}      	{141}
IX: {Hashing!load factor|(}       	{141}
IX: {Hashing!table size|(}       	{142}
IX: {Hashing!load factor|)}       	{142}
IX: {Hashing!table size|)}       	{142}
IX: {Hashing!open hashing|)}       	{142}
IX: {Hashing!closed hashing|(}       	{142}
IX: {Hashing!load factor}       	{142}
IX: {Hashing!table size|(}       	{142}
IX: {Hashing!table size|)}       	{142}
IX: {Hashing!linear probing|(}       	{142}
IX: {Clustering|(}        	{142}
IX: {Hashing!closed hashing!clustering|(}       	{142}
IX: {Hashing!closed hashing!analysis of|(}      	{142}
IX: {Clustering!primary|(}        	{142}
IX: {Hashing!linear probing|)}       	{144}
IX: {Hashing!closed hashing!analysis of|)}      	{144}
IX: {Hashing!quadratic probing|(}       	{144}
IX: {Clustering!primary|)}        	{144}
IX: {Hashing!table size|(}       	{144}
IX: {Modular arithmetic|(}       	{144}
IX: {Hashing!table size|)}       	{145}
IX: {Modular arithmetic|)}       	{145}
IX: {Lazy deletion!closed hash table|(}     	{145}
IX: {Hashing!closed hashing!deletion|(}       	{145}
IX: {Lazy deletion!closed hash table|)}     	{145}
IX: {Hashing!closed hashing!deletion|)}       	{145}
IX: {Clustering!secondary|(}        	{146}
IX: {Clustering!secondary|)}        	{147}
IX: {Clustering|)}        	{147}
IX: {Hashing!closed hashing!clustering|)}       	{147}
IX: {Hashing!quadratic probing|)}       	{147}
IX: {Hashing!double hashing|(}       	{147}
IX: {Hashing!double hashing|)}       	{148}
IX: {Rehashing|see hashing}       	{148}
IX: {Hashing!rehashing|(}        	{148}
IX: {Queue}        	{150}
IX: {Hashing!rehashing|)}        	{150}
IX: {Hashing!closed hashing|)}       	{150}
IX: {Extendible hashing|(}       	{150}
IX: {Hashing!extendible hashing|(}       	{150}
IX: {B-tree|(}        	{150}
IX: {B-tree|)}        	{150}
IX: {Extendible hashing!performance of|(}      	{151}
IX: {Extendible hashing!performance of|)}      	{152}
IX: {Extendible hashing|)}       	{152}
IX: {Hashing!extendible hashing|)}       	{152}
IX: {Binary search tree|(}      	{152}
IX: {Binary search tree!comparison to hash table|(}   	{152}
IX: {Hashing!comparison to binary search tree|(}    	{152}
IX: {Symbol table|(}       	{153}
IX: {Symbol table|)}       	{153}
IX: {Transposition table|(}       	{153}
IX: {Transposition table|)}       	{153}
IX: {Spelling checker|(}       	{153}
IX: {Spelling checker|)}       	{153}
IX: {Binary search tree|)}      	{153}
IX: {Binary search tree!comparison to hash table|)}   	{153}
IX: {Hashing!comparison to binary search tree|)}    	{153}
IX: {Hashing!random collision resolution|(}      	{154}
IX: {Hashing!random collision resolution|)}      	{154}
IX: {Spelling checker|(}       	{154}
IX: {Spelling checker|)}       	{154}
IX: {Pattern matching|(}       	{154}
IX: {Pattern matching|)}       	{155}
IX: {Moore, J. S.}      	{156}
IX: {Boyer, R. S.}      	{156}
IX: {Wegman, M. N.}      	{156}
IX: {Carter, J. L.}      	{156}
IX: {Melhorn, K.}       	{156}
IX: {Karlin, A. R.}      	{156}
IX: {Dietzfelbinger, M.}       	{156}
IX: {Du, H. C.}      	{156}
IX: {Enbody, R. J.}      	{156}
IX: {Strong, H. R.}      	{156}
IX: {Pippenger, N.}       	{156}
IX: {Nievergelt, J.}       	{156}
IX: {Fagin, R.}       	{156}
IX: {Flajolet, P.}       	{156}
IX: {Szemeredi, E.}       	{156}
IX: {Komlos, J.}       	{156}
IX: {Fredman, M. L.}      	{156}
IX: {Szemeredi, E.}       	{156}
IX: {Guibas, L. J.}      	{156}
IX: {Rabin, M. O.}      	{156}
IX: {Karp, R. M.}      	{156}
IX: {Knuth, D. E.}      	{156}
IX: {Pratt, V. R.}      	{156}
IX: {Morris, J. H.}      	{156}
IX: {Knuth, D. E.}      	{156}
IX: {Molodowitch, M.}       	{156}
IX: {Lueker, G.}       	{156}
IX: {Lewis, T. G.}      	{156}
IX: {Maurer, W. D.}      	{156}
IX: {Bell, T.}       	{156}
IX: {Harries, R.}       	{156}
IX: {McKenzie, B. J.}      	{156}
IX: {Morris, R.}       	{156}
IX: {Peterson, W. W.}      	{156}
IX: {Vitter, J. S.}      	{156}
IX: {Yao, A. C.}      	{157}
IX: {Yao, A. C.}      	{157}
IX: {Hashing|)}        	{157}
IX: {Heap|see priority queue}      	{158}
IX: {Priority queue|(}       	{158}
IX: {Priority queue!basic operations|(}      	{158}
IX: {Line printer queue|(}      	{159}
IX: {Line printer queue|)}      	{159}
IX: {Scheduler!operating system|(}       	{159}
IX: {Scheduler!operating system|)}       	{159}
IX: {Line printer queue|)}      	{159}
IX: {Priority queue!basic operations|)}      	{159}
IX: {Priority queue!simple implementations|(}      	{160}
IX: {Priority queue!simple implementations|)}      	{160}
IX: {Priority queue!binary heap|(}      	{160}
IX: {Binary heap|(}       	{160}
IX: {Binary heap!structure|(}       	{160}
IX: {Tree|(}        	{160}
IX: {Tree!complete binary tree|(}      	{160}
IX: {Tree|)}        	{161}
IX: {Tree!complete binary tree|)}      	{161}
IX: {Binary heap!structure|)}       	{161}
IX: {Binary heap!heap order|(}      	{161}
IX: {Heap order property|(}      	{161}
IX: {Binary heap!heap order|)}      	{161}
IX: {Heap order property|)}      	{161}
IX: {Binary heap!insertion|(}       	{162}
IX: {Sentinel|(}        	{163}
IX: {Sentinel|)}        	{163}
IX: {Binary heap!insertion|)}       	{164}
IX: {Binary heap!delete_min operation|(}      	{164}
IX: {Binary heap!delete_min operation|)}      	{165}
IX: {Binary heap!miscellaneous operations|(}      	{165}
IX: {Binary heap!miscellaneous operations|)}      	{167}
IX: {Binary heap!linear-time construction|(}      	{167}
IX: {Binary heap!linear-time construction|)}      	{169}
IX: {Binary heap|)}       	{169}
IX: {Priority queue!binary heap|)}      	{169}
IX: {Selection problem!priority queue solution|(}     	{170}
IX: {Selection problem!priority queue solution|)}     	{171}
IX: {Priority queue!simulation|(}       	{171}
IX: {Simulation|(}        	{171}
IX: {Queue|(}        	{172}
IX: {Queue|)}        	{172}
IX: {Priority queue!simulation|)}       	{172}
IX: {Simulation|)}        	{172}
IX: {Priority queue!d-heap|(}       	{172}
IX: {d-heap|(}        	{172}
IX: {Priority queue!d-heap|)}       	{172}
IX: {d-heap|)}        	{172}
IX: {Recursion!leftist heap|(}       	{172}
IX: {Priority queue!leftist heap|(}      	{173}
IX: {Leftist heap|(}       	{173}
IX: {Leftist heap!structure|(}       	{173}
IX: {Leftist heap!structure|)}       	{174}
IX: {Leftist heap!merging|(}       	{174}
IX: {Leftist heap!implementation of|(}      	{175}
IX: {Leftist heap!implementation of|)}      	{176}
IX: {Leftist heap!merging|)}       	{177}
IX: {Leftist heap!insertion|(}       	{177}
IX: {Leftist heap!delete_min operation|(}      	{177}
IX: {Leftist heap!insertion|)}       	{178}
IX: {Leftist heap!delete_min operation|)}      	{178}
IX: {Leftist heap|)}       	{178}
IX: {Priority queue!leftist heap|)}      	{178}
IX: {Recursion!leftist heap|)}       	{178}
IX: {Skew heap|(}       	{179}
IX: {Recursion!skew heap|(}       	{179}
IX: {Priority queue!skew heap|(}      	{179}
IX: {Self adjusting data structure!skew heap|(}    	{179}
IX: {Amortized analysis|(}       	{179}
IX: {Amortized analysis|)}       	{179}
IX: {Skew heap|)}       	{181}
IX: {Priority queue!skew heap|)}      	{181}
IX: {Self adjusting data structure!skew heap|)}    	{181}
IX: {Recursion!skew heap|)}       	{181}
IX: {Binomial queue|(}       	{181}
IX: {Priority queue!binomial queue|(}      	{181}
IX: {Binomial tree|(}       	{181}
IX: {Binomial queue!structure|(}       	{181}
IX: {Binomial tree|)}       	{181}
IX: {Binomial queue!structure|)}       	{181}
IX: {Binomial queue!merging|(}       	{181}
IX: {Binomial queue!insertion|(}       	{182}
IX: {Binomial queue!merging|)}       	{184}
IX: {Binomial queue!insertion|)}       	{185}
IX: {Binomial queue!delete_min operation|(}      	{185}
IX: {Binomial queue!delete_min operation|)}      	{187}
IX: {Binomial queue!implementation of|(}      	{187}
IX: {Tree|(}        	{187}
IX: {Tree!left child/right sibling implementation|(}     	{187}
IX: {Linked list|(}       	{187}
IX: {Linked list!circularly linked list|(}     	{187}
IX: {Linked list!doubly linked list|(}     	{187}
IX: {Tree|)}        	{187}
IX: {Tree!left child/right sibling implementation|)}     	{187}
IX: {Linked list|)}       	{187}
IX: {Linked list!circularly linked list|)}     	{187}
IX: {Linked list!doubly linked list|)}     	{187}
IX: {Binomial queue!miscellaneous operations|(}      	{188}
IX: {Binomial queue!implementation of|)}      	{189}
IX: {Binomial queue!miscellaneous operations|)}      	{189}
IX: {Binomial queue|)}       	{189}
IX: {Priority queue!binomial queue|)}      	{189}
IX: {Lazy deletion!leftist heap|(}      	{192}
IX: {Lazy deletion!leftist heap|)}      	{192}
IX: {Bin packing|(}       	{193}
IX: {Bin packing|)}       	{193}
IX: {Priority queue!min-max heap|(}      	{193}
IX: {Priority queue!min-max heap|)}      	{194}
IX: {Priority queue!deap|(}       	{194}
IX: {Priority queue!deap|)}       	{194}
IX: {Strothotte, T.}       	{195}
IX: {Santoro, N.}       	{195}
IX: {Sack, J. R.}      	{195}
IX: {Atkinson, M. D.}      	{195}
IX: {Brown, M. R.}      	{195}
IX: {Carlsson, S.}       	{195}
IX: {Strothotte, T.}       	{195}
IX: {Chen, J.}       	{195}
IX: {Carlsson, S.}       	{195}
IX: {Poblete, P. V.}      	{195}
IX: {Munro, J. I.}      	{195}
IX: {Carlsson, S.}       	{195}
IX: {Tarjan, R. E.}      	{195}
IX: {Cheriton, D.}       	{195}
IX: {Crane, C. A.}      	{195}
IX: {Tarjan, R. E.}      	{195}
IX: {Shrairman, R.}       	{195}
IX: {Gabow, H. N.}      	{195}
IX: {Driscoll, J. R.}      	{195}
IX: {Floyd, R. W.}      	{195}
IX: {Tarjan, R. E.}      	{195}
IX: {Sleator, D. D.}      	{195}
IX: {Sedgewick, R.}       	{195}
IX: {Fredman, M. L.}      	{195}
IX: {Tarjan, R. E.}      	{195}
IX: {Fredman, M. L.}      	{195}
IX: {Munro, J. I.}      	{195}
IX: {Gonnet, G. H.}      	{195}
IX: {Sack, J. R.}      	{195}
IX: {Hasham, A.}       	{195}
IX: {Johnson, D. B.}      	{195}
IX: {Knuth, D. E.}      	{195}
IX: {Reed, B. A.}      	{195}
IX: {McDiarmid, C. J. H.}     	{195}
IX: {Tarjan, R. E.}      	{195}
IX: {Sleator, D. D.}      	{195}
IX: {Vallner, S.}       	{195}
IX: {Eriksson, P.}       	{195}
IX: {Strothotte, T.}       	{195}
IX: {Zijlstra, E.}       	{195}
IX: {Kaas, R.}       	{195}
IX: {van Emde Boas, P.}     	{195}
IX: {Vuillemin, J.}       	{196}
IX: {Williams, J. W. J.}     	{196}
IX: {Priority queue|)}       	{196}
IX: {Sorting|(}        	{197}
IX: {Sorting!comparison based|(}       	{198}
IX: {Sorting!comparison based|)}       	{198}
IX: {Sorting!insertion sort|(}       	{198}
IX: {Insertion sort|(}       	{198}
IX: {Insertion sort!implementation|(}       	{199}
IX: {Sentinel}        	{199}
IX: {Insertion sort!implementation|)}       	{199}
IX: {Insertion sort!analysis|(}       	{199}
IX: {Inversion|(}        	{199}
IX: {Analysis of algorithms|(}      	{199}
IX: {Analysis of algorithms!lower bound proofs|(}    	{199}
IX: {Lower bound!sorting|(}       	{199}
IX: {Sorting!lower bounds|(}       	{199}
IX: {Inversion|)}        	{200}
IX: {Analysis of algorithms|)}      	{200}
IX: {Analysis of algorithms!lower bound proofs|)}    	{200}
IX: {Lower bound!sorting|)}       	{200}
IX: {Sorting!lower bounds|)}       	{200}
IX: {Insertion sort|)}       	{200}
IX: {Sorting!insertion sort|)}       	{200}
IX: {Insertion sort!analysis|)}       	{200}
IX: {Shellsort|(}        	{200}
IX: {Sorting!shellsort|(}        	{200}
IX: {Shell, D. L.}      	{200}
IX: {Diminishing increment sort|see shellsort}     	{200}
IX: {Insertion sort|(}       	{201}
IX: {Insertion sort|)}       	{201}
IX: {Shellsort!implementation|(}        	{201}
IX: {Shell, D. L.}      	{201}
IX: {Shellsort!implementation|)}        	{201}
IX: {Analysis of algorithms|(}      	{201}
IX: {Shellsort!analysis|(}        	{201}
IX: {Shellsort!analysis!Shell's increments|(}       	{201}
IX: {Shellsort!analysis!Shell's increments|)}       	{202}
IX: {Shell, D. L.}      	{203}
IX: {Hibbard, T. H.}      	{203}
IX: {Shellsort!analysis!Hibbard's increments|(}       	{203}
IX: {Shellsort!analysis!Hibbard's increments|)}       	{203}
IX: {Shellsort!average running time|(}      	{203}
IX: {Pratt, V. R.}      	{203}
IX: {Sedgewick, R.}       	{203}
IX: {Hibbard, T. H.}      	{203}
IX: {Shellsort!average running time|)}      	{203}
IX: {Shellsort|)}        	{204}
IX: {Sorting!shellsort|)}        	{204}
IX: {Shellsort!analysis|)}        	{204}
IX: {Analysis of algorithms|)}      	{204}
IX: {Heapsort|(}        	{204}
IX: {Sorting!heapsort|(}        	{204}
IX: {Priority queue!heapsort|(}       	{204}
IX: {Heapsort!implementation|(}        	{204}
IX: {Heapsort!implementation|)}        	{204}
IX: {Heapsort|)}        	{204}
IX: {Sorting!heapsort|)}        	{204}
IX: {Priority queue!heapsort|)}       	{204}
IX: {Sorting!mergesort|(}        	{205}
IX: {Mergesort|(}        	{205}
IX: {Divide and conquer|(}      	{205}
IX: {Divide and conquer!mergesort|(}      	{205}
IX: {Mergesort!merging|(}        	{205}
IX: {Mergesort!merging|)}        	{207}
IX: {Mergesort!implementation|(}        	{208}
IX: {Mergesort!implementation|)}        	{208}
IX: {Mergesort!analysis|(}        	{208}
IX: {Analysis of algorithms|(}      	{208}
IX: {Analysis of algorithms!recursive procedures|(}     	{208}
IX: {Recurrence relations!solution of|(}      	{209}
IX: {Recurrence relations!solution of|)}      	{211}
IX: {Mergesort|)}        	{211}
IX: {Sorting!mergesort|)}        	{211}
IX: {Divide and conquer!mergesort|)}      	{211}
IX: {Analysis of algorithms|)}      	{211}
IX: {Analysis of algorithms!recursive procedures|)}     	{211}
IX: {Mergesort!analysis|)}        	{211}
IX: {Quicksort|(}        	{211}
IX: {Sorting!quicksort|(}        	{211}
IX: {Divide and conquer!quicksort|(}      	{211}
IX: {Quicksort!basic algorithm|(}       	{211}
IX: {Quicksort!basic algorithm|)}       	{211}
IX: {Quicksort!picking the pivot|(}      	{212}
IX: {Randomized algorithm!quicksort|(}       	{213}
IX: {Randomized algorithm|(}       	{213}
IX: {Randomized algorithm!quicksort|)}       	{213}
IX: {Randomized algorithm|)}       	{213}
IX: {Median of three partitioning|(}     	{213}
IX: {Median of three partitioning|)}     	{213}
IX: {Quicksort!picking the pivot|)}      	{213}
IX: {Quicksort!partitioning|(}        	{213}
IX: {Quicksort!pitfalls|(}        	{214}
IX: {Quicksort!dealing with duplicates|(}      	{214}
IX: {Quicksort!partitioning|)}        	{215}
IX: {Quicksort!pitfalls|)}        	{215}
IX: {Quicksort!dealing with duplicates|)}      	{215}
IX: {Quicksort!cutoff for small files|(}     	{215}
IX: {Insertion sort|(}       	{215}
IX: {Insertion sort|)}       	{215}
IX: {Quicksort!cutoff for small files|)}     	{215}
IX: {Quicksort!implementation|(}        	{215}
IX: {Quicksort!pitfalls|(}        	{216}
IX: {Quicksort!pitfalls|)}        	{216}
IX: {Quicksort!implementation|)}        	{216}
IX: {Quicksort!analysis|(}        	{217}
IX: {Analysis of algorithms|(}      	{217}
IX: {Analysis of algorithms!average case analysis|(}    	{217}
IX: {Analysis of algorithms!recursive procedures|(}     	{217}
IX: {Recurrence relations!solution of|(}      	{217}
IX: {Series!harmonic}        	{219}
IX: {Euler's constant}       	{219}
IX: {Quicksort|)}        	{220}
IX: {Quicksort!analysis|)}        	{220}
IX: {Analysis of algorithms|)}      	{220}
IX: {Analysis of algorithms!average case analysis|)}    	{220}
IX: {Analysis of algorithms!recursive procedures|)}     	{220}
IX: {Recurrence relations!solution of|)}      	{220}
IX: {Sorting!quicksort|)}        	{220}
IX: {Divide and conquer|)}      	{220}
IX: {Divide and conquer!quicksort|)}      	{220}
IX: {Selection problem!quickselect|(}       	{220}
IX: {Recursion!selection|(}        	{220}
IX: {Selection problem!quickselect|)}       	{220}
IX: {Recursion!selection|)}        	{220}
IX: {Indirect sorting|(}       	{220}
IX: {Sorting!large records|(}       	{220}
IX: {Sorting!large records|)}       	{221}
IX: {Indirect sorting|)}       	{221}
IX: {Analysis of algorithms!lower bound proofs|(}    	{221}
IX: {Lower bound!sorting|(}       	{221}
IX: {Sorting!lower bounds|(}       	{221}
IX: {Mergesort}        	{221}
IX: {Heapsort}        	{221}
IX: {Quicksort}        	{221}
IX: {Decision tree|(}       	{222}
IX: {Tree|(}        	{222}
IX: {Tree!decision tree|(}       	{222}
IX: {Lower bound!information theoretic|(}      	{223}
IX: {Lower bound!information theoretic|)}      	{223}
IX: {Tree|)}        	{223}
IX: {Tree!decision tree|)}       	{223}
IX: {Decision tree|)}       	{223}
IX: {Sorting!lower bounds|)}       	{223}
IX: {Analysis of algorithms!lower bound proofs|)}    	{223}
IX: {Lower bound!sorting|)}       	{223}
IX: {Sorting!bucket sort|(}       	{223}
IX: {Bucket sort|(}       	{223}
IX: {Lower bound!sorting|(}       	{224}
IX: {Sorting!lower bounds|(}       	{224}
IX: {Lower bound!sorting|)}       	{224}
IX: {Sorting!lower bounds|)}       	{224}
IX: {Bucket sort|)}       	{224}
IX: {Sorting!bucket sort|)}       	{224}
IX: {Sorting!external|(}        	{224}
IX: {External sorting|(}       	{224}
IX: {External sorting!simple merging|(}      	{224}
IX: {External sorting!run construction|(}      	{224}
IX: {Run construction|see external sorting}     	{224}
IX: {External sorting!run construction|)}      	{225}
IX: {External sorting!simple merging|)}      	{225}
IX: {Multiway merge|see external sorting}     	{225}
IX: {External sorting!multiway merge|(}      	{225}
IX: {Priority queue!external sorting|(}      	{225}
IX: {Priority queue!external sorting|)}      	{226}
IX: {External sorting!multiway merge|)}      	{226}
IX: {External sorting!polyphase merge|(}      	{226}
IX: {Polyphase merge|see external sorting}     	{226}
IX: {Fibonacci numbers!polyphase merge|(}      	{227}
IX: {Fibonacci numbers!\x'0'\f2\s11k\v'-44u'\s-3€th\s+3€\v'44u'\s11\f(01 order|(}      	{227}
IX: {Fibonacci numbers!polyphase merge|)}      	{227}
IX: {Fibonacci numbers!\x'0'\f2\s11k\v'-44u'\s-3€th\s+3€\v'44u'\s11\f(01 order|)}      	{227}
IX: {External sorting!polyphase merge|)}      	{227}
IX: {Replacement selection|see external sorting}     	{227}
IX: {External sorting!replacement selection|(}      	{227}
IX: {External sorting!run construction|(}      	{227}
IX: {Priority queue!external sorting|(}      	{227}
IX: {Sorting!external|)}        	{228}
IX: {External sorting!replacement selection|)}      	{228}
IX: {External sorting!run construction|)}      	{228}
IX: {Priority queue!external sorting|)}      	{228}
IX: {External sorting|)}       	{228}
IX: {Sorting!comparison of algorithms|(}      	{228}
IX: {Sorting!comparison of algorithms|)}      	{229}
IX: {Sorting!stable|(}        	{230}
IX: {Sorting!stable|)}        	{230}
IX: {Stirling's formula|(}       	{231}
IX: {Stirling's formula|)}       	{231}
IX: {Shellsort!average running time|(}      	{232}
IX: {Shellsort!average running time|)}      	{232}
IX: {Carlsson, S.}       	{232}
IX: {Doberkat, E. E.}      	{232}
IX: {Floyd, R. W.}      	{232}
IX: {Johnson, S. M.}      	{233}
IX: {Ford, L. R.}      	{233}
IX: {Sedgewick, R.}       	{233}
IX: {Golin, M.}       	{233}
IX: {Gonnet, G. H.}      	{233}
IX: {Hoare, C. A. R.}     	{233}
IX: {Hibbard, T. H.}      	{233}
IX: {Horvath, E. C.}      	{233}
IX: {Langston, M.}       	{233}
IX: {Huang, B.}       	{233}
IX: {Sedgewick, R.}       	{233}
IX: {Incerpi, J.}       	{233}
IX: {Knuth, D. E.}      	{233}
IX: {Manacher, G. K.}      	{233}
IX: {Stasevich, G. V.}      	{233}
IX: {Papernov, A. A.}      	{233}
IX: {Pratt, V. R.}      	{233}
IX: {Sedgewick, R.}       	{233}
IX: {Sedgewick, R.}       	{233}
IX: {Sedgewick, R.}       	{233}
IX: {Sedgewick, R.}       	{233}
IX: {Sedgewick, R.}       	{233}
IX: {Shell, D. L.}      	{233}
IX: {Weiss, M. A.}      	{233}
IX: {Sedgewick, R.}       	{233}
IX: {Weiss, M. A.}      	{233}
IX: {Sedgewick, R.}       	{233}
IX: {Weiss, M. A.}      	{233}
IX: {Williams, J. W. J.}     	{233}
IX: {Yao, A. C.}      	{233}
IX: {Sorting|)}        	{233}
IX: {Disjoint sets|(}       	{234}
IX: {Union/find algorithm|see disjoint sets}     	{234}
IX: {Merge/find algorithm|see disjoint sets}     	{234}
IX: {Equivalence relations|(}       	{235}
IX: {Equivalence class|(}       	{235}
IX: {Equivalence problem|(}       	{235}
IX: {Relation|(}        	{235}
IX: {Reflexive relation|(}       	{235}
IX: {Symmetric relation|(}       	{235}
IX: {Transitive relation|(}       	{235}
IX: {Connectivity|(}        	{235}
IX: {Connectivity|)}        	{235}
IX: {Reflexive relation|)}       	{235}
IX: {Transitive relation|)}       	{235}
IX: {Symmetric relation|)}       	{235}
IX: {Relation|)}        	{235}
IX: {On-line algorithms!disjoint sets algorithm|(}     	{235}
IX: {Disjoint sets!quick find algorithms|(}     	{236}
IX: {Disjoint sets!quick find algorithms|)}     	{237}
IX: {Equivalence relations|)}       	{237}
IX: {Equivalence class|)}       	{237}
IX: {Equivalence problem|)}       	{237}
IX: {Disjoint sets!quick union algorithms|(}     	{237}
IX: {Disjoint sets!quick union algorithms!union heuristics|(}    	{240}
IX: {Disjoint sets!quick union algorithms!implementation|(}     	{242}
IX: {Disjoint sets!quick union algorithms!union heuristics|)}    	{242}
IX: {Disjoint sets!quick union algorithms!implementation|)}     	{242}
IX: {Self adjusting data structure!disjoint sets algorithm|(}   	{242}
IX: {Path compression|see disjoint sets algorithm}    	{242}
IX: {Disjoint sets!quick union algorithms!path compression|(}    	{242}
IX: {Disjoint sets!quick union algorithm!implementation|(}     	{242}
IX: {Recursion!path compression|(}       	{242}
IX: {Recursion!path compression|)}       	{242}
IX: {Disjoint sets!quick union algorithm!implementation|)}     	{242}
IX: {Disjoint sets!quick union algorithms!path compression|)}    	{243}
IX: {Analysis of algorithms|(}      	{244}
IX: {Amortized analysis|(}       	{244}
IX: {Analysis of algorithms!amortized analysis|(}     	{244}
IX: {Amortized analysis!disjoint set algorithm|(}     	{244}
IX: {Disjoint sets!analysis|(}       	{244}
IX: {Ackerman's function|(}       	{244}
IX: {Ackerman's function|)}       	{244}
IX: {Disjoint sets!analysis|)}       	{248}
IX: {Analysis of algorithms|)}      	{248}
IX: {Amortized analysis|)}       	{248}
IX: {Analysis of algorithms!amortized analysis|)}     	{248}
IX: {Amortized analysis!disjoint set algorithm|)}     	{248}
IX: {Self adjusting data structure!disjoint sets algorithm|)}   	{248}
IX: {Connectivity!on-line algorithm|(}       	{248}
IX: {Connectivity|(}        	{248}
IX: {On-line algorithms!graph connectivity|(}      	{248}
IX: {Connectivity!on-line algorithm|)}       	{249}
IX: {Connectivity|)}        	{249}
IX: {On-line algorithms!graph connectivity|)}      	{249}
IX: {Disjoint sets!deunion operation|(}      	{249}
IX: {Disjoint sets!deunion operation|)}      	{249}
IX: {Disjoint sets!quick union algorithm!path halving|(}    	{250}
IX: {Disjoint sets!quick union algorithm!path halving|)}    	{250}
IX: {Graph|(}        	{250}
IX: {Graph!dominance|(}        	{250}
IX: {Dominance|see graphs}       	{250}
IX: {Reducibility|see graphs}       	{250}
IX: {Graph!reducibility|(}        	{250}
IX: {Graph!dominance|)}        	{250}
IX: {Graph!reducibility|)}        	{250}
IX: {Graph|)}        	{250}
IX: {Ullman, J. D.}      	{250}
IX: {Hopcroft, J. E.}      	{250}
IX: {Aho, A. V.}      	{250}
IX: {Banachowski, L.}       	{250}
IX: {Blum, N.}       	{250}
IX: {Rivest, R. L.}      	{251}
IX: {Doyle, J.}       	{251}
IX: {Fischer, M. J.}      	{251}
IX: {Saks, M. E.}      	{251}
IX: {Fredman, M. L.}      	{251}
IX: {Tarjan, R. E.}      	{251}
IX: {Gabow, H. N.}      	{251}
IX: {Fischer, M. J.}      	{251}
IX: {Galler, B. A.}      	{251}
IX: {Karp, R. M.}      	{251}
IX: {Hopcroft, J. E.}      	{251}
IX: {Ullman, J. D.}      	{251}
IX: {Hopcroft, J. E.}      	{251}
IX: {Schonhage, A.}       	{251}
IX: {Knuth, D. E.}      	{251}
IX: {LaPoutre, J. A.}      	{251}
IX: {LaPoutre, J. A.}      	{251}
IX: {Tarjan, R. E.}      	{251}
IX: {Tarjan, R. E.}      	{251}
IX: {Tarjan, R. E.}      	{251}
IX: {van Leeuwen, J.}      	{251}
IX: {Tarjan, R. E.}      	{251}
IX: {Tarjan, R. E.}      	{251}
IX: {Westbrook, J.}       	{251}
IX: {Yao, A. C.}      	{251}
IX: {Disjoint sets|)}       	{251}
IX: {On-line algorithms!disjoint sets algorithm|)}     	{251}
IX: {Disjoint sets!quick union algorithms|)}     	{251}
IX: {Graph|(}        	{252}
IX: {Graph!directed|(}        	{253}
IX: {Graph!undirected|(}        	{253}
IX: {Graph!definitions|(}        	{253}
IX: {Graph!cycle|(}        	{253}
IX: {Graph!acyclic|(}        	{253}
IX: {Acyclic graph|see graph}      	{253}
IX: {Graph!directed|)}        	{254}
IX: {Graph!undirected|)}        	{254}
IX: {Graph!definitions|)}        	{254}
IX: {Graph!cycle|)}        	{254}
IX: {Graph!acyclic|)}        	{254}
IX: {Graph!representation|(}        	{254}
IX: {Adjacency list|(}       	{254}
IX: {Linked list|(}       	{254}
IX: {Linked list!adjacency|(}       	{254}
IX: {Adjacency matrix|(}       	{254}
IX: {Sentinel}        	{254}
IX: {Dense graph}       	{254}
IX: {Sparse graph}       	{254}
IX: {Hashing|(}        	{255}
IX: {Hashing|)}        	{255}
IX: {Graph!representation|)}        	{255}
IX: {Adjacency list|)}       	{255}
IX: {Linked list!adjacency|)}       	{255}
IX: {Linked list|)}       	{255}
IX: {Adjacency matrix|)}       	{255}
IX: {Graph!directed|(}        	{255}
IX: {Sorting!topological|(}        	{255}
IX: {Topological sort|(}       	{255}
IX: {Graph!topological sort|(}       	{255}
IX: {Graph!acyclic|(}        	{255}
IX: {Graph!acyclic!test for|(}       	{256}
IX: {Graph!acyclic!test for|)}       	{256}
IX: {Queue|(}        	{257}
IX: {Stack|(}        	{257}
IX: {Queue!topological sort|(}       	{257}
IX: {Stack!topological sort|(}       	{257}
IX: {Stack!topological sort|)}       	{257}
IX: {Stack|)}        	{257}
IX: {Queue|)}        	{258}
IX: {Queue!topological sort|)}       	{258}
IX: {Sorting!topological|)}        	{258}
IX: {Topological sort|)}       	{258}
IX: {Graph!topological sort|)}       	{258}
IX: {Graph!acyclic|)}        	{258}
IX: {Shortest path algorithms|see graph}     	{259}
IX: {Graph!shortest path|(}       	{259}
IX: {Graph!shortest path!single source weighted|(}     	{259}
IX: {Graph!shortest path!single source unweighted|(}     	{259}
IX: {Graph!shortest path!acyclic graph|(}      	{259}
IX: {Graph!shortest path!negative edge costs|(}     	{259}
IX: {Graph!acyclic|(}        	{259}
IX: {Negative cost cycle|(}      	{259}
IX: {Graph!cycle!negative cost|(}       	{259}
IX: {Graph!cycle!negative cost|)}       	{260}
IX: {Negative cost cycle|)}      	{260}
IX: {Graph!shortest path!single source weighted|)}     	{260}
IX: {Graph!shortest path!acyclic graph|)}      	{260}
IX: {Graph!shortest path!negative edge costs|)}     	{260}
IX: {Graph!acyclic|)}        	{260}
IX: {Breadth first search|(}      	{260}
IX: {Queue!breadth first search|(}      	{260}
IX: {Queue|(}        	{260}
IX: {Graph!breadth first search|(}      	{260}
IX: {Queue!breadth first search|)}      	{264}
IX: {Queue|)}        	{264}
IX: {Breadth first search|)}      	{264}
IX: {Graph!breadth first search|)}      	{264}
IX: {Graph!shortest path!single source unweighted|)}     	{264}
IX: {Graph!shortest path!weighted|(}       	{264}
IX: {Dijkstra's algorithm|(}       	{264}
IX: {Greedy algorithm!shortest path|(}      	{264}
IX: {Recursion!recovering shortest path|(}      	{266}
IX: {Recursion!recovering shortest path|)}      	{267}
IX: {Priority queue|(}       	{269}
IX: {Priority queue!Dijkstra's algorithm|(}      	{269}
IX: {Sparse graph}       	{269}
IX: {Fibonacci heaps!Dijkstra's algorithm|(}      	{269}
IX: {Priority queue!Fibonacci heap|(}      	{269}
IX: {Graph!shortest path!weighted|)}       	{269}
IX: {Fibonacci heaps!Dijkstra's algorithm|)}      	{269}
IX: {Priority queue!Fibonacci heap|)}      	{269}
IX: {Dijkstra's algorithm|)}       	{269}
IX: {Greedy algorithm!shortest path|)}      	{269}
IX: {Priority queue!Dijkstra's algorithm|)}      	{269}
IX: {Priority queue|)}       	{269}
IX: {Graph!shortest path|)}       	{275}
IX: {Network flow|(}       	{276}
IX: {Dijsktra's algorithm|(}       	{279}
IX: {Breadth first search|(}      	{279}
IX: {Graph!shortest path|(}       	{279}
IX: {Dijsktra's algorithm|)}       	{280}
IX: {Breadth first search|)}      	{280}
IX: {Graph!shortest path|)}       	{280}
IX: {Network flow|)}       	{280}
IX: {Graph!directed|)}        	{280}
IX: {Minimum spanning tree|(}      	{281}
IX: {Tree|(}        	{281}
IX: {Tree!minimum spanning|(}       	{281}
IX: {Graph!undirected|(}        	{281}
IX: {Greedy algorithm!minimum spanning tree|(}     	{281}
IX: {Prim's algorithm|(}       	{281}
IX: {Priority queue|(}       	{283}
IX: {Priority queue!Prim's algorithm|(}      	{283}
IX: {Priority queue!Prim's algorithm|)}      	{283}
IX: {Priority queue|)}       	{283}
IX: {Prim's algorithm|)}       	{283}
IX: {Kruskal's algorithm|(}       	{284}
IX: {Disjoint sets|(}       	{284}
IX: {Disjoint sets!Kruskal's algorithm|(}      	{284}
IX: {Priority queue|(}       	{285}
IX: {Priority queue!Kruskal's algorithm|(}      	{285}
IX: {Priority queue!Kruskal's algorithm|)}      	{285}
IX: {Disjoint sets|)}       	{285}
IX: {Disjoint sets!Kruskal's algorithm|)}      	{285}
IX: {Kruskal's algorithm|)}       	{285}
IX: {Minimum spanning tree|)}      	{285}
IX: {Tree|)}        	{285}
IX: {Tree!minimum spanning|)}       	{285}
IX: {Priority queue|)}       	{285}
IX: {Greedy algorithm!minimum spanning tree|)}     	{285}
IX: {Recursion!depth first search|(}      	{285}
IX: {Depth first search|(}      	{285}
IX: {Graph!depth first search|(}      	{285}
IX: {Depth first search!undirected graph|(}     	{287}
IX: {Connectivity|(}        	{287}
IX: {Connectivity!linear time test|(}      	{287}
IX: {Connectivity|)}        	{287}
IX: {Connectivity!linear time test|)}      	{287}
IX: {Graph!biconnectivity|(}        	{287}
IX: {Biconnectivity|see graph}       	{287}
IX: {Articulation point|see graph (biconnectivity)}     	{287}
IX: {Graph!biconnectivity|)}        	{290}
IX: {Euler circuit|(}       	{291}
IX: {Graph!Euler circuit|(}       	{291}
IX: {Graph!Euler circuit|)}       	{295}
IX: {Euler circuit|)}       	{295}
IX: {Graph!undirected|)}        	{295}
IX: {Depth first search!undirected graph|)}     	{295}
IX: {Graph!directed|(}        	{295}
IX: {Depth first search!directed graph|(}     	{295}
IX: {Graph!acyclic|(}        	{296}
IX: {Graph!acyclic!test for|(}       	{296}
IX: {Graph!acyclic!test for|)}       	{296}
IX: {Graph!acyclic|)}        	{296}
IX: {Strong components|(}       	{296}
IX: {Graph!strong components|(}       	{296}
IX: {Graph!strong components|)}       	{298}
IX: {Strong components|)}       	{298}
IX: {Recursion!depth first search|)}      	{298}
IX: {Depth first search|)}      	{298}
IX: {Graph!depth first search|)}      	{298}
IX: {Depth first search!directed graph|)}     	{298}
IX: {Graph!undirected|(}        	{298}
IX: {Graph!longest path|(}       	{298}
IX: {Longest path algorithms|see graph}     	{298}
IX: {Graph!longest path|)}       	{298}
IX: {Graph!undirected|)}        	{298}
IX: {Graph!directed|)}        	{298}
IX: {Euclid's algorithm|(}       	{298}
IX: {Euclid's algorithm|)}       	{298}
IX: {Undecidability|(}        	{298}
IX: {Halting problem|(}       	{299}
IX: {Recursively undecidable problems|see undecidability}     	{299}
IX: {Undecidability|)}        	{299}
IX: {Halting problem|)}       	{299}
IX: {Non-determinism|(}        	{299}
IX: {NP problems|(}       	{299}
IX: {NP-completeness|(}        	{299}
IX: {Hamiltonian cycle|(}       	{299}
IX: {Graph!hamiltonian cycle|(}       	{299}
IX: {Reduction|(}        	{300}
IX: {Traveling salesman|(}       	{300}
IX: {Graph!traveling salesman|(}       	{300}
IX: {Hamiltonian cycle|)}       	{301}
IX: {Graph!hamiltonian cycle|)}       	{301}
IX: {Traveling salesman|)}       	{301}
IX: {Graph!traveling salesman|)}       	{301}
IX: {Satisfiability|(}        	{301}
IX: {Cook's theorem|(}       	{301}
IX: {Turing machine|(}       	{301}
IX: {Satisfiability|)}        	{301}
IX: {Cook's theorem|)}       	{301}
IX: {Turing machine|)}       	{301}
IX: {Graph!longest path}       	{301}
IX: {Bin packing}       	{302}
IX: {Knapsack problem}       	{302}
IX: {Graph!colorability}        	{302}
IX: {Coloring|see graph}       	{302}
IX: {Graph!clique}        	{302}
IX: {Clique|see graph}       	{302}
IX: {Scheduling}        	{302}
IX: {NP-completeness|)}        	{302}
IX: {NP problems|)}       	{302}
IX: {Non-determinism|)}        	{302}
IX: {Reduction|)}        	{302}
IX: {d-heap}        	{302}
IX: {Graph!bipartite|(}        	{303}
IX: {Graph!matching|(}        	{303}
IX: {Graph!bipartite|)}        	{303}
IX: {Graph!matching|)}        	{303}
IX: {Bipartite graph|see graph}      	{303}
IX: {Planar graph|see graph}      	{306}
IX: {Graph!planar|(}        	{306}
IX: {Graph!planar|)}        	{306}
IX: {Multigraph|see graph}       	{306}
IX: {Graph!multigraph|(}        	{306}
IX: {Graph!multigraph|)}        	{306}
IX: {Vertex cover|see graph}      	{306}
IX: {Graph!vertex cover|(}       	{306}
IX: {NP-completeness|(}        	{306}
IX: {Graph!vertex cover|)}       	{306}
IX: {NP-completeness|)}        	{307}
IX: {Graph!dominance}        	{307}
IX: {Graph!reducibility}        	{307}
IX: {Graph!isomorphism}        	{307}
IX: {Ullman, J. D.}      	{307}
IX: {Hopcroft, J. E.}      	{307}
IX: {Aho, A. V.}      	{307}
IX: {Tarjan, R. E.}      	{308}
IX: {Orlin, J. B.}      	{308}
IX: {Melhorn, K.}       	{308}
IX: {Ahuja, R. K.}      	{308}
IX: {Bellman, R. E.}      	{308}
IX: {Boruvka, O.}       	{308}
IX: {Tarjan, R. E.}      	{308}
IX: {Cheriton, D.}       	{308}
IX: {Cook, S.}       	{308}
IX: {Deo, N.}       	{308}
IX: {Dijkstra, E. W.}      	{308}
IX: {Dinic, E. A.}      	{308}
IX: {Edmonds, J.}       	{308}
IX: {Karp, R. M.}      	{308}
IX: {Edmonds, J.}       	{308}
IX: {Even, S.}       	{308}
IX: {Fulkerson, D. R.}      	{308}
IX: {Ford, L. R.}      	{308}
IX: {Tarjan, R. E.}      	{308}
IX: {Fredman, M. L.}      	{308}
IX: {Gabow, H. N.}      	{308}
IX: {Tarjan, R. E.}      	{308}
IX: {Spencer, T. H.}      	{308}
IX: {Galil, Z.}       	{308}
IX: {Gabow, H. N.}      	{308}
IX: {Galil, Z.}       	{308}
IX: {Tardos, E.}       	{308}
IX: {Galil, Z.}       	{308}
IX: {Johnson, D. S.}      	{308}
IX: {Garey, M. R.}      	{308}
IX: {Tarjan, R. E.}      	{308}
IX: {Goldberg, A. V.}      	{308}
IX: {Harary, F.}       	{308}
IX: {Karp, R. M.}      	{308}
IX: {Hopcroft, J. E.}      	{308}
IX: {Tarjan, R. E.}      	{308}
IX: {Hopcroft, J. E.}      	{308}
IX: {Tarjan, R. E.}      	{308}
IX: {Hopcroft, J. E.}      	{308}
IX: {Tarjan, R. E.}      	{309}
IX: {Hopcroft, J. E.}      	{309}
IX: {Wong, J. K.}      	{309}
IX: {Hopcroft, J. E.}      	{309}
IX: {Johnson, D. B.}      	{309}
IX: {Kahn, A. B.}      	{309}
IX: {Karp, R. M.}      	{309}
IX: {Karzanov, A. V.}      	{309}
IX: {Knuth, D. E.}      	{309}
IX: {Kruskal, J. R.}      	{309}
IX: {Kuhn, H. W.}      	{309}
IX: {Lawler, E. L.}      	{309}
IX: {Kernighan, B. W.}      	{309}
IX: {Lin, S.}       	{309}
IX: {Melhorn, K.}       	{309}
IX: {Steiglitz, K.}       	{309}
IX: {Papdimitriou, C. H.}      	{309}
IX: {Prim, R. C.}      	{309}
IX: {Sharir, M.}       	{309}
IX: {Tarjan, R. E.}      	{309}
IX: {Tarjan, R. E.}      	{309}
IX: {Tarjan, R. E.}      	{309}
IX: {Tarjan, R. E.}      	{309}
IX: {Tarjan, R. E.}      	{309}
IX: {Yao, A. C.}      	{309}
IX: {Graph|)}        	{309}
IX: {Greedy algorithm|(}       	{311}
IX: {Greedy algorithm!coin changing|(}      	{311}
IX: {Coin changing problem|(}      	{311}
IX: {Coin changing problem|)}      	{311}
IX: {Greedy algorithm!coin changing|)}      	{311}
IX: {NP-completeness}        	{311}
IX: {Scheduling|(}        	{312}
IX: {Greedy algorithm!processor scheduling|(}      	{312}
IX: {Non-preemptive scheduling}       	{312}
IX: {NP-completeness}        	{315}
IX: {Knapsack problem}       	{315}
IX: {Bin packing}       	{315}
IX: {Scheduling|)}        	{315}
IX: {Greedy algorithm!processor scheduling|)}      	{315}
IX: {Compression|see file compression}      	{315}
IX: {File compression|(}       	{315}
IX: {Huffman codes|(}       	{315}
IX: {Tree|(}        	{315}
IX: {Greedy algorithm!Huffman codes|(}      	{315}
IX: {Trie|(}        	{315}
IX: {Tree!trie|(}        	{315}
IX: {Binary tree|(}       	{315}
IX: {Binary tree!Huffman code|(}      	{315}
IX: {Prefix code|(}       	{316}
IX: {Prefix code|)}       	{317}
IX: {Priority queue!Huffman code|(}      	{320}
IX: {Priority queue|(}       	{320}
IX: {File compression|)}       	{320}
IX: {Huffman codes|)}       	{320}
IX: {Greedy algorithm!Huffman codes|)}      	{320}
IX: {Trie|)}        	{320}
IX: {Tree!trie|)}        	{320}
IX: {Binary tree|)}       	{320}
IX: {Binary tree!Huffman code|)}      	{320}
IX: {Priority queue!Huffman code|)}      	{320}
IX: {Priority queue|)}       	{320}
IX: {Greedy algorithm!approximate bin packing|(}     	{320}
IX: {Bin packing|(}       	{320}
IX: {Approximation algorithm!bin packing|(}      	{320}
IX: {Tree|)}        	{320}
IX: {On-line algorithms!bin packing|(}      	{321}
IX: {Bin packing!lower bound for on-line algorithms|(}   	{321}
IX: {Lower bound!on-line bin packing|(}     	{321}
IX: {Bin packing!lower bound for on-line algorithms|)}   	{322}
IX: {Lower bound!on-line bin packing|)}     	{322}
IX: {Bin packing!next fit|(}      	{322}
IX: {Bin packing!next fit|)}      	{322}
IX: {Bin packing!first fit|(}      	{322}
IX: {Bin packing!first fit|)}      	{324}
IX: {Bin packing!best fit|(}      	{324}
IX: {Bin packing!best fit|)}      	{324}
IX: {On-line algorithms!bin packing|)}      	{324}
IX: {Bin packing!first fit decreasing|(}     	{325}
IX: {Bin packing!best fit decreasing|(}     	{325}
IX: {Bin packing!best fit decreasing|)}     	{325}
IX: {Bin packing!first fit decreasing|)}     	{327}
IX: {Greedy algorithm|)}       	{327}
IX: {Bin packing|)}       	{327}
IX: {Greedy algorithm!approximate bin packing|)}     	{327}
IX: {Approximation algorithm!bin packing|)}      	{327}
IX: {Divide and conquer|(}      	{327}
IX: {Divide and conquer!principles of|(}     	{327}
IX: {Divide and conquer!principles of|)}     	{328}
IX: {Computational geometry}       	{328}
IX: {Divide and conquer!analysis of general case|(}   	{328}
IX: {Analysis of algorithms!recursive procedures|(}     	{328}
IX: {Recurrence relations!solution of|(}      	{328}
IX: {Divide and conquer!analysis of general case|)}   	{330}
IX: {Analysis of algorithms!recursive procedures|)}     	{330}
IX: {Recurrence relations!solution of|)}      	{330}
IX: {Divide and conquer!closest points|(}     	{330}
IX: {Computational geometry|(}       	{330}
IX: {Computational geometry!closest points|(}      	{330}
IX: {Closest points|see computational geometry}     	{330}
IX: {Divide and conquer!closest points|)}     	{334}
IX: {Computational geometry|)}       	{334}
IX: {Computational geometry!closest points|)}      	{334}
IX: {Selection problem!in linear worst case time|(}   	{334}
IX: {Divide and conquer!selection|(}      	{334}
IX: {Selection problem!in linear worst case time|)}   	{336}
IX: {Selection problem!sampling algorithm|(}      	{336}
IX: {Randomized algorithm!selection|(}       	{336}
IX: {Randomized algorithm|(}       	{336}
IX: {Randomized algorithm!selection|)}       	{337}
IX: {Randomized algorithm|)}       	{337}
IX: {Selection problem!sampling algorithm|)}      	{337}
IX: {Divide and conquer!selection|)}      	{337}
IX: {Divide and conquer!multiplication of integers|(}    	{337}
IX: {Multiplication of integers|(}      	{337}
IX: {Divide and conquer!multiplication of integers|)}    	{338}
IX: {Multiplication of integers|)}      	{338}
IX: {Strassen's algorithm|(}       	{338}
IX: {Divide and conquer!matrix multiplication|(}     	{338}
IX: {Matrix multiplication!Strassen's algorithm|(}      	{338}
IX: {Divide and conquer|)}      	{340}
IX: {Strassen's algorithm|)}       	{340}
IX: {Divide and conquer!matrix multiplication|)}     	{340}
IX: {Matrix multiplication!Strassen's algorithm|)}      	{340}
IX: {Dynamic programming|(}       	{340}
IX: {Dynamic programming!principles of|(}      	{340}
IX: {Fibonacci numbers!bad use of recursion|(}    	{340}
IX: {Recursion!bad uses|(}       	{340}
IX: {Fibonacci numbers!bad use of recursion|)}    	{341}
IX: {Recursion!bad uses|)}       	{342}
IX: {Dynamic programming!chained matrix multiplication|(}     	{343}
IX: {Matrix multiplication!chained|(}       	{343}
IX: {Catalan numbers}       	{344}
IX: {Dynamic programming!principles of|)}      	{346}
IX: {Dynamic programming!chained matrix multiplication|)}     	{346}
IX: {Matrix multiplication!chained|)}       	{346}
IX: {Dynamic programming!optimal binary search tree|(}    	{346}
IX: {Optimal binary search tree|(}     	{346}
IX: {Binary search tree|(}      	{346}
IX: {Binary search tree!optimal|(}      	{346}
IX: {Dynamic programming!optimal binary search tree|)}    	{348}
IX: {Optimal binary search tree|)}     	{348}
IX: {Binary search tree|)}      	{348}
IX: {Binary search tree!optimal|)}      	{348}
IX: {Dynamic programming!all pairs shortest path|(}    	{348}
IX: {Graph!shortest path!all pairs|(}      	{348}
IX: {Dynamic programming!all pairs shortest path|)}    	{350}
IX: {Graph!shortest path!all pairs|)}      	{350}
IX: {Dynamic programming|)}       	{350}
IX: {Randomized algorithm|(}       	{350}
IX: {Randomized algorithm!principles of|(}      	{350}
IX: {Randomized algorithm!principles of|)}      	{352}
IX: {Random number generator|(}      	{352}
IX: {Linear congruential generator|(}      	{352}
IX: {Modular arithmetic|(}       	{352}
IX: {Lehmer, D}       	{352}
IX: {Schrage, L.}       	{353}
IX: {Modular arithmetic|)}       	{354}
IX: {Random number generator|)}      	{354}
IX: {Linear congruential generator|)}      	{354}
IX: {Randomized algorithm!skip list|(}      	{355}
IX: {Linked list|(}       	{355}
IX: {Skip list|(}       	{355}
IX: {Linked list!skip list|(}      	{355}
IX: {Linked list|)}       	{357}
IX: {Randomized algorithm!skip list|)}      	{357}
IX: {Skip list|)}       	{357}
IX: {Linked list!skip list|)}      	{357}
IX: {Randomized algorithm!primality test|(}      	{357}
IX: {Primality test|(}       	{357}
IX: {Modular arithmetic|(}       	{357}
IX: {NP-completeness|(}        	{357}
IX: {Cryptography|(}        	{357}
IX: {NP-completeness|)}        	{357}
IX: {Cryptography|)}        	{357}
IX: {Fermat's lesser theorem|(}      	{357}
IX: {Fermat's lesser theorem|)}      	{357}
IX: {Charmichael numbers|(}       	{357}
IX: {Charmichael numbers|)}       	{357}
IX: {Exponentiation|(}        	{358}
IX: {Randomized algorithm|)}       	{358}
IX: {Randomized algorithm!primality test|)}      	{358}
IX: {Primality test|)}       	{358}
IX: {Exponentiation|)}        	{358}
IX: {Modular arithmetic|)}       	{358}
IX: {Recursion!backtracking algorithm|(}       	{358}
IX: {Backtracking algorithm|(}       	{358}
IX: {Backtracking algorithm!principles of|(}      	{358}
IX: {Backtracking algorithm!principles of|)}      	{358}
IX: {Backtracking algorithm!turnpike reconstruction|(}      	{358}
IX: {Turnpike reconstruction|(}       	{358}
IX: {Computational geometry|(}       	{358}
IX: {Computational geometry!turnpike reconstruction|(}      	{358}
IX: {Tree|(}        	{363}
IX: {Tree!splay|(}        	{363}
IX: {Tree|)}        	{364}
IX: {Tree!splay|)}        	{364}
IX: {Backtracking algorithm!turnpike reconstruction|)}      	{364}
IX: {Turnpike reconstruction|)}       	{364}
IX: {Computational geometry|)}       	{364}
IX: {Computational geometry!turnpike reconstruction|)}      	{364}
IX: {Backtracking algorithm!games|(}       	{364}
IX: {Tic-tac-toe|(}        	{364}
IX: {Chess|see backtracking algorithm (games)}     	{364}
IX: {Minimax algorithm|(}       	{364}
IX: {Backtracking algorithm!games!minimax algorithm|(}      	{364}
IX: {Transposition table|(}       	{366}
IX: {Hashing|(}        	{366}
IX: {Transposition table|)}       	{366}
IX: {Hashing|)}        	{366}
IX: {Minimax algorithm|)}       	{366}
IX: {Backtracking algorithm!games!minimax algorithm|)}      	{366}
IX: {Tree|(}        	{366}
IX: {Tree!game|(}        	{366}
IX: {Game tree|(}       	{366}
IX: {Alpha-beta pruning@\x'0'\f2\s11\(*a\(mi\(*b\s11\f(01 pruning|(}      	{366}
IX: {Backtracking algorithm!games!\x'0'\f2\s11\(*a\(mi\(*b\s11\f(01 pruning|(}      	{366}
IX: {Alpha-beta pruning@\x'0'\f2\s11\(*a\(mi\(*b\s11\f(01 pruning|)}      	{369}
IX: {Backtracking algorithm!games!\x'0'\f2\s11\(*a\(mi\(*b\s11\f(01 pruning|)}      	{369}
IX: {Recursion!backtracking algorithm|)}       	{369}
IX: {Backtracking algorithm!games|)}       	{369}
IX: {Tree!game|)}        	{369}
IX: {Tree|)}        	{369}
IX: {Game tree|)}       	{369}
IX: {Tic-tac-toe|)}        	{369}
IX: {Backtracking algorithm|)}       	{369}
IX: {Lower bound!on-line bin packing|(}     	{371}
IX: {Lower bound!on-line bin packing|)}     	{371}
IX: {Skip list|(}       	{372}
IX: {Skip list|)}       	{373}
IX: {Approximation algorithm!traveling salesman problem|(}     	{374}
IX: {Graph!traveling salesman|(}       	{374}
IX: {Minimum spanning tree}      	{374}
IX: {Graph!minimum spanning tree}      	{374}
IX: {Approximation algorithm!traveling salesman problem|)}     	{374}
IX: {Graph!traveling salesman|)}       	{374}
IX: {Computational geometry!Voronoi diagram|(}      	{374}
IX: {Voronoi diagram|(}       	{374}
IX: {Computational geometry|(}       	{374}
IX: {Computational geometry!closest points|(}      	{374}
IX: {Voronoi diagram|)}       	{374}
IX: {Computational geometry!Voronoi diagram|)}      	{374}
IX: {Computational geometry|)}       	{374}
IX: {Computational geometry!closest points|)}      	{374}
IX: {Convex hull|(}       	{375}
IX: {Computational geometry|(}       	{375}
IX: {Computational geometry!convex hull|(}      	{375}
IX: {Convex hull|)}       	{375}
IX: {Computational geometry|)}       	{375}
IX: {Computational geometry!convex hull|)}      	{375}
IX: {Paragraphing problem|(}       	{375}
IX: {Paragraphing problem|)}       	{375}
IX: {Pattern matching|(}       	{376}
IX: {Pattern matching|)}       	{376}
IX: {Knapsack problem|(}       	{376}
IX: {Knapsack problem|)}       	{376}
IX: {Coin changing problem|(}      	{376}
IX: {Coin changing problem|)}      	{376}
IX: {Eight queens problem|(}      	{376}
IX: {Eight queens problem|)}      	{376}
IX: {Knight's tour|(}       	{376}
IX: {Knight's tour|)}       	{376}
IX: {Abramson, B.}       	{378}
IX: {Wein, J.}       	{378}
IX: {Aggarwal, A. A.}      	{378}
IX: {Cleary, J. G.}      	{378}
IX: {Witten, I. H.}      	{378}
IX: {Bell, T.}       	{378}
IX: {Bellman, R. E.}      	{378}
IX: {Dreyfus, S. E.}      	{378}
IX: {Bellman, R. E.}      	{378}
IX: {Saxe, J. B.}      	{378}
IX: {Haken, D.}       	{378}
IX: {Bentley, J. L.}      	{378}
IX: {Bloom, G. S.}      	{378}
IX: {Tarjan, R. E.}      	{378}
IX: {Rivest, R. L.}      	{378}
IX: {Pratt, V. R.}      	{378}
IX: {Floyd, R. W.}      	{378}
IX: {Blum, M.}       	{378}
IX: {Munro, J. I.}      	{378}
IX: {Borodin, A.}       	{378}
IX: {Korsh, J.}       	{378}
IX: {Chang, L.}       	{378}
IX: {Christofides, N.}       	{378}
IX: {Winograd, S.}       	{378}
IX: {Coppersmith, D.}       	{378}
IX: {Edelsbrunner, H.}       	{379}
IX: {Giancarlo, R.}       	{379}
IX: {Galil, Z.}       	{379}
IX: {Eppstein, D.}       	{379}
IX: {Floyd, R. W.}      	{379}
IX: {Rivest, R. L.}      	{379}
IX: {Floyd, R. W.}      	{379}
IX: {Fredman, M. L.}      	{379}
IX: {Godbole, S.}       	{379}
IX: {Shing, M. R.}      	{379}
IX: {Hu, T. C.}      	{379}
IX: {Huffman, D. A.}      	{379}
IX: {Johnson, D. S.}      	{379}
IX: {Ofman, Y.}       	{379}
IX: {Karatsuba, A.}       	{379}
IX: {Knuth, D. E.}      	{379}
IX: {Knuth, D. E.}      	{379}
IX: {Knuth, D. E.}      	{379}
IX: {Knuth, D. E.}      	{379}
IX: {Knuth, D. E.}      	{379}
IX: {Knuth, D. E.}      	{379}
IX: {Vishkin, U.}       	{379}
IX: {Landau, G. M.}      	{379}
IX: {Larmore, L. L.}      	{379}
IX: {Hirschberg, D. S.}      	{379}
IX: {Larmore, L. L.}      	{379}
IX: {Mahajan, S.}       	{379}
IX: {Lee, K.}       	{379}
IX: {Hirschberg, D. S.}      	{379}
IX: {Lelewer, D. A.}      	{379}
IX: {Liang, F. M.}      	{379}
IX: {Miller, G. L.}      	{379}
IX: {Monier, L.}       	{380}
IX: {Pan, V.}       	{380}
IX: {Miller, K. W.}      	{380}
IX: {Park, S. K.}      	{380}
IX: {Shamos, M. I.}      	{380}
IX: {Preparata, F. P.}      	{380}
IX: {Pugh, W.}       	{380}
IX: {Rabin, M. O.}      	{380}
IX: {Rabin, M. O.}      	{380}
IX: {Lee, D. T.}      	{380}
IX: {Len, C. C.}      	{380}
IX: {Brown, D. J.}      	{380}
IX: {Ramanan, P.}       	{380}
IX: {Hoey, D.}       	{380}
IX: {Shamos, M. I.}      	{380}
IX: {Schrage, L.}       	{380}
IX: {Lemke, P.}       	{380}
IX: {Smith, W. D.}      	{380}
IX: {Skiena, S. S.}      	{380}
IX: {Strassen, V.}       	{380}
IX: {Fischer, M. J.}      	{380}
IX: {Wagner, R. A.}      	{380}
IX: {Yao, A. C.}      	{380}
IX: {Yao, F. F.}      	{380}
IX: {Lempel, A.}       	{380}
IX: {Ziv, J.}       	{380}
IX: {Lempel, A.}       	{380}
IX: {Ziv, J.}       	{380}
IX: {Analysis of algorithms|(}      	{381}
IX: {Amortized analysis|(}       	{381}
IX: {Analysis of algorithms!amortized analysis|(}     	{381}
IX: {Amortized analysis!potential function|(}      	{382}
IX: {Potential function|(}       	{382}
IX: {Binomial queue!amortized analysis of|(}     	{383}
IX: {Binomial queue|(}       	{383}
IX: {Amortized analysis!binomial queue|(}      	{383}
IX: {Binomial queue!amortized analysis of|)}     	{387}
IX: {Amortized analysis!binomial queue|)}      	{387}
IX: {Amortized analysis!potential function|)}      	{387}
IX: {Potential function|)}       	{387}
IX: {Binomial queue|)}       	{387}
IX: {Self adjusting data structure!skew heap|(}    	{387}
IX: {Skew heap!amortized analysis of|(}     	{387}
IX: {Skew heap|(}       	{387}
IX: {Amortized analysis!skew heap|(}      	{387}
IX: {Skew heap!amortized analysis of|)}     	{390}
IX: {Amortized analysis!skew heap|)}      	{390}
IX: {Skew heap|)}       	{390}
IX: {Self adjusting data structure!skew heap|)}    	{390}
IX: {Fibonacci heap|(}       	{390}
IX: {Priority queue!Fibonacci heap|(}      	{390}
IX: {Dijkstra's algorithm|(}       	{390}
IX: {Graph!shortest path!single source weighted|(}     	{390}
IX: {Priority queue!Dijkstra's algorithm|(}      	{390}
IX: {d-heap|(}        	{390}
IX: {Dijkstra's algorithm|)}       	{390}
IX: {Graph!shortest path!single source weighted|)}     	{390}
IX: {Priority queue!Dijkstra's algorithm|)}      	{390}
IX: {d-heap|)}        	{390}
IX: {Lazy merging|(}       	{390}
IX: {Lazy merging|)}       	{390}
IX: {Leftist heap|(}       	{390}
IX: {Leftist heap!cutting nodes|(}      	{390}
IX: {Leftist heap!decrease_key operation|(}      	{390}
IX: {Leftist heap!cutting nodes|)}      	{392}
IX: {Leftist heap!decrease_key operation|)}      	{392}
IX: {Leftist heap|)}       	{392}
IX: {Lazy merging|(}       	{392}
IX: {Lazy merging!binomial queue|(}      	{392}
IX: {Binomial queue|(}       	{392}
IX: {Binomial queue!lazy merging|(}      	{392}
IX: {Lazy binomial queue|(}      	{392}
IX: {Amortized analysis!lazy binomial queue|(}     	{392}
IX: {Lazy merging|)}       	{396}
IX: {Lazy merging!binomial queue|)}      	{396}
IX: {Binomial queue|)}       	{396}
IX: {Binomial queue!lazy merging|)}      	{396}
IX: {Lazy binomial queue|)}      	{396}
IX: {Amortized analysis!lazy binomial queue|)}     	{396}
IX: {Fibonacci heap!basic operations|(}      	{396}
IX: {Fibonacci heap!marking nodes|(}      	{396}
IX: {Fibonacci heap!cascading cut|(}      	{396}
IX: {Fibonacci heap!basic operations|)}      	{397}
IX: {Fibonacci heap!marking nodes|)}      	{397}
IX: {Fibonacci heap!cascading cut|)}      	{397}
IX: {Fibonacci heap!amortized analysis of|(}     	{397}
IX: {Amortized analysis!Fibonacci heap|(}      	{397}
IX: {Fibonacci numbers|(}       	{397}
IX: {Fibonacci numbers!properties of|(}      	{397}
IX: {Fibonacci numbers|)}       	{397}
IX: {Fibonacci numbers!properties of|)}      	{397}
IX: {Fibonacci heap!amortized analysis of|)}     	{398}
IX: {Amortized analysis!Fibonacci heap|)}      	{398}
IX: {Fibonacci heap|)}       	{398}
IX: {Priority queue!Fibonacci heap|)}      	{398}
IX: {Self adjusting data structure!splay tree|(}    	{398}
IX: {Splay tree!amortized analysis of|(}     	{398}
IX: {Amortized analysis!splay tree|(}      	{398}
IX: {Splay tree|(}       	{398}
IX: {Splay tree!amortized analysis of|)}     	{402}
IX: {Amortized analysis!splay tree|)}      	{402}
IX: {Splay tree|)}       	{402}
IX: {Self adjusting data structure!splay tree|)}    	{402}
IX: {two-three tree@2-3 tree|(}      	{403}
IX: {two-three tree@2-3 tree|)}      	{403}
IX: {Queue|(}        	{403}
IX: {Queue!double-ended|(}        	{403}
IX: {Queue|)}        	{403}
IX: {Queue!double-ended|)}        	{403}
IX: {Splay tree|(}       	{403}
IX: {Splay tree!merging|(}       	{403}
IX: {Splay tree|)}       	{403}
IX: {Splay tree!merging|)}       	{403}
IX: {Self adjusting data structure!list|(}     	{403}
IX: {Self adjusting data structure!list|)}     	{403}
IX: {Brown, M. R.}      	{403}
IX: {Tarjan, R. E.}      	{404}
IX: {Brown, M. R.}      	{404}
IX: {Tarjan, R. E.}      	{404}
IX: {Fredman, M. L.}      	{404}
IX: {Tarjan, R. E.}      	{404}
IX: {Gajewska, H.}       	{404}
IX: {Moffat, A.}       	{404}
IX: {Port, G.}       	{404}
IX: {Tarjan, R. E.}      	{404}
IX: {Sleator, D. D.}      	{404}
IX: {Tarjan, R. E.}      	{404}
IX: {Sleator, D. D.}      	{404}
IX: {Tarjan, R. E.}      	{404}
IX: {Sleator, D. D.}      	{404}
IX: {Tarjan, R. E.}      	{404}
IX: {Vuillemin, J.}       	{404}
IX: {Amortized analysis|)}       	{404}
IX: {Analysis of algorithms|)}      	{404}
IX: {Analysis of algorithms!amortized analysis|)}     	{404}