source code for chapter 10

Author: shenzhun

ch10/__init__.py

@@ -0,0 +1 @@
+__all__ = ['chain_hash_map', 'cost_performance', 'multi_map', 'probe_hash_map', 'sorted_table_map', 'unsorted_table_map']

ch10/chain_hash_map.py

@@ -0,0 +1,52 @@
+# Copyright 2013, Michael H. Goldwasser
+#
+# Developed for use with the book:
+#
+#    Data Structures and Algorithms in Python
+#    Michael T. Goodrich, Roberto Tamassia, and Michael H. Goldwasser
+#    John Wiley & Sons, 2013
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from .hash_map_base import HashMapBase
+from .unsorted_table_map import UnsortedTableMap
+
+class ChainHashMap(HashMapBase):
+  """Hash map implemented with separate chaining for collision resolution."""
+
+  def _bucket_getitem(self, j, k):
+    bucket = self._table[j]
+    if bucket is None:
+      raise KeyError('Key Error: ' + repr(k))        # no match found
+    return bucket[k]                                 # may raise KeyError
+
+  def _bucket_setitem(self, j, k, v):
+    if self._table[j] is None:
+      self._table[j] = UnsortedTableMap()     # bucket is new to the table
+    oldsize = len(self._table[j])
+    self._table[j][k] = v
+    if len(self._table[j]) > oldsize:         # key was new to the table
+      self._n += 1                            # increase overall map size
+
+  def _bucket_delitem(self, j, k):
+    bucket = self._table[j]
+    if bucket is None:
+      raise KeyError('Key Error: ' + repr(k))        # no match found
+    del bucket[k]                                    # may raise KeyError
+
+  def __iter__(self):
+    for bucket in self._table:
+      if bucket is not None:                         # a nonempty slot
+        for key in bucket:
+          yield key

ch10/cost_performance.py

@@ -0,0 +1,49 @@
+# Copyright 2013, Michael H. Goldwasser
+#
+# Developed for use with the book:
+#
+#    Data Structures and Algorithms in Python
+#    Michael T. Goodrich, Roberto Tamassia, and Michael H. Goldwasser
+#    John Wiley & Sons, 2013
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from .sorted_table_map import SortedTableMap
+
+class CostPerformanceDatabase:
+  """Maintain a database of maximal (cost,performance) pairs."""
+
+  def __init__(self):
+    """Create an empty database."""
+    self._M = SortedTableMap()             # or a more efficient sorted map
+
+  def best(self, c):
+    """Return (cost,performance) pair with largest cost not exceeding c.
+
+    Return None if there is no such pair.
+    """
+    return self._M.find_le(c)
+
+  def add(self, c, p):
+    """Add new entry with cost c and performance p."""
+    # determine if (c,p) is dominated by an existing pair
+    other = self._M.find_le(c)              # other is at least as cheap as c
+    if other is not None and other[1] >= p: # if its performance is as good,
+        return                              # (c,p) is dominated, so ignore
+    self._M[c] = p                          # else, add (c,p) to database
+    # and now remove any pairs that are dominated by (c,p)
+    other = self._M.find_gt(c)              # other more expensive than c
+    while other is not None and other[1] <= p:
+      del self._M[other[0]]
+      other = self._M.find_gt(c)

ch10/hash_map_base.py

@@ -0,0 +1,71 @@
+# Copyright 2013, Michael H. Goldwasser
+#
+# Developed for use with the book:
+#
+#    Data Structures and Algorithms in Python
+#    Michael T. Goodrich, Roberto Tamassia, and Michael H. Goldwasser
+#    John Wiley & Sons, 2013
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from .map_base import MapBase
+from collections import MutableMapping
+from random import randrange         # used to pick MAD parameters
+
+class HashMapBase(MapBase):
+  """Abstract base class for map using hash-table with MAD compression.
+
+  Keys must be hashable and non-None.
+  """
+
+  def __init__(self, cap=11, p=109345121):
+    """Create an empty hash-table map.
+
+    cap     initial table size (default 11)
+    p       positive prime used for MAD (default 109345121)
+    """
+    self._table = cap * [ None ]
+    self._n = 0                                   # number of entries in the map
+    self._prime = p                               # prime for MAD compression
+    self._scale = 1 + randrange(p-1)              # scale from 1 to p-1 for MAD
+    self._shift = randrange(p)                    # shift from 0 to p-1 for MAD
+
+  def _hash_function(self, k):
+    return (hash(k)*self._scale + self._shift) % self._prime % len(self._table)
+
+  def __len__(self):
+    return self._n
+
+  def __getitem__(self, k):
+    j = self._hash_function(k)
+    return self._bucket_getitem(j, k)             # may raise KeyError
+
+  def __setitem__(self, k, v):
+    j = self._hash_function(k)
+    self._bucket_setitem(j, k, v)                 # subroutine maintains self._n
+    if self._n > len(self._table) // 2:           # keep load factor <= 0.5
+      self._resize(2 * len(self._table) - 1)      # number 2^x - 1 is often prime
+
+  def __delitem__(self, k):
+    j = self._hash_function(k)
+    self._bucket_delitem(j, k)                    # may raise KeyError
+    self._n -= 1
+
+  def _resize(self, c):
+    """Resize bucket array to capacity c and rehash all items."""
+    old = list(self.items())       # use iteration to record existing items
+    self._table = c * [None]       # then reset table to desired capacity
+    self._n = 0                    # n recomputed during subsequent adds
+    for (k,v) in old:
+      self[k] = v                  # reinsert old key-value pair

