CS211 - Data Structure and Algorithms

Arrays and Lists

Lecture # 2
Nasir Uddin

1
Nasir Uddin
 CS211 - Data Structure and Algorithms

Arrays
• A one-dimensional array is composed of multiple sequential elements
stored in contiguous bytes of memory and allows for random access
to the individual elements.
• Array contains fixed number of elements
• Individual elements within the array can be accessed directly form
their index values.
• Occupy less memory as compared to python list
• Internal processing is faster than python lists

2
Nasir Uddin
 CS211 - Data Structure and Algorithms

Array ADT

3
Nasir Uddin
 CS211 - Data Structure and Algorithms

Array Class in Python

# Fill a 1-D array with random values, then print them, one per line.
from array import Array
import random
# The constructor is called to create the array.
valueList = Array( 100 )
# Fill the array with random floating-point values.
for i in range( len( valueList ) ) :
valueList[ i ] = random.random()
# Print the values, one per line.
for value in valueList :
print( value )

4
Nasir Uddin
 CS211 - Data Structure and Algorithms

Array Class in Python

#Count the number of occurrences of each letter in a text file.
from array import Array
# Create an array for the counters and initialize each element to 0.
theCounters = Array( 127 )
theCounters.clear( 0 )
# Open the text file for reading and extract each line from the file
# and iterate over each character in the line.
theFile = open( 'atextfile.txt', 'r' )
for line in theFile :
for letter in line :
code = ord( letter )
theCounters[code] += 1
# Close the file
theFile.close()
# Print the results. The uppercase letters have ASCII values in the
# range 65..90 and the lowercase letters are in the range 97..122.
for i in range( 26 ) :
print( "%c - %4d %c - %4d" % \
(chr(65+i), theCounters[65+i], chr(97+i), theCounters[97+i]) )
5
Nasir Uddin
 CS211 - Data Structure and Algorithms

Implementing the Array

6
Nasir Uddin
 CS211 - Data Structure and Algorithms

Implementing the Array

7
Nasir Uddin
 CS211 - Data Structure and Algorithms

Implementing the Array

8
Nasir Uddin
 CS211 - Data Structure and Algorithms

Using the Array

import random
myarray = Array(10)
print("myarray legth is: ",len(myarray))
for i in range(len(myarray)):
item =random.random()
print("{} --> {:.2f}".format(i,item))
myarray[i]=item

print ("myarray initialized upto {} values".format(len(myarray)))

aindex = int(input("Enter the index value of array element: "))

print("The array index '{}' contains item {:.2f}".format(aindex,myarray[aindex]))

9
Nasir Uddin
 CS211 - Data Structure and Algorithms

Using the Array - output

myarray length is: 10
0 --> 0.26
1 --> 0.21
2 --> 0.12
3 --> 0.12
4 --> 0.76
5 --> 0.73
6 --> 0.74
7 --> 0.86
8 --> 1.00
9 --> 0.48
myarray is initialized upto 10 values
Enter the index value of array element: 9
The array index '9' contains item 0.48

10
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Python List

• Python's list structure is a
mutable sequence container
that can change size as items are
added or removed.
• It is an abstract data type that is
implemented using an array
structure to store the items
contained in the list.
• For example
• pyList = [ 4, 12, 2, 34, 17 ]

11
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Python List – Appending item

• Appending an item
• pyList.append( 50 )
• Appending more items
• pyList.append( 18 )
• pyList.append( 64 )
• pyList.append( 6 )

• when the third statement is

executed, the array will have to be
expanded to make room for value 6.
• To allow for the expansion of the
list, the following steps have to be
performed:
12
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Python List – Appending item

• To allow for the expansion of the
list, the following steps have to
be performed:
1. a new array is created with
additional capacity,
2. the items from the original array
are copied to the new array,
3. the new larger array is set as the
data structure for the list, and
4. The original smaller array is
destroyed.

13
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Python List – Extending list

• A list can be appended to a
second list using the extend()
method as shown in the
following example:
• pyListA = [ 34, 12 ]
• pyListB = [ 4, 6, 31, 9 ]
• pyListA.extend( pyListB )

14
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Python List – Inserting items

• An item can be inserted anywhere
within the list using the insert()
method. In the following example:
• pyList.insert( 3, 79 )
a) the array elements are shifted to
the right one at a time, traversing
from right to left,
b) the new value is then inserted into
the array at the given position,
c) the result after inserting the item.

15
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Python List – Removing items

• An item can be removed from
any position within the list using
the pop() method.
• pyList.pop( 0 ) # remove the first item
a) a copy of the item is saved;
b) the array elements are shifted
to the left one at a time,
traversing left to right and
c) the size of the list is
decremented by one.
16
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Python List - List Slice

• Slicing is an operation that
creates a new list consisting of a
contiguous subset of elements
from the original list.
• The original list is not modified by
this operation.
• Instead, references to the
corresponding elements are
copied and stored in the new list.
• aSlice = pyList[2:3]

