1. Fundamentals of Python: From First Programs Through Data Structures Chapter 13 Collections, Arrays, and Linked Structures

2. Fundamentals of Python: From First Programs Through Data Structures2 Objectives After completing this chapter, you will be able to: Recognize different categories of collections and the operations on them Understand the difference between an abstract data type and the concrete data structures used to implement it Perform basic operations on arrays, such as insertions and removals of items

3. Fundamentals of Python: From First Programs Through Data Structures3 Objectives (continued) Resize an array when it becomes too small or too large Describe the space/time trade-offs for users of arrays Perform basic operations, such as traversals, insertions, and removals, on linked structures Explain the space/time trade-offs of arrays and linked structures in terms of the memory models that underlie these data structures

4. Fundamentals of Python: From First Programs Through Data Structures4 Overview of Collections Collection: Group of items that we want to treat as conceptual unit Examples: –Lists, strings, stacks, queues, binary search trees, heaps, graphs, dictionaries, sets, and bags Can be homogeneous or heterogeneous –Lists are heterogeneous in Python Four main categories: –Linear, hierarchical, graph, and unordered

5. Fundamentals of Python: From First Programs Through Data Structures5 Linear Collections Ordered by position Everyday examples: –Grocery lists –Stacks of dinner plates –A line of customers waiting at a bank

6. Fundamentals of Python: From First Programs Through Data Structures6 Hierarchical Collections Structure reminiscent of an upside-down tree –D3’s parent is D1; its children are D4, D5, and D6 Examples: a file directory system, a company’s organizational tree, a book’s table of contents

7. Fundamentals of Python: From First Programs Through Data Structures7 Graph: Collection in which each data item can have many predecessors and many successors –D3’s neighbors are its predecessors and successors Examples: Maps of airline routes between cities; electrical wiring diagrams for buildings Graph Collections

8. Fundamentals of Python: From First Programs Through Data Structures8 Unordered Collections Items are not in any particular order –One cannot meaningfully speak of an item’s predecessor or successor Example: Bag of marbles

9. Fundamentals of Python: From First Programs Through Data Structures9 Operations on Collections

10. Fundamentals of Python: From First Programs Through Data Structures10 Operations on Collections (continued)

11. Fundamentals of Python: From First Programs Through Data Structures11 Abstraction and Abstract Data Types To a user, a collection is an abstraction In CS, collections are abstract data types (ADTs) –ADT users are concerned with learning its interface –Developers are concerned with implementing their behavior in the most efficient manner possible In Python, methods are the smallest unit of abstraction, classes are the next in size, and modules are the largest We will implement ADTs as classes or sets of related classes in modules

12. Fundamentals of Python: From First Programs Through Data Structures12 Data Structures for Implementing Collections: Arrays “Data structure” and “concrete data type” refer to the internal representation of an ADT’s data The two data structures most often used to implement collections in most programming languages are arrays and linked structures –Different approaches to storing and accessing data in the computer’s memory –Different space/time trade-offs in the algorithms that manipulate the collections

13. Fundamentals of Python: From First Programs Through Data Structures13 Array: Underlying data structure of a Python list –More restrictive than Python lists We’ll define an Array class The Array Data Structure

14. Fundamentals of Python: From First Programs Through Data Structures14 Random Access and Contiguous Memory Array indexing is a random access operation Address of an item: base address + offset  Index operation has two steps:

15. Fundamentals of Python: From First Programs Through Data Structures15 Static Memory and Dynamic Memory Arrays in older languages were static Modern languages support dynamic arrays To readjust length of an array at run time: –Create an array with a reasonable default size at start-up –When it cannot hold more data, create a new, larger array and transfer the data items from the old array –When the array seems to be wasting memory, decrease its length in a similar manner These adjustments are automatic with Python lists

16. Fundamentals of Python: From First Programs Through Data Structures16 Physical Size and Logical Size The physical size of an array is its total number of array cells The logical size of an array is the number of items currently in it To avoid reading garbage, must track both sizes

17. Fundamentals of Python: From First Programs Through Data Structures17 Physical Size and Logical Size (continued) In general, the logical and physical size tell us important things about the state of the array: –If the logical size is 0, the array is empty –Otherwise, at any given time, the index of the last item in the array is the logical size minus 1. –If the logical size equals the physical size, there is no more room for data in the array

18. Fundamentals of Python: From First Programs Through Data Structures18 Operations on Arrays We now discuss the implementation of several operations on arrays In our examples, we assume the following data settings: These operations would be used to define methods for collections that contain arrays

19. Fundamentals of Python: From First Programs Through Data Structures19 Increasing the Size of an Array The resizing process consists of three steps: –Create a new, larger array –Copy the data from the old array to the new array –Reset the old array variable to the new array object To achieve more reasonable time performance, double array size each time you increase its size:

