Index
A
- add, Exercise 2, Classifying add, Exercise 3-Exercise 3, Classifying MyLinkedList Methods, Profiling, Performance Profiling Results, Adding to the End of a LinkedList, Data Structure Selection, Exercise 6
- amortized analysis, ArrayList, Classifying add, Analyzing MyHashMap
- analysis, Analysis of Lookup-Analysis of Indexing, Analysis of Merge Sort, Space Complexity
- analysis of algorithms, Interfaces, Analysis of Algorithms, Analyzing MyLinearMap
- and, Exercise 13
- anonymous class, Profiling, Comparable and Comparator
- Ant, Prerequisites, Exercise 1, Exercise 2, Getting Started, Exercise 6, Exercise 6, Exercise 7, Exercise 8, Exercise 9, Profiling MyHashMap, Implementing a TreeMap, Making a Redis-Backed Index, Exercise 12, Exercise 13, Exercise 14
- Apache Ant, Prerequisites
- API, Prerequisites
- application programming interface, Prerequisites
- ArrayDeque, Iterative DFS
- ArrayList, Interfaces-List Interface, ArrayList, Interpreting Results, Implementing MyLinearMap, Hashing
- average time, Classifying add, Performance Profiling Results
- AVL tree, Self-Balancing Trees
B
- balanced tree, The Logarithmic Methods
- base case, Searching for Values, In-Order Traversal, Exercise 14
- big O notation, Big O Notation
- binary search tree, Interfaces, Binary Search Tree, Heap Sort
- boolean, Exercise 2
- boolean search, Boolean Search
- bounded heap, Heap Sort-Bounded Heap
- BST, Binary Search Tree, Heap Sort
- BST property, Binary Search Tree, In-Order Traversal
- bubble sort, Radix Sort
C
- cache, The Tradeoffs, Space Complexity
- call stack, Depth-First Search
- Card, Comparable and Comparator
- child node, Parsing HTML
- chooseMap, Hashing
- choosing a data structure, Choosing a Structure
- class diagram, UML Class Diagrams
- clear, A Note on Garbage Collection, The Tradeoffs, Exercise 10
- client, Redis Clients and Servers
- clone, Working with the Code
- code point, How Does Hashing Work?
- Collections, Exercise 13
- Comparable, Interfaces in Java, Interfaces in Java, Exercise 13
- Comparator, Exercise 13-Comparable and Comparator, Bounded Heap
- compare, Comparable and Comparator
- compareTo, Interfaces in Java, Comparable and Comparator
- comparison sort, Analysis of Merge Sort
- constant time, Analysis of Algorithms-Selection Sort, Exercise 2, Classifying MyArrayList Methods-Classifying add, Problem Size, Exercise 3, A Note on Garbage Collection, Classifying MyLinkedList Methods, Classifying MyLinkedList Methods, Interpreting Results-Interpreting Results, Performance Profiling Results, Profiling LinkedList Methods, Profiling LinkedList Methods, Adding to the End of a LinkedList, Doubly Linked List, Stacks in Java, Analyzing MyLinearMap, Analyzing MyLinearMap, HashMap, Analyzing MyHashMap, Analyzing MyHashMap, Fixing MyHashMap-Fixing MyHashMap, What’s Wrong with Hashing?, Exercise 10, The Logarithmic Methods, Redis Data Types, Analysis of Lookup, Crawler Solution, Radix Sort, Heap Sort
- constructor, Exercise 1, Exercise 2
- contains, Data Structure Selection
- containsKey, Exercise 7, The Tradeoffs, Implementing a TreeMap
- containsValue, Exercise 8, The Tradeoffs, Implementing a TreeMap
- crawl, Exercise 12
- crawler, Interfaces, Search Engines, Persistence
D
- data structure selection, Choosing a Structure
- data structures, Interfaces
- database, Redis
- DBMS, Redis
- depth-first search, Iterating Through the DOM, Iterables and Iterators
- Deque, Tree Traversal, Stacks in Java
- deque, Stacks in Java
- DFS, Depth-First Search, Iterables and Iterators
- difference, Boolean Search
- divide-conquer-glue, Sorting
- Document, Using jsoup
- DOM tree, Parsing HTML, TermCounter, Analysis of Indexing
- doubly linked list, Doubly Linked List
E
- element, Exercise 2, Parsing HTML
- Element, Using jsoup, TermCounter, Crawler Solution
- Elements, WikiFetcher
- encapsulate, List Interface
- Entry, Implementing MyLinearMap
- equals, Exercise 2, Classifying MyArrayList Methods, Analyzing MyLinearMap, How Does Hashing Work?
- exception, Classifying MyArrayList Methods
- external sorting, Heap Sort
F
- field, Redis Data Types
- FIFO, Stacks in Java, Graph Traversal
- findEntry, Exercise 7-Analyzing MyLinearMap
- findNode, Implementing a TreeMap, A Simple MyTreeMap
- fork, Working with the Code
- frequency, Data Structure Selection
G
- garbage collection, A Note on Garbage Collection
- generic type, Interfaces in Java
- get, Exercise 2, Classifying MyArrayList Methods, TermCounter, Exercise 6, Exercise 7-Analyzing MyLinearMap, Hashing, Exercise 8, The Tradeoffs, Implementing a TreeMap, The Logarithmic Methods
- getCounts, The Redis-Backed Indexer
- getNode, Classifying MyLinkedList Methods
- Getting to Philosophy, Interfaces, Search Engines, Getting to Philosophy, Exercise 5
- Git, Working with the Code
- GitHub, Working with the Code
- Google, Radix Sort
- graph, Graph Traversal
H
- HAS-A relationship, UML Class Diagrams
- hash code, Analyzing MyLinearMap, Hashing, Hashing and Mutation
- hash function, Hashing
- hash table, Interfaces, The Map Interface
- hashCode, How Does Hashing Work?
- hashing, Hashing, Analyzing MyHashMap
- HashMap, Interfaces, TermCounter, HashMap, Analysis of Indexing
- haystack, Analyzing MyLinearMap
- heap, Heap Sort
- heap property, Heap Sort
- heap sort, Heap Sort-Heap Sort
- height, Binary Search Tree, Implementing a TreeMap
- helper class, Making a Redis-Backed Index, Exercise 12, Exercise 13
- helper method, Exercise 2, Exercise 3, Classifying MyLinkedList Methods, Exercise 7, Hashing, Implementing a TreeMap-Implementing a TreeMap, Exercise 11, The Redis-Backed Indexer
- Heroku, Extensions
- HTML, Parsing HTML
I
- IDE, Exercise 1
- immutable, Hashing and Mutation
- implementation, Exercise 1
- in-order, Depth-First Search, Implementing a TreeMap, In-Order Traversal
- index, Indexer
- Index, Exercise 6, Crawler Solution
- indexer, Interfaces, Search Engines, Persistence
- Indexer, Persistence
- indexOf, Exercise 2, Classifying MyArrayList Methods, Classifying MyLinkedList Methods
- indexPage, Exercise 6
- information retrieval, Interfaces, Information Retrieval
- inheritance, UML Class Diagrams
- insertion sort, Insertion Sort
- inspecting the DOM, Parsing HTML
- instance variable, Exercise 2
- instantiate, List Interface
- Integer, Interfaces in Java
- interactive development environment, Exercise 1
- interface, Prerequisites, Why Are There Two Kinds of List?, Exercise 1
- interface-based programming, List Interface
- intersection, Boolean Search
- inverse document frequency, Exercise 13
- IS-A relationship, UML Class Diagrams
- isEmpty, Stacks in Java, Iterables and Iterators
- Iterable, Iterables and Iterators
- iterative, Implementing put
- iterative DFS, Iterative DFS
- Iterator, Iterables and Iterators
J
- Java Collections Framework, Prerequisites
- Java SDK, Working with the Code, Exercise 1
- JCF, Prerequisites
- Jedis, Redis Clients and Servers
- JedisIndex, Making a Redis-Backed Index, Exercise 11, The Redis-Backed Indexer, Exercise 12
- JedisMaker, Making a Redis-Backed Index, Exercise 12, Exercise 13
- JSON, Redis
- jsoup, Parsing HTML, Using jsoup
- JUnit, Prerequisites
K
- k largest elements, Bounded Heap
- key, Data Structure Selection, Binary Search Tree
- key-value database, Redis
- key-value pair, Data Structure Selection, Exercise 10
- keySet, Implementing a TreeMap, In-Order Traversal
L
- LIFO, Stacks in Java, Graph Traversal
- linear search, The Logarithmic Methods
- linear time, Analysis of Algorithms, Selection Sort, Exercise 2, Classifying MyArrayList Methods, Classifying add-Classifying add, Exercise 3, A Note on Garbage Collection, Classifying MyLinkedList Methods, Interpreting Results, Interpreting Results-Exercise 4, Performance Profiling Results, Profiling LinkedList Methods-Adding to the End of a LinkedList, Choosing a Structure, Analyzing MyLinearMap-Analyzing MyLinearMap, Hashing, Exercise 8, Analyzing MyHashMap, The Tradeoffs, Fixing MyHashMap, What’s Wrong with Hashing?, Exercise 10, Searching for Values, The Logarithmic Methods, Analysis of Lookup, Insertion Sort, Analysis of Merge Sort-Radix Sort, Bounded Heap
- linearithmic, Heap Sort
- linearithmic time, Sorting, Analysis of Merge Sort
- linked data structures, Linked Data Structures
- linked list, Linked Data Structures
- LinkedHashSet, In-Order Traversal
- LinkedList, Interfaces-List Interface, Exercise 4, Profiling LinkedList Methods-Adding to the End of a LinkedList, Doubly Linked List, Iterative DFS, Crawler Solution
- List, Interfaces-List Interface, Insertion Sort
- ListClientExample, List Interface
- ListNode, Linked Data Structures
- ListSorter, Insertion Sort, Exercise 14, Heap Sort
- load factor, Exercise 9
- log time, Binary Search Tree
- log-log scale, Interpreting Results
- logarithm, Interpreting Results, Binary Search Tree, Analysis of Merge Sort
- logarithmic time, The Logarithmic Methods, Self-Balancing Trees, Heap Sort
- lookup, Data Structure Selection
M
- Map, Interfaces, TermCounter, Hashing, TreeMap, Exercise 10
- map, Data Structure Selection, The Map Interface
- merge sort, Exercise 14
- mergeSort, Exercise 14
- minus, Exercise 13
- mutable, Hashing and Mutation
- MyArrayList, Exercise 2, Comparing MyArrayList and MyLinkedList
- MyBetterMap, Hashing, Exercise 8, Exercise 9
- MyFixedHashMap, Fixing MyHashMap
- MyHashMap, Exercise 9, Profiling MyHashMap
- MyLinearMap, Implementing MyLinearMap
- MyLinkedList, Exercise 3-Exercise 3, Comparing MyArrayList and MyLinkedList
- MyTreeMap, Implementing a TreeMap, A Simple MyTreeMap
N
- n log n, Analysis of Merge Sort, Heap Sort
- natural order, Comparable and Comparator
- next, Iterables and Iterators
- node, Linked Data Structures, Binary Search Tree
- Node, Exercise 3, Using jsoup, Exercise 10
- non-comparison sort, Radix Sort
- null, Linked Data Structures
- Number, Interfaces in Java
O
- Obama, Barack, Radix Sort
- object diagram, Linked Data Structures, Exercise 6
- offer, Heap Sort
- or, Exercise 13
- order of growth, Big O Notation, Comparing MyArrayList and MyLinkedList, Choosing a Structure, Binary Search Tree
- ordering, Comparable and Comparator
- out of core algorithm, Heap Sort
P
- parent node, Parsing HTML
- parsing, Parsing HTML
- peek, Stacks in Java
- performance bug, A Note on Garbage Collection, Profiling MyHashMap
- persistent, Redis
- poll, Heap Sort
- pop, Stacks in Java
- post-order, Depth-First Search
- pre-order, Depth-First Search
- PriorityQueue, Heap Sort
- problem size, Problem Size, Performance Profiling Results
- ProfileListAdd, Exercise 4
- Profiler, Profiling, Performance Profiling Results
- profiling, Analysis of Algorithms, Profiling, Performance Profiling Results, Performance Profiling Results, Adding to the End of a LinkedList, Profiling MyHashMap, Fixing MyHashMap, The Logarithmic Methods
- programming to an interface, List Interface
- push, Stacks in Java
- put, TermCounter, Exercise 7, Analyzing MyLinearMap, Hashing, Exercise 8, Analyzing MyHashMap, The Tradeoffs, Fixing MyHashMap, Implementing a TreeMap, Implementing put, The Logarithmic Methods
Q
- quadratic time, Analysis of Algorithms, Selection Sort, Problem Size, Classifying MyLinkedList Methods, Interpreting Results-Exercise 4, Performance Profiling Results, Adding to the End of a LinkedList, Insertion Sort, Radix Sort
- query, Boolean Search
- queue, Stacks in Java, Graph Traversal, Crawler Solution
- Queue, Heap Sort
R
- radix sort, Radix Sort
- raw type, Exercise 1
- recursion, Depth-First Search, Implementing a TreeMap, Searching for Values-Searching for Values, In-Order Traversal, Exercise 14
- red-black tree, Self-Balancing Trees
- Redis, The Philosophy Behind the Book, Redis, The Redis-Backed Indexer
- Redis data type, Redis Data Types
- Redis get, Redis Data Types
- Redis hash, Redis Data Types
- Redis instance, Redis Clients and Servers
- Redis list, Redis Data Types
- Redis set, Redis Data Types
- RedisToGo, Redis Clients and Servers
- regular expression, TermCounter
- rehash, Exercise 9
- relevance, Exercise 13, Extensions
- remove, Exercise 2, Classifying MyArrayList Methods, Exercise 3, Classifying MyLinkedList Methods, Exercise 7, The Tradeoffs, Fixing MyHashMap, One More Exercise
- removeAll, Problem Size
- repository, Working with the Code
- retriever, Interfaces, Search Engines, Persistence
- root, Parsing HTML
S
- Schmidt, Eric, Radix Sort
- search engine, Interfaces, Search Engines, Persistence
- search term, Search Engines, Indexer
- select, Using jsoup
- selection sort, Selection Sort
- self-balancing tree, Self-Balancing Trees
- server, Redis Clients and Servers, More Suggestions If You Want Them, Space Complexity
- set, Exercise 2, Classifying MyArrayList Methods
- Set, Data Structure Selection
- set intersection, Data Structure Selection
- set operations, Boolean Search
- setChar, Hashing and Mutation
- SillyArray, Hashing and Mutation
- SillyString, How Does Hashing Work?
- singleton, WikiFetcher
- size, Exercise 3, Exercise 6, Fixing MyHashMap, Fixing MyHashMap, Exercise 10
- slope, Interpreting Results
- snippet, Extensions
- sort, Exercise 13
- sorting, Selection Sort, Sorting
- space complexity, Space Complexity
- special case, Exercise 3
- Stack, Stacks in Java
- stack, Stacks in Java, Graph Traversal
- stop words, Analysis of Indexing
- sub-map, Hashing, How Does Hashing Work?, HashMap
- subclass, Using jsoup
- subtree, Implementing put
- superclass, Exercise 9, Fixing MyHashMap, Implementing a TreeMap
T
- tag, Parsing HTML
- term frequency, Exercise 13
- TermCounter, TermCounter, Exercise 11, The Redis-Backed Indexer, Analysis of Indexing
- ternary operator, Interfaces in Java
- TextNode, Iterating Through the DOM
- TF-IDF, Exercise 13, Extensions
- Timeable, Profiling
- timestamp, The Logarithmic Methods
- toString, How Does Hashing Work?
- Transaction, More Suggestions If You Want Them, The Redis-Backed Indexer, Analysis of Lookup
- traversal, Graph Traversal
- tree, Interfaces
- tree traversal, Depth-First Search, Implementing a TreeMap, In-Order Traversal
- TreeMap, TreeMap
- type parameter, Prerequisites, Exercise 2, Exercise 3, Implementing MyLinearMap, Insertion Sort
- type wildcard, Implementing a TreeMap, A Simple MyTreeMap
U
- UML, UML Class Diagrams
- UML diagram, Using jsoup
- unbalanced tree, The Logarithmic Methods
- Unicode, How Does Hashing Work?
- union, Boolean Search
- unit of work, Analyzing MyHashMap
- unit testing, The Philosophy Behind the Book, Exercise 1
- URL, TermCounter, Exercise 6
- URLSet, Exercise 11, The Redis-Backed Indexer
- UUID, The Logarithmic Methods
V
- value, Data Structure Selection
- version control, The Philosophy Behind the Book, Working with the Code
- volatile, Redis
W
- web search, The Philosophy Behind the Book, Interfaces
- WikiCrawler, Exercise 12, Crawler Solution
- WikiFetcher, WikiFetcher, TermCounter, Making a Redis-Backed Index, Exercise 11
- WikiNodeIterable, Iterating Through the DOM, Iterables and Iterators
- WikiNodeIterator, Iterables and Iterators
- Wikipedia, Search Engines, Crawler Solution
- WikiPhilosophy, Getting Started
- WikiSearch, Exercise 13
- wrapper method, TermCounter
X
- XYSeries, Profiling
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.