ch10/map_base.py

@@ -0,0 +1,43 @@
+# Copyright 2013, Michael H. Goldwasser
+#
+# Developed for use with the book:
+#
+#    Data Structures and Algorithms in Python
+#    Michael T. Goodrich, Roberto Tamassia, and Michael H. Goldwasser
+#    John Wiley & Sons, 2013
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from collections import MutableMapping
+
+class MapBase(MutableMapping):
+  """Our own abstract base class that includes a nonpublic _Item class."""
+
+  #------------------------------- nested _Item class -------------------------------
+  class _Item:
+    """Lightweight composite to store key-value pairs as map items."""
+    __slots__ = '_key', '_value'
+
+    def __init__(self, k, v):
+      self._key = k
+      self._value = v
+
+    def __eq__(self, other):               
+      return self._key == other._key   # compare items based on their keys
+
+    def __ne__(self, other):
+      return not (self == other)       # opposite of __eq__
+
+    def __lt__(self, other):               
+      return self._key < other._key    # compare items based on their keys

ch10/multi_map.py

@@ -0,0 +1,76 @@
+# Copyright 2013, Michael H. Goldwasser
+#
+# Developed for use with the book:
+#
+#    Data Structures and Algorithms in Python
+#    Michael T. Goodrich, Roberto Tamassia, and Michael H. Goldwasser
+#    John Wiley & Sons, 2013
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+class MultiMap:
+  """
+  A multimap class built upon use of an underlying map for storage.
+
+  This uses dict for default storage.
+
+  Subclasses can override class variable _MapType to change the default.
+  That catalog class must have a default constructor that produces an empty map.
+  As an example, one might define the following subclass to use a SortedTableMap
+ 
+  class SortedTableMultimap(MultiMap):
+    _MapType = SortedTableMap
+  """
+  _MapType = dict                 # Map type; can be redefined by subclass
+
+  def __init__(self):
+    """Create a new empty multimap instance."""
+    self._map = self._MapType()          # create map instance for storage
+    self._n = 0
+
+  def __len__(self):
+    """Return number of (k,v) pairs in multimap."""
+    return self._n
+
+  def __iter__(self):
+    """Iterate through all (k,v) pairs in multimap."""
+    for k,secondary in self._map.items():
+      for v in secondary:
+        yield (k,v)
+    
+  def add(self, k, v):
+    """Add pair (k,v) to multimap."""
+    container = self._map.setdefault(k, [])     # create empty list, if needed
+    container.append(v)
+    self._n += 1
+
+  def pop(self, k):
+    """Remove and return arbitrary (k,v) pair with key k (or raise KeyError)."""
+    secondary = self._map[k]                    # may raise KeyError
+    v = secondary.pop()
+    if len(secondary) == 0:
+      del self._map[k]                          # no pairs left
+    self._n -= 1
+    return (k, v)
+
+  def find(self, k):
+    """Return arbitrary (k,v) pair with given key (or raise KeyError)."""
+    secondary = self._map[k]                    # may raise KeyError
+    return (k, secondary[0])
+    
+  def find_all(self, k):
+    """Generate iteration of all (k,v) pairs with given key."""
+    secondary = self._map.get(k, [])            # empty list, by default
+    for v in secondary:
+      yield (k,v)

ch10/probe_hash_map.py

@@ -0,0 +1,73 @@
+# Copyright 2013, Michael H. Goldwasser
+#
+# Developed for use with the book:
+#
+#    Data Structures and Algorithms in Python
+#    Michael T. Goodrich, Roberto Tamassia, and Michael H. Goldwasser
+#    John Wiley & Sons, 2013
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from .hash_map_base import HashMapBase
+
+class ProbeHashMap(HashMapBase):
+  """Hash map implemented with linear probing for collision resolution."""
+  _AVAIL = object()       # sentinal marks locations of previous deletions
+
+  def _is_available(self, j):
+    """Return True if index j is available in table."""
+    return self._table[j] is None or self._table[j] is ProbeHashMap._AVAIL
+
+  def _find_slot(self, j, k):
+    """Search for key k in bucket at index j.
+
+    Return (success, index) tuple, described as follows:
+    If match was found, success is True and index denotes its location.
+    If no match found, success is False and index denotes first available slot.
+    """
+    firstAvail = None
+    while True:                               
+      if self._is_available(j):
+        if firstAvail is None:
+          firstAvail = j                      # mark this as first avail
+        if self._table[j] is None:
+          return (False, firstAvail)          # search has failed
+      elif k == self._table[j]._key:
+        return (True, j)                      # found a match
+      j = (j + 1) % len(self._table)          # keep looking (cyclically)
+
+  def _bucket_getitem(self, j, k):
+    found, s = self._find_slot(j, k)
+    if not found:
+      raise KeyError('Key Error: ' + repr(k))        # no match found
+    return self._table[s]._value
+
+  def _bucket_setitem(self, j, k, v):
+    found, s = self._find_slot(j, k)
+    if not found:
+      self._table[s] = self._Item(k,v)               # insert new item
+      self._n += 1                                   # size has increased
+    else:
+      self._table[s]._value = v                      # overwrite existing
+
+  def _bucket_delitem(self, j, k):
+    found, s = self._find_slot(j, k)
+    if not found:
+      raise KeyError('Key Error: ' + repr(k))        # no match found
+    self._table[s] = ProbeHashMap._AVAIL             # mark as vacated
+
+  def __iter__(self):
+    for j in range(len(self._table)):                # scan entire table
+      if not self._is_available(j):
+        yield self._table[j]._key