20. Fundamentals of Python: From First Programs Through Data Structures20 Decreasing the Size of an Array This operation occurs in Python’s list when a pop results in memory wasted beyond a threshold Steps: –Create a new, smaller array –Copy the data from the old array to the new array –Reset the old array variable to the new array object

21. Fundamentals of Python: From First Programs Through Data Structures21 Inserting an Item into an Array That Grows Programmer must do four things: –Check for available space and increase the physical size of the array, if necessary –Shift items from logical end of array to target index position down by one To open hole for new item at target index –Assign new item to target index position –Increment logical size by one

22. Fundamentals of Python: From First Programs Through Data Structures22 Inserting an Item into an Array That Grows (continued)

23. Fundamentals of Python: From First Programs Through Data Structures23 Removing an Item from an Array Steps: –Shift items from target index position to logical end of array up by one To close hole left by removed item at target index –Decrement logical size by one –Check for wasted space and decrease physical size of the array, if necessary Time performance for shifting items is linear on average; time performance for removal is linear

24. Fundamentals of Python: From First Programs Through Data Structures24 Removing an Item from an Array (continued)

25. Fundamentals of Python: From First Programs Through Data Structures25 Complexity Trade-Off: Time, Space, and Arrays Average-case use of memory for is O(1) Memory cost of using an array is its load factor

26. Fundamentals of Python: From First Programs Through Data Structures26 Two-Dimensional Arrays (Grids) Sometimes, two-dimensional arrays or grids are more useful than one-dimensional arrays Suppose we call this grid table ; to access an item:

27. Fundamentals of Python: From First Programs Through Data Structures27 Processing a Grid In addition to the double subscript, a grid must recognize two methods that return the number of rows and the number of columns –Examples: getHeight and getWidth The techniques for manipulating one-dimensional arrays are easily extended to grids:

28. Fundamentals of Python: From First Programs Through Data Structures28 Creating and Initializing a Grid Let’s assume that there exists a Grid class: After a grid has been created, we can reset its cells to any values: height width initial fill value

29. Fundamentals of Python: From First Programs Through Data Structures29 Defining a Grid Class

30. Fundamentals of Python: From First Programs Through Data Structures30 Defining a Grid Class (continued) The method __getitem__ is all that is needed to support the client’s use of the double subscript:

31. Fundamentals of Python: From First Programs Through Data Structures31 Ragged Grids and Multidimensional Arrays In a ragged grid, there are a fixed number of rows, but the number of columns in each row can vary An array of lists or arrays provides a suitable structure for implementing a ragged grid Dimensions can be added to grid definition if needed; the only limit is computer’s memory –A three-dimensional array can be visualized as a box filled with smaller boxes stacked in rows and columns Depth, height, and width; three indexes; three loops

32. Fundamentals of Python: From First Programs Through Data Structures32 Linked Structures After arrays, linked structures are probably the most commonly used data structures in programs Like an array, a linked structure is a concrete data type that is used to implement many types of collections, including lists We discuss in detail several characteristics that programmers must keep in mind when using linked structures to implement any type of collection

33. Fundamentals of Python: From First Programs Through Data Structures33 Singly Linked Structures and Doubly Linked Structures No random access; must traverse list No shifting of items needed for insertion/removal Resize at insertion/removal with no memory cost An empty link

34. Fundamentals of Python: From First Programs Through Data Structures34 Noncontiguous Memory and Nodes A linked structure decouples logical sequence of items in the structure from any ordering in memory –Noncontiguous memory representation scheme The basic unit of representation in a linked structure is a node:

35. Fundamentals of Python: From First Programs Through Data Structures35 Noncontiguous Memory and Nodes (continued) Depending on the language, you can set up nodes to use noncontiguous memory in several ways: –Using two parallel arrays

36. Fundamentals of Python: From First Programs Through Data Structures36 Noncontiguous Memory and Nodes (continued) Ways to set up nodes to use noncontiguous memory (continued): –Using pointers (a null or nil represents the empty link as a pointer value) Memory allocated from the object heap –Using references to objects (e.g., Python) In Python, None can mean an empty link Automatic garbage collection frees programmer from managing the object heap In the discussion that follows, we use the terms link, pointer, and reference interchangeably

37. Fundamentals of Python: From First Programs Through Data Structures37 Defining a Singly Linked Node Class Node classes are fairly simple Flexibility and ease of use are critical –Node instance variables are usually referenced without method calls, and constructors allow the user to set a node’s link(s) when the node is created A singly linked node contains just a data item and a reference to the next node:

38. Fundamentals of Python: From First Programs Through Data Structures38 Using the Singly Linked Node Class Node variables are initialized to None or a new Node object

39. Fundamentals of Python: From First Programs Through Data Structures39 Using the Singly Linked Node Class (continued) node1.next = node3 raises AttributeError –Solution: node1 = Node("C", node3), or Node1 = Node("C", None) node1.next = node3 To guard against exceptions: if nodeVariable != None: Like arrays, linked structures are processed with loops

