使用者的陣列操作

Array類中的方法

a = Array(10)  

__init__( capacity, fillValue = None ) 

len(a) 

__len__() 

str(a) 

__str__() 

for item in a: 

__iter__() 

a[index] 

__getitem__(index) 

a[index] = newItem 

__setitem__( index, newItem ) 

#!/usr/bin/env python

# -*- coding:utf-8 -*-

# Author:Lijunjie

"""

File: arrays.py

An array is like a list, but the client can use only [], len, iter, and str

To instantiate, use

<Varialbe> = Array( <capacity>, <optional fill value> )

The fill value is None by default.

"""

class Array( object ):

""" Represents an array """

def __init__( self, capacity, fillValue = None ):

""" Capacity is the static size of the array. fillValue is placed at each position. """

self._items = list()

for count in range( capacity ):

self._items.append( fillValue )

def __len__( self ):

""" -> The capacity of the array. """

return len( self._items )

def __str__( self ):

""" -> The string representation of the array """

return str( self._items )

def __iter__( self ):

"""Supports traversal with for loop."""

return iter( self._items )

def __getitem__( self, index ):

""" Subscript operator for access at index. """

return self._items[ index ]

def __setitem__( self, index, newItem ):

"""Subscript operator for replacement at index."""

self._items[index] = newItem

DEFAULT_CAPACITY = 5

logicalSize = 0

a = Array[DEFAULT_CAPACITY]

if logicalSize == len( a ):

temp = Array( len( a ) + 1 )

for i in range( logicalSize ):

temp[i] = a[i]

a = temp

temp = Array( len( a ) * 2 )

if logicalSize <= len(a) // 4 and len(a) >= DEFAULTCAPACTIY * 2:

temp = Array( len(a) // 2 )

for i in range( logicalSize ):

temp[i] = a[i]

a = temp

#Increase physical size of array if necessary

#shift items by one position

while index in range( logicalSize, targetIndex, -1 ):

a[index] = a[index-1]

#Add new item, and increase logical size

a[targetIndex] = newItem

logicalSize += 1 

#shift items by one position

while index in range( targetIndex, logicalSize ):

a[index] = a[index+1]

#decrease logical size

logicalSize -= 1

#decrease physical size of array if necessary  

操作

執行時間

從第 i 個位置訪問

O(1)，最好情況和最壞情況

在第 i 個位置訪問

O(1)，最好情況和最壞情況

在邏輯未尾插入

O(1)，平均情況

在邏輯未尾刪除

O(1)，平均情況

在第 i 個位置插入

O(n)，平均情況

在第 i 個位置刪除

O(n)，平均情況

增加容量

O(n)，最好情況和最差情況

減小容量

O(n)，最好情況和最差情況

#!/usr/bin/env python

# -*- coding:utf-8 -*-

# Author:Lijunjie

"""

Defines a two-dimensional array

"""

from arrays import Array

class Grid( object ):

"""Represent a two dimensional array."""

def __init__( self, rows, columns, fillValue = None ):

self._data = Array( rows )

for row in range( rows ):

self._data[row] = Array( columns, fillValue )

def getHeight( self ):

"""Return the number of rows"""

return len( self._data )

def getWidth( self ):

"""Return the number of columns."""

return len( self._data[0] )

def __getitem__( self, index ):

"""Supports two-dimensional indexing with [row][column]"""

return self._data[index]

def __setitem__( self, index, newItem ):

"""Supoort two dimensional replacement by index."""

self._data[index] = newItem

def __str__( self ):

"""Return a string represention of a grid."""

result = ""

for row in range( self.getHeight() ):

for column in range( self.getWidth() ):

result += str( self._data[row][column] ) + " "

result += "\n"

return result

#!/usr/bin/env python

# -*- coding:utf-8 -*-

# Author:Lijunjie

"""

linked node structure

"""

class Node( object ):

"""Represent a singly linked node."""

def __init__( self, data, next = None ):

"""Instantiates a Node with default next of None."""

self.data = data

self.next = next

#!/usr/bin/env python

# -*- coding:utf-8 -*-

# Author:Lijunjie

"""

File: testnode.py

Tests the Node class

"""

from node import Node

head = None

#Add five nodes to the beginning of the linked structrue

for count in range(1,10):

head = Node( count, head )

#Print the contents of the structrue

while head != None:

print( head.data )

head = head.next

probe = head

while probe != None:

#<use or modify probe.data>

probe = probe.next 

probe = head

while probe != None and targetItem != probe.data:

#<use or modify probe.data>

probe = probe.next

if probe != None:

<targetItem has been found>

else:

<targetItem is not in the linked structure> 

#Assums 0 <= index < n

probe = head

while index > 0:

probe = probe.next

index -= 1

return probe.data

probe = head

while probe != None and targetItem != probe.data:

#<use or modify probe.data>

probe = probe.next

if probe != None:

probe.data = newItem

return True

else:

return False

#Assums 0 <= index < n

probe = head

while index > 0:

probe = probe.next

index -= 1

probe.data = newItem 

head = Node( newItem, head ) 

newNode = Node( newItem )

if head is None:

head = newNode

else:

probe = head

while probe.next != None:

probe = probe.next

probe.next = newNode 

#Assume at least one node in the structure

removedItem = head.data

head = head.next

return removedItem 

#Assume at least one node in the structure

removedItem = head.data

if head.next is None:

head = None

else:

probe = head

while probe.next.next != None:

probe = probe.next

removedItem = probe.data

probe.next = None

return removedItem

if head is None or index <= 0:

head = Node( newItem, head )

else:

#Serach for node at position index - 1 or the last position

probe = head

while index > 1 and probe.next != None:

probe = probe.next

index -=1

#Insert new node after node at position index - 1 or last position

probe.next = Node( newItem, probe.next )

#Assume that the linked structure has at least one node

if index <=0 or head.next == None:

removeItem = head.data

head = head.next

return removeItem

else:

#Search for node at position next - 1 or the next to last position

probe = head

while index > 1 and probe.next.next != None

probe = probe.next

index -= 1

removeItem = probe.next.data

probe.next = probe.next.next

return removeItem