rearranged

Author: lyuka

README.md

@@ -0,0 +1,4 @@
+data_structure_and_algorithm_using_python
+=========================================
+
+code in book "data structure and algorithm using python"

gameoflife.py

@@ -0,0 +1,55 @@
+# Program for playing the game of Life.
+from life import LifeGrid
+
+# Define the initial configuration of live cells.
+INIT_CONFIG = [ (1, 2), (2, 1), (2, 2), (2, 3) ]
+
+# Set the size of the grid.
+GRID_WIDTH = 5
+GRID_HEIGHT = 5
+
+# Indicate the number of generations.
+NUM_GENS = 8
+
+def main():
+	# Construct the game grid and confiture it.
+	grid = LifeGrid( GRID_WIDTH, GRID_HEIGHT)
+	grid.configure( INIT_CONFIG )
+
+	# Play the game.
+	draw( grid )
+	for i in range( NUM_GENS ):
+		evolve( grid )
+		draw( grid )
+
+# Generates the next generation of organisms.
+def evolve( grid ):
+	# List for storing the live cells of the next generation.
+	liveCells = list()
+
+	# Iterate over the elements of the grid.
+	for i in range( grid.numRows() ):
+		for j in range( grid.numCols() ):
+
+			#print '( ' + str(i) + ', ' + str(j)  + ' )',
+
+			# Determine the number of live neighbors for this cell.
+			neighbors = grid.numLiveNeighbors( i, j )
+
+			#print neighbors
+
+			# Add the (i, j) tuple to liveCells if this cell contains
+			# a live organisms in the next generation.
+			if (neighbors == 2 and grid.isLiveCell(i, j)) or (neighbors == 3):
+				liveCells.append( (i, j) )
+
+	# Reconfigure the grid using the liveCells coord list.
+	grid.configure( liveCells )
+
+# Prints a text-based representation of the game grid.
+def draw( grid ):
+	grid.print_config()
+	print ""
+
+# Executes the main routine
+main()

life.py

@@ -0,0 +1,82 @@
+# Implements the LifeGrid ADT for the use with the game of Life.
+from myarray import myArray2D
+
+class LifeGrid:
+	# Defines constants to represent the cell states.
+	DEAD_CELL = 0
+	LIVE_CELL = 1
+
+	# Creates the game grid and initializes the cells to dead.
+	def __init__( self, numRows, numCols ):
+		# Allocate the 2-D array for the grid.
+		self._grid = myArray2D( numRows, numCols )
+		# Clear the grid and set all cells to dead.
+		self.configure( list() )
+
+	# Returns the number of rows in the grid.
+	def numRows( self ):
+		return self._grid.numRows()
+
+	# Returns the number of columns in the grid.
+	def numCols( self ):
+		return self._grid.numCols()
+
+	# Configures the grid to contain the given live cells.
+	def configure( self, coordList ):
+		# Clear the game grid.
+		for i in range( self.numRows() ):
+			for j in range( self.numCols() ):
+				self.clearCell(i, j)
+
+		# Set the indicated cells to be alive
+		for coord in coordList:
+			self.setCell( coord[0], coord[1])
+
+	# Does the indicated cell contain  a live organism?
+	def isLiveCell( self, row, col ):
+		return self._grid[row, col] == self.LIVE_CELL
+
+	# Clears the indicated cell by setting it to dead.
+	def clearCell( self, row, col ):
+		self._grid[row, col] = self.DEAD_CELL
+
+	def setCell( self, row, col ):
+		self._grid[row, col] = self.LIVE_CELL
+
+	# Returns the number of live neighbors for the given cell.
+	def numLiveNeighbors( self, row, col ):
+		#print str(row) + ' , ' + str(col)
+		alive_cnt = 0
+		for i in [-1, 0, 1]:
+			for j in [-1, 0, 1]:
+				if row + i >= 0 and row + i < self.numRows() and col + j >= 0 and col + j < self.numCols():
+					if self.isLiveCell(row+i, col+j):
+						alive_cnt += 1
+						#print '( ' + str(row+i) + ', ' + str(col+j) + ' ): ' + 'YES' 
+		return alive_cnt - self.isLiveCell(row, col)
+
+	# Prints the current configure
+	def print_config( self ):
+		for i in range( self.numRows() ):
+			for j in range( self.numCols() ):
+				print self._grid[i, j], 
+			print ""
+
+if __name__ == '__main__':
+	init_grid = LifeGrid(5, 5)
+	init_grid.print_config()
+
+	print ""
+
+	#for i in range( init_config.numRows() ):
+	#	for j in range( init_config.numRows() ):
+	#		init_config.setCell(i, j)
+	init_grid.configure([ (1, 2), (2, 1), (2, 2), (2, 3) ])
+	init_grid.print_config()
+	print init_grid.numLiveNeighbors(1, 2)
+	#for i in range(5):
+	#	for j in range(5):
+	#		print '( ' + str(i) + ', ' + str(j)  + ' )',
+	#		print init_grid.numLiveNeighbors(i, j)
+
+

linearmap.py