40. Fundamentals of Python: From First Programs Through Data Structures40 Using the Singly Linked Node Class (continued) –Note that when the data are displayed, they appear in the reverse order of their insertion

41. Fundamentals of Python: From First Programs Through Data Structures41 Operations on Singly Linked Structures Almost all of the operations on arrays are index based –Indexes are an integral part of the array structure Emulate index-based operations on a linked structure by manipulating links within the structure We explore how these manipulations are performed in common operations, such as: –Traversals –Insertions –Removals

42. Fundamentals of Python: From First Programs Through Data Structures42 Traversal Traversal: Visit each node without deleting it –Uses a temporary pointer variable Example: probe = head while probe != None: probe = probe.next –None serves as a sentinel that stops the process Traversals are linear in time and require no extra memory

43. Fundamentals of Python: From First Programs Through Data Structures43 Traversal (continued)

44. Fundamentals of Python: From First Programs Through Data Structures44 Searching Resembles a traversal, but two possible sentinels: –Empty link –Data item that equals the target item Example: probe = head while probe != None and targetItem != probe.data: probe = probe.next if probe != None: else: On average, it is linear for singly linked structures

45. Fundamentals of Python: From First Programs Through Data Structures45 Searching (continued) Unfortunately, accessing the ith item of a linked structure is also a sequential search operation –We start at the first node and count the number of links until the ith node is reached Linked structures do not support random access –Can’t use a binary search on a singly linked structure –Solution: Use other types of linked structures

46. Fundamentals of Python: From First Programs Through Data Structures46 Replacement Replacement operations employ traversal pattern Replacing the ith item assumes 0 <= i < n Both replacement operations are linear on average

47. Fundamentals of Python: From First Programs Through Data Structures47 Inserting at the Beginning Uses constant time and memory

48. Fundamentals of Python: From First Programs Through Data Structures48 Inserting at the End Inserting an item at the end of an array ( append in a Python list) requires constant time and memory –Unless the array must be resized Inserting at the end of a singly linked structure must consider two cases: –Linear in time and constant in memory

49. Fundamentals of Python: From First Programs Through Data Structures49 Inserting at the End (continued)

50. Fundamentals of Python: From First Programs Through Data Structures50 Removing at the Beginning

51. Fundamentals of Python: From First Programs Through Data Structures51 Removing at the End Removing an item at the end of an array ( pop in a Python list) requires constant time and memory –Unless the array must be resized Removing at the end of a singly linked structure must consider two cases:

52. Fundamentals of Python: From First Programs Through Data Structures52 Removing at the End (continued)

53. Fundamentals of Python: From First Programs Through Data Structures53 Inserting at Any Position Insertion at beginning uses code presented earlier In other position i, first find the node at position i - 1 (if i = n) Linear time performance; constant use of memory

54. Fundamentals of Python: From First Programs Through Data Structures54 Inserting at Any Position (continued)

55. Fundamentals of Python: From First Programs Through Data Structures55 Removing at Any Position The removal of the ith item from a linked structure has three cases:

56. Fundamentals of Python: From First Programs Through Data Structures56 Complexity Trade-Off: Time, Space, and Singly Linked Structures The main advantage of singly linked structure over array is not time performance but memory performance

57. Fundamentals of Python: From First Programs Through Data Structures57 Variations on a Link A Circular Linked Structure with a Dummy Header Node Doubly Linked Structures

58. Fundamentals of Python: From First Programs Through Data Structures58 A Circular Linked Structure with a Dummy Header Node A circular linked structure contains a link from the last node back to the first node in the structure –Dummy header node serves as a marker for the beginning and the end of the linked structure

59. Fundamentals of Python: From First Programs Through Data Structures59 A Circular Linked Structure with a Dummy Header Node (continued) To initialize the empty linked structure: To insert at the ith position:

60. Fundamentals of Python: From First Programs Through Data Structures60 Doubly Linked Structures

61. Fundamentals of Python: From First Programs Through Data Structures61 Doubly Linked Structures (continued) To insert a new item at the end of the linked structure

62. Fundamentals of Python: From First Programs Through Data Structures62 Doubly Linked Structures (continued)

63. Fundamentals of Python: From First Programs Through Data Structures63 Summary Collections are objects that hold 0+ other objects –Main categories: Linear, hierarchical, graph, and unordered –Collections are iterable –Collections are thus abstract data types A data structure is an object used to represent the data contained in a collection The array is a data structure that supports random access, in constant time, to an item by position –Can be two-dimensional (grid)

64. Fundamentals of Python: From First Programs Through Data Structures64 Summary (continued) A linked structure is a data structure that consists of 0+ nodes –A singly linked structure’s nodes contain a data item and a link to the next node –Insertions or removals in linked structures require no shifting of data elements –Using a header node can simplify some of the operations, such as adding or removing items