17
Nasir Uddin
 CS211 - Data Structure and Algorithms

Two-Dimensional Arrays
• Two-dimensional array arrange
data in rows and columns.
• The individual elements are
accessed by specifying two
indices, one for the row and one
for the column, [i,j].

18
Nasir Uddin
 CS211 - Data Structure and Algorithms

Two-Dimensional Arrays - ADT

19
Nasir Uddin
 CS211 - Data Structure and Algorithms

Implementing the 2-D Array

• an array of arrays to store the
elements of a 2-D array.
• Store each row of the 2-D array
within its own 1-D array.
• Then, another 1-D array is used
to store references to each of
the arrays used to store the row
elements.

20
Nasir Uddin
 CS211 - Data Structure and Algorithms

Implementing the 2-D Array

from myarray import Array

class Array2D:

def __init__(self, numRows, numCols):

self._theRows = Array(numRows)
for i in range(numRows):
self._theRows[i] = Array(numCols)

def numRows(self):
return len(self._theRows)

def numCols(self):
return len(self._theRows[0])

def clear(self, value):

for row in range(self.numRows()):
self._theRows[row].clear(value)
21
Nasir Uddin
 CS211 - Data Structure and Algorithms

Implementing the 2-D Array

def __getitem__(self, ndxTuple):
assert len(ndxTuple)==2, "Invalid number of array subscripts"
row = ndxTuple[0]
col = ndxTuple[1]
assert row >= 0 and row < self.numRows() \
and col >= 0 and col < self.numCols(),\
"Array subscript out of range"
the1dArray = self._theRows[row]
return the1dArray[col]

def __setitem__(self, ndxTuple, value):

assert len(ndxTuple)==2, "Invalid no of array subscripts"
row = ndxTuple[0]
col = ndxTuple[1]
assert row >=0 and row < self.numRows() \
and col >= 0 and col < self.numCols(), \
"Array subscript out of range."
the1dArray = self._theRows[row]
the1dArray[col] = value 22
Nasir Uddin
 CS211 - Data Structure and Algorithms

Implementing the 2-D Array

##-------------------------------------
## Implementation
##-------------------------------------
twoDArray = Array2D(3,3)
twoDArray.clear(0)

for i in range(twoDArray.numRows()):
print('')
for j in range(twoDArray.numCols()):
twoDArray[i,j] = int(input('enter value %d,%d = '%(i,j)))

print(‘Your 2D-Array is here:')

for i in range(twoDArray.numRows()):
print('')
for j in range(twoDArray.numCols()):
print(twoDArray[i,j],end =" ")
23
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Matrix Abstract Data Type

•  a matrix is an rectangular grid or table of numerical values divided
into rows and columns.

24
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Matrix Abstract Data Type

•  a matrix is an rectangular grid or table of numerical values divided
into rows and columns.

25
Nasir Uddin
 CS211 - Data Structure and Algorithms

Implementing the Matrix

26
Nasir Uddin
 CS211 - Data Structure and Algorithms

Implementing the Matrix

27
Nasir Uddin
 CS211 - Data Structure and Algorithms

Application: The Game of Life

1. If a cell is alive and has either two or three live neighbors, the cell remains alive
in the next generation. The neighbors are the eight cells immediately
surrounding a cell: vertically, horizontally, and diagonally.
2. A living cell that has no live neighbors or a single live neighbor dies from
isolation in the next generation.
3. A living cell that has four or more live neighbors dies from overpopulation in
the next generation.
4. A dead cell with exactly three live neighbors results in a birth and becomes
alive in the next generation. All other dead cells remain dead in the next
generation.

28
Nasir Uddin
 CS211 - Data Structure and Algorithms

Application: The Game of Life

29
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Game of Life - Designing a Solution

30
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Game of Life - Designing a Solution

31
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Game of Life - Designing a Solution

32
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Game of Life - Designing a Solution

33
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Game of Life - Designing a Solution

34
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Game of Life - Implementation

35
Nasir Uddin
 CS211 - Data Structure and Algorithms

The Game of Life - Implementation

36
Nasir Uddin
 CS211 - Data Structure and Algorithms

Assignment – 1
1. Implement Matrix class that can perform following operations,
• Addition
• Subtraction
• Scaling
• Transpose
• Multiplication
• Inverse of Matrix

37
Nasir Uddin
 CS211 - Data Structure and Algorithms

Assignment – 1
2. Implement the numLiveNeighbors() method of the
LifeGrid class.
3. Complete the implementation of the gameoflife.py program by
implementing the draw() function. The output should look
similar to the following, where dead cells are indicated using a
period and live cells are indicated using the @ symbol.
4. Modify the gameoflife.py program to prompt the user for the grid
size and the number of generations to evolve.
Due Date:
Submission: Microsoft Teams
38
Nasir Uddin