@@ -0,0 +1,95 @@
+# Implementation of Map ADT using a single list.
+class myMap:
+    # Creates an empty map instance.
+    def __init__( self ):
+        self._entryList = list()
+    
+    # Returns the number of entries in the map.
+    def __len__( self ):
+        return len( self._entryList )
+
+    # Determines if the map contains the given key.
+    def __contains__( self, key ):
+        ndx = self._findPosition( key )
+        return ndx is not None
+
+    # Adds a new entry to the map if the key does exist. Otherwise, the
+    # new value replaces the current value assocaited with the key.
+    def add( self, key, value ):
+        ndx = self._findPosition( key )
+        if ndx is not None:
+            self._entryList[ndx].value = value
+            return False
+        else:
+            entry = _MapEntry( key, value )
+            self._entryList.append( entry )
+            return True
+
+    # Returns the value associated with the key.
+    def Valueof( self, key ):
+        ndx = self._findPosition( key )
+        assert ndx is not None, "Invalid map key. "
+        return self._entryList[ndx].value
+
+    # Removes the entry associated with the key.
+    def remove( self, key ):
+        ndx = self._findPosition( key )
+        assert ndx is not None, "Invalid map key. "
+        self._entryList.pop( ndx )
+
+    # Returns an iterator for traversing the keys in the map.
+    def __iter__( self ):
+        return _MapIterator( self._entryList )
+
+    # Helper method used to find the index position of a category. If the
+    # key is not found, None is returned.
+    def _findPosition( self, key ):
+        for i in range( len(self) ):
+            if self._entryList[i].key == key:
+                return i
+        return None
+
+# Storage class for holding the key/value pairs.
+class _MapEntry:
+    def __init__( self, key, value ):
+        self.key = key
+        self.value = value
+
+# An iterator for the Map ADT
+class _MapIterator:
+    def __init__( self, theEntryList ):
+        self._entryItems = theEntryList
+        self._curItem = 0
+
+    def __iter__( self ):
+        return self
+
+    def next( self ):
+        if self._curItem < len( self._entryItems ):
+            entry = self._entryItems[ self._curItem ]
+            self._curItem += 1
+            return entry
+        else:
+            raise StopIteration
+
+
+if __name__ == '__main__':
+    StuMap = myMap()
+    print StuMap
+
+    StuMap.add('0301', 'Bell')
+    StuMap.add('0302', 'Tang')
+    StuMap.add('0303', 'Liu')
+    StuMap.add('0304', 'James')
+    print StuMap
+
+    for entry in StuMap:
+        print entry.key, 
+        print entry.value
+    print ""
+
+    StuMap.add('0303', 'Ronadol')
+    for entry in StuMap:
+        print entry.key,
+        print entry.value
+    print ""

linearset.py

@@ -0,0 +1,139 @@
+# Implementation of the Set ADT container using a Python list
+class mySet:
+    # Creates an empty set instance
+    def __init__( self ):
+        self._theElements = list()
+
+    # Returns the number of items in the set.
+    def __len__( self ):
+        return len( self._theElements )
+
+    # Determines if an element is in the set.
+    def __contains__( self, element ):
+        return element in self._theElements
+
+    # Adds a new unique element to the set.
+    def add( self, element ):
+        if element not in self:
+            self._theElements.append( element )
+
+    # Removes an element from the set.
+    def remove( self, element ):
+        assert element in self, "The element must be in the set."
+        self._theElements.remove( item )
+
+    # Determins if two sets are equal.
+    def __eq__( self, setB):
+        if len( self ) != len( setB ):
+            return False
+        else:
+            return self.isSubsetOf( setB )
+
+    # Determins if this set is a subset of setB.
+    def isSubsetOf( self, setB ):
+        for element in self:
+            if element not in setB:
+                return False
+        return True
+
+    # Creates a new set from the union of this set and setB
+    def union( self, setB ):
+        newSet = mySet()
+        newSet._theElements.extend( self._theElements )
+        for element in setB:
+            if element not in self : 
+                newSet._theElements.append( element )
+        return newSet
+
+    # Creates a new set from the intersection: self set and setB.
+    def interset( self, setB ):
+        newSet = mySet()
+        for element in self:
+            if element in setB:
+                newSet._theElements.append( element )
+        return newSet
+
+    # Creates a new set from the difference: self set and setB.
+    def difference( self, setB ):
+        newSet = mySet()
+        for element in self:
+            if element not in setB:
+                newSet._theElements.append( element )
+        return newSet
+
+    # Returns an iterator for traversing the list of items.
+    def __iter__( self ):
+        return _SetIterator( self._theElements )
+
+# An iterator for the Set ADT.
+class _SetIterator:
+    def __init__( self, theSet ):
+        self._setRef = theSet
+        self._curNdx = 0
+
+    def __iter__( self ):
+        return self
+
+    def next( self ):
+        if self._curNdx < len( self._setRef ):
+            entry = self._setRef[ self._curNdx ]
+            self._curNdx += 1
+            return entry
+        else:
+            raise StopIteration
+
+
+if __name__ == '__main__':
+    mySetA = mySet()
+    mySetA.add(6)
+    mySetA.add(3)
+    mySetA.add(2)
+    mySetA.add(1)
+    mySetA.add(3)
+    print "Set A: "
+    for ele in mySetA:
+        print ele, 
+    print ""
+    
+    mySetB = mySet()
+    mySetB.add(4)
+    mySetB.add(1)
+    mySetB.add(7)
+    mySetB.add(2)
+    print "Set B: "
+    for ele in mySetB:
+        print ele,
+    print ""
+
+    # Set Union
+    mySetC = mySetA.union(mySetB)
+    print "A + B: "
+    for ele in mySetC:
+        print ele,
+    print ""
+
+    # Set Interset
+    mySetD = mySetA.interset(mySetB)
+    print "interset(A, B)"
+    for ele in mySetD:
+        print ele,
+    print ""
+
+    mySetE = mySetB.interset(mySetA)
+    print "interset(B, A)"
+    for ele in mySetE:
+        print ele,
+    print ""
+
+    # Set difference
+    mySetF = mySetA.difference(mySetB)
+    print "A - B: "
+    for ele in mySetF:
+        print ele,
+    print ""
+
+    mySetG = mySetB.difference(mySetA)
+    print "B - A: "
+    for ele in mySetG:
+        print ele,
+    print ""