1. Stacks and Queues

2.  Abstract Data Types  Stacks  Queues  Priority Queues September 2004John Edgar2

3. September 2004John Edgar3

4.  Reverse Polish Notation (RPN)  Also known as postfix notation  A mathematical notation ▪Where every operator follows its operands  Invented by Jan Łukasiewicz in 1920  Example  Infix: 1 + 2  RPN: 1 2 + September 2004John Edgar4

5.  More interesting example  Infix: 5 + ((1 + 2) * 4) − 3  RPN: 5 1 2 + 4 * + 3 –  Cleaner, no backets September 2004John Edgar5

6.  5 1 2 + 4 * + 3 – September 2004John Edgar6 5 store 5 store 1 store 2 Apply + to the last two operands 1 2

7.  5 1 2 + 4 * + 3 – September 2004John Edgar7 5 store 5 store 1 store 2 Apply + to the last two operands store result store 4 Apply * to the last two operands 3 4

8.  5 1 2 + 4 * + 3 – September 2004John Edgar8 5 store 5 store 1 store 2 Apply + to the last two operands store result store 4 Apply * to the last two operands store result 12 Apply + to the last two operands

9.  5 1 2 + 4 * + 3 – September 2004John Edgar9 store 5 store 1 store 2 Apply + to the last two operands store result store 4 Apply * to the last two operands store result store 3 Apply + to the last two operands store result 3 Apply - to the last two operands 17

10.  5 1 2 + 4 * + 3 – September 2004John Edgar10 store 5 store 1 store 2 Apply + to the last two operands store result store 4 Apply * to the last two operands store result store 3 Apply + to the last two operands store result Apply - to the last two operands 14 store result retrieve answer

11. WWhat are the storage properties of the data structure that we used? SSpecifically how are items inserted and removed? TThe last item to be entered is the first item to be removed KKnown as LIFO (Last In First Out) AA stack September 2004John Edgar11

12. September 2004John Edgar12

13.  A stack only allows items to be inserted and removed at one end  We call this end the top of the stack  The other end is called the bottom  Access to other items in the stack is not allowed September 2004John Edgar13

14.  A stack can be used to naturally store data for postfix notation  Operands are stored at the top of the stack  And removed from the top of the stack  Notice that we have not (yet) discussed how a stack should be implemented  Just what it does  An example of an Abstract Data Type September 2004John Edgar14

15. September 2004John Edgar15

16.  A collection of data  Describes the data but not how it is stored  Set of operations on the data  Describes precisely what effect the operations have on the data but  Does not specify how operations are carried out  An ADT is not a data structure September 2004John Edgar16

17.  The term concrete data type is usually used in contrast with an ADT  An ADT is a collection of data and a set of operations on the data  A concrete data type is an implementation of an ADT using a data structure  A construct that is defined in a programming language to store a collection of data September 2004John Edgar17

18.  Mutators  Accessors  Other September 2004John Edgar18

19.  Often known as setters  Operations that change the contents of an ADT, usually subdivided into ▪ Adding data to a data collection and ▪ Removing data from a collection  Different ADTs allow data to be added and removed at different locations September 2004John Edgar19

20.  Often known as getters  Retrieve data from the collection  e.g. the item at the top of the stack  Ask questions about the data collection  Is it full?  How many items are stored?  … September 2004John Edgar20

21.  Information related to storage implementation should be hidden  An ADT’s operations can be used in the design of other modules or applications  Other modules do not need to know the implementation of the ADT operations  Allowing the implementation of operations to be changed without affecting other modules September 2004John Edgar21

22.  Operations should be specified in detail without discussing implementation issues  In C++ an ADT class can be divided into header (.h) and implementation (.cpp) files ▪More in later lectures September 2004John Edgar22

23. Arrays September 2004John Edgar23

24.  A stack should implement at least the first two of these operations:  push – insert an item at the top of the stack  pop – remove and return the top item  peek – return the top item  These operations are straightforward so should be performed efficiently September 2004John Edgar24

25.  Assume that we plan on using a stack to contain integers with these methods  void push (int)  int pop()  We can design other modules that use these methods  Without having to know anything about how they, or the stack itself, are implemented September 2004John Edgar25

26.  We will use classes to encapsulate stacks  Encapsulate – enclose in  A class is a programming construct that contains  Data for the class  Operations of the class  More about classes later … September 2004John Edgar26

27.  The stack ADT can be implemented using a variety of data structures, e.g.  Arrays  Linked Lists  Both implementations must implement all the stack operations  And in constant time (time that is independent of the number of items in the stack) September 2004John Edgar27

28.  Let’s use an array to implement a stack  We will need to keep track of the index that represents the top of the stack  When we insert an item increment this index  When we delete an item decrement this index September 2004John Edgar28

29. September 2004John Edgar29 012345 index of top is current size – 1 //Java Code Stack st = new Stack(); index of top is current size – 1 //Java Code Stack st = new Stack();

30. September 2004John Edgar30 6 012345 index of top is current size – 1 //Java Code Stack st = new Stack(); st.push(6); //top = 0 index of top is current size – 1 //Java Code Stack st = new Stack(); st.push(6); //top = 0

31. September 2004John Edgar31 6178 012345 index of top is current size – 1 //Java Code Stack st = new Stack(); st.push(6); //top = 0 st.push(1); //top = 1 st.push(7); //top = 2 st.push(8); //top = 3 index of top is current size – 1 //Java Code Stack st = new Stack(); st.push(6); //top = 0 st.push(1); //top = 1 st.push(7); //top = 2 st.push(8); //top = 3

32. September 2004John Edgar32 617 012345 index of top is current size – 1 //Java Code Stack st = new Stack(); st.push(6); //top = 0 st.push(1); //top = 1 st.push(7); //top = 2 st.push(8); //top = 3 st.pop(); //top = 2 index of top is current size – 1 //Java Code Stack st = new Stack(); st.push(6); //top = 0 st.push(1); //top = 1 st.push(7); //top = 2 st.push(8); //top = 3 st.pop(); //top = 2

33.  Java coding example September 2004John Edgar33

34.  Easy to implement a stack with an array  And push and pop can be performed in constant time  But what happens when the array is full?  Once the array is full  No new values can be inserted or  A new, larger, array has to be created ▪And the existing items copied to this new array September 2004John Edgar34

35. September 2004John Edgar35

36.  Arrays contain identically typed values  These values are stored sequentially in main memory  Values are stored at specific numbered positions in the array called indexes  The first value is stored at index 0, the second at index 1, the ith at index i-1, and so on  The last item is stored at position n-1, assuming that n values are stored in the array September 2004John Edgar36

37. iint[] arr = {3,7,6,8,1,7,2}; CCreates an integer array with 7 elements TTo access an element refer to the array name and the element's index iint x = arr[3]; assigns the value of the fourth array element (8) to x aarr[5] = 11; changes the sixth element of the array from 7 to 11 aarr[7] = 3; results in an error because the index is out of bounds September 2004John Edgar37 indexvalue 03 17 26 38 41 57 62 11 In Java this results in an ArrayIndexOutOfBoundsException

38.  C++ coding example September 2004John Edgar38

39. September 2004John Edgar39 int[] grade; Declares an array variable grade In Java arrays are objects, so this is a reference variable This symbol represents the “null pointer” main memory is depicted below this line Note: Java syntax. C++ is int * grade;

40. 0 0 0 0 September 2004John Edgar40 int[] grade; grade = new int[4]; Creates a new array of size 4 grade main memory is depicted below this line Stores 4 int s consecutively. The int s are initialized to 0 refers to the newly created array object

41. 0 0 0 0 September 2004John Edgar41 int[] grade; grade = new int[4]; grade[2] = 23; Assigns 23 to the third item in the array grade main memory is depicted below this line But how does the system “know” where grade[2] is? 23

42.  Access to array elements is very fast  An array variable references the array  A reference is just a main memory address  The address is stored as number, with each address referring to one byte of memory ▪Address 0 would be the first byte ▪Address 1 would be the second byte ▪Address 20786 would be the twenty thousand, seven hundred and eighty seventh byte ▪… September 2004John Edgar42

43. CConsider grade[2] = 23; HHow do we find this element in the array? CConsider what we know TThe address of the first array element TThe type of the values stored in the array ▪A▪And therefore the size of the array elements TThe index of the element to be accessed WWe can calculate the address of the element to be accessed aaddress of first element + (index * type size) September 2004John Edgar43

44. … 12801290 12811291 12821292 12831293 12841294 12851295 12861296 12871297 12881298 12891299 … September 2004John Edgar44 The int stored at grade[2] is located at byte: 1282 + 2 * 4 = 1290 grade Stores a reference to the start of the array, in this case byte 1282

45.  Array variables are reference variables  An array variable argument to a method passes the address of the array ▪And not the elements of the array  Changes made to the array by a method are made to the original array object  If this is not desired, a copy of the array should be made within the method September 2004John Edgar45

46.  What if array positions carry meaning?  An array that is sorted by name, or grade or some other value  Or an array where the position corresponds to a position of some entity in the world  The ordering should be maintained as elements are inserted or removed September 2004John Edgar46

47.  When an item is inserted either  Write over the element at the given index or  Move the element, and all elements after it, up one position  When an item is removed either  Leave gaps in the array, i.e. array elements that don't represent values or  Move all the values after the removed value down one index September 2004John Edgar47

48.  The size of an array must be specified when it is created  And cannot then be changed  If the array is full values can’t be inserted  There are, time consuming, ways around this  To avoid this problem we can make arrays much larger than they are needed  However this wastes space September 2004John Edgar48

49.  Good things about arrays  Fast, random access, of elements using a simple offset calculation  Very memory efficient, as little memory is required other than the data itself  Easy to use  Bad things about arrays  Slow deletion and insertion of elements for ordered arrays  Size must be known when the array is created September 2004John Edgar49

50. September 2004John Edgar50

51.  It would be nice to have a data structure that is  Dynamic  Does fast insertions/deletions in the middle  We can achieve this using linked lists … September 2004John Edgar51

52.  A linked list is a dynamic data structure that consists of nodes linked together  A node is a data structure that contains  data  the location of the next node September 2004John Edgar52 7

53.  A linked list is a chain of nodes where each node stores the address of the next node September 2004John Edgar53 627 start 8 This symbol indicates a null reference

54. September 2004John Edgar54 7 // Java class Node { public int data; public Node next; } // C++ class Node { public: int data; Node *next; };

55. // Java class Node { public int data; public Node next; } // C++ class Node { public: int data; Node *next; }; September 2004John Edgar55 7 A node points to another node, so the reference must be of type Node

56. Node a = new Node(7, null); September 2004John Edgar56 a Assume we’ve added a constructor to the Node class that lets us initialize data and next like this. 7 // C++ Node *a = new Node(7, null);

57. Node a = new Node(7, null); a.next = new Node(3, null); 57 a 7 3 a.next a->next a.data a->data a.next.data a->next->data // C++ Node *a = new Node(7, null); a->next = new Node(3, null);

58. Node a = new Node(7, null); a.next = new Node(3, null); Node p = a; 58 a 7 3 p // C++ Node *a = new Node(7, null); a->next = new Node(3, null); Node *p = a;

59. Node a = new Node(7, null); a.next = new Node(3, null); Node p = a; p = p.next; // go to the next node September 2004John Edgar59 a 7 3 We can walk through a linked list by going from node to node. p Node *a = new Node(7, null); a->next = new Node(3, null); Node *p = a; p = p->next;// go to the next node

60. Node a = new Node(7, null); a.next = new Node(3, null); Node p = a; p = p.next; // go to the next node p = p.next; September 2004John Edgar60 a 7 3 Eventually, p reaches the end of the list and becomes null. p Node *a = new Node(7, null); a->next = new Node(3, null); Node *p = a; p = p->next; // go to the next node p = p->next;

61.  The previous example showed a list built out of nodes  In practice a linked list is encapsulated in its own class  Allowing new nodes to be easily inserted and removed as desired  The linked list class has a pointer to the (node at the) head of the list  Implementations of linked lists vary September 2004John Edgar61

62. Linked Lists September 2004John Edgar62

63.  Nodes should be inserted and removed at the head of the list  New nodes are pushed onto the front of the list, so that they become the top of the stack  Nodes are popped from the front of the list  Straight-forward linked list implementation  Both push and pop affect the front of the list ▪There is therefore no need for either algorithm to traverse the entire list September 2004John Edgar63

64. September 2004John Edgar64 public void push(int x){ // Make a new node whose next reference is // the existing list Node newNode = new Node(x, head); head = newNode; //head points to new node } public void push(int x){ // Make a new node whose next reference is // the existing list Node newNode = new Node(x, head); head = newNode; //head points to new node } public int pop(){ // Return the value at the head of the list int temp = head.data; head = head.next; return temp; //head points to new node }// Garbage collection deallocates old head public int pop(){ // Return the value at the head of the list int temp = head.data; head = head.next; return temp; //head points to new node }// Garbage collection deallocates old head Java

65. September 2004John Edgar65 void LinkedList::push(int x){ // Make a new node whose next reference is // the existing list Node *newNode = new Node(x, head); head = newNode; //head points to new node } void LinkedList::push(int x){ // Make a new node whose next reference is // the existing list Node *newNode = new Node(x, head); head = newNode; //head points to new node } int LinkedList::pop(){ // Return the value at the head of the list int temp = head->data; Node *ht = head; head = head->next; delete ht; return temp; //head points to new node } int LinkedList::pop(){ // Return the value at the head of the list int temp = head->data; Node *ht = head; head = head->next; delete ht; return temp; //head points to new node } C++

66. September 2004John Edgar66 C++ Code Stack st; st.push(6); C++ Code Stack st; st.push(6); top 6

67. September 2004John Edgar67 Java Code Stack st = new Stack(); st.push(6); st.push(1); Java Code Stack st = new Stack(); st.push(6); st.push(1); top 61

68. September 2004John Edgar68 C++ Code Stack st; st.push(6); st.push(1); st.push(7); C++ Code Stack st; st.push(6); st.push(1); st.push(7); top 617

69. September 2004John Edgar69 C++ Code Stack st; st.push(6); st.push(1); st.push(7); st.push(8); C++ Code Stack st; st.push(6); st.push(1); st.push(7); st.push(8); top 6178

70. September 2004John Edgar70 Java Code Stack st = new Stack(); st.push(6); st.push(1); st.push(7); st.push(8); st.pop(); Java Code Stack st = new Stack(); st.push(6); st.push(1); st.push(7); st.push(8); st.pop(); top 6178

71. September 2004John Edgar71 Java Code Stack st = new Stack(); st.push(6); st.push(1); st.push(7); st.push(8); st.pop(); Java Code Stack st = new Stack(); st.push(6); st.push(1); st.push(7); st.push(8); st.pop(); top 617

72. September 2004John Edgar72

73.  Programs typically involve more than one function call  A main function  Which calls other functions as required  Each function requires space in main memory for its variables and parameters  This space must be allocated and de-allocated in some organized way

74.  Most programming languages use a call stack to implement function calling  When a method is called, its line number and other data are pushed onto the call stack  When a method terminates, it is popped from the call stack  Execution restarts at the indicated line number in the method currently at the top of the stack September 2004John Edgar74

75. September 2004John Edgar75 This is a display of the call stack (from the Eclipse Debug window) Top of the stack: most recently called method. Bottom of the stack: least recently called method

76.  When a function is called space is allocated for it on the call stack  This space is allocated sequentially  Once a function has run the space it used on the call stack is de-allocated  Allowing it to be re-used  Execution returns to the previous function  Which is now at the top of the call stack

77. public double biggerArea(double side, double r){ double sq; double circ; sq = squareArea(side); circ = circleArea(r); if (sq > circ) return sq; else return circ; } public double squareArea(double side){ return square(side) } public double circleArea(double r){ return Math.PI * square(r); } public double square(double x){ return x * x; } public double square(double x){ return x * x; }

78. double biggerArea(double side, double r){ double sq; double circ; sq = squareArea(side); circ = circleArea(r); if (sq > circ) return sq; else return circ; } double squareArea(double side){ return square(side) } double circleArea(double r){ return 3.14 * square(r); } double square(double x){ return x * x; } double square(double x){ return x * x; }

79. biggerArea(4, 2) // executing biggerArea sq = squareArea(side) // executing squareArea return square(side) // return to biggerArea sidersqcirc biggerArea 42 … side squareArea 4 x square 4 16 stack

80. biggerArea(4, 2) // executing biggerArea sq = squareArea(side) // executing squareArea return square(side) // return to biggerArea circ = circleArea(r) // executing circleArea return pi * square(r) // return to biggerArea if (sq > circ) return sq sidersqcirc biggerArea 4216 … r circleArea 2 x square 2 12.5… stack

81.  In the example, functions returned values assigned to variables in other functions  They did not affect the amount of memory required by previously called functions  That is, functions below them on the call stack  Stack memory is sequentially allocated  It is not possible to increase memory assigned to a function previously pushed onto the stack

82.  Let's say we want to call a function to insert some values in an existing array  If the calling function has made an array with of the right size this is not a problem ▪The new values are stored in the existing array  But the calling function might not know how many values are to be inserted

83.  Memory on the call stack is allocated sequentially  So we can’t change the size of a variable belonging to a function already on the stack  Suggesting that we can’t change the size of an array when the program is running  Either make an array large enough so that it doesn’t overflow  Or use dynamic memory

84.  What happens if we want to allocate memory at run time?  It can’t be allocated to stack memory so will need to be put somewhere else  Let’s call somewhere else the heap  We still need stack variables that refer or point to the dynamically allocated memory  Which we will call reference or pointer variables

85.  Create a variable to store an address  A reference of pointer variable  Addresses have a fixed size  If there is initially no address assign it a special value (null)  Create new data in the heap when needed  This may be done at run time  Assign the address of the data to variable  This does involve more administration

86. // in function, f … // Java code int arr[]; arr = getOrdArray(5); // … …arr f …null … n getOrdArray 5 stack int[] getOrdArray(int n){ int arr[] = new int[n]; for (int i = 0; i < n; ++i){ arr[i] = i * 2 + 1; } return arr; } heap 13579 arr

87. // in function, f … // C++ code int *arr; arr = getOrdArray(5); // … … f …null … n getOrdArray 5 stack int * getOrdArray(int n){ int *arr = new int[n]; for (int i = 0; i < n; ++i){ arr[i] = i * 2 + 1; } return arr; } heap 13579 arr

88.  When a function call is complete its stack memory is released and can be re-used  Dynamic memory should also be released  Failing to do so results in a memory leak  It is not as easy to determine when dynamic memory should be released  Data might be referred to by more than one address variable ▪Memory should only be released when it is no longer required by any variable

89.  When should a data object be created in dynamic memory?  When the object is required to change size, or  If it is not known if the object will be required  Languages have different approaches to using static and dynamic memory  In Java this is determined by the data type  In C++ the programmer can choose whether to assign data to static or dynamic memory

90. September 2004John Edgar90

91.  Assume that we want to store data for a print queue for a student printer  Student ID  Time  File name  The printer is to be assigned to file in the order in which they are received  A fair algorithm September 2004John Edgar91

92.  To maintain the print queue we would require at least two classes  Request class  Collection class to store requests  The collection class should support the desired behaviour  FIFO (First In First Out)  The ADT is a queue September 2004John Edgar92

93.  In a queue items are inserted at the back and removed from the front  As an aside queue is just the British (i.e. correct ) word for a line (or line-up)  Queues are FIFO (First In First Out) data structures – fair data structures September 2004John Edgar93

94.  Server requests  Instant messaging servers queue up incoming messages  Database requests  Print queues  Operating systems often use queues to schedule CPU jobs  Various algorithm implementations September 2004John Edgar94

95.  A queue should implement at least the first two of these operations:  insert – insert item at the back of the queue  remove – remove an item from the front  peek – return the item at the front of the queue without removing it  Like stacks, it is assumed that these operations will be implemented efficiently  That is, in constant time September 2004John Edgar95

96. Arrays September 2004John Edgar96

97. CConsider using an array as the underlying structure for a queue, we could MMake the back of the queue the current size of the array, much like the stack implementation IInitially make the front of the queue index 0 IInserting an item is easy September 2004John Edgar97 01234567 4 01234567 back = 0 back = 1 back = 2 418 01234567 front = 0

98. WWhat happens when items are removed? EEither move all remaining items down – slow OOr increment the front index – wastes space September 2004John Edgar98 4182525 01234567 back = 5 front = 0 182525 01234567 back = 4 front = 0 4182525 01234567 back = 5 front = 1

99.  Neat trick: use a circular array to insert and remove items from a queue in constant time  The idea of a circular array is that the end of the array “wraps around” to the start of the array 01234567 September 2004John Edgar99 0 1 3 2 4 5 6 7

100.  The mod operator (%) calculates remainders:  1%5 = 1, 2%5 = 2, 5%5 = 0, 8%5 = 3  The mod operator can be used to calculate the front and back positions in a circular array  Thereby avoiding comparisons to the array size  The back of the queue is: ▪ (front + num) % queue.length ▪where num is the number of items in the queue  After removing an item the front of the queue is: ▪ (front + 1) % queue.length; September 2004John Edgar100

101. September 2004John Edgar101 012345 //C++ Code Queue q; q.insert(6); //C++ Code Queue q; q.insert(6); 6 front0 insert item at (front + num) % queue.length num01

102. September 2004John Edgar102 012345 //Java Code Queue q = new Queue(); q.insert(6); q.insert(4); q.insert(7); q.insert(3); q.insert(8); //Java Code Queue q = new Queue(); q.insert(6); q.insert(4); q.insert(7); q.insert(3); q.insert(8); 6 front0 4738 num12345 insert item at (front + num) % queue.length

103. September 2004John Edgar103 012345 // C++ Code Queue q; q.insert(6); q.insert(4); q.insert(7); q.insert(3); q.insert(8); q.remove();//front to 1 q.remove();//front to 2 q.insert(9); // C++ Code Queue q; q.insert(6); q.insert(4); q.insert(7); q.insert(3); q.insert(8); q.remove();//front to 1 q.remove();//front to 2 q.insert(9); 6 front0 4 make front = (0 + 1) % 6 = 1 1 7389 num5434 make front = (1 + 1) % 6 = 2 2

104. September 2004John Edgar104 012345 //Java Code Queue q = new Queue(); q.insert(6); q.insert(4); q.insert(7); q.insert(3); q.insert(8); q.remove();//front to 1 q.remove();//front to 2 q.insert(9); q.insert(5); //Java Code Queue q = new Queue(); q.insert(6); q.insert(4); q.insert(7); q.insert(3); q.insert(8); q.remove();//front to 1 q.remove();//front to 2 q.insert(9); q.insert(5); front2 73895 insert at (front + num) % 6 = (2 + 4) % 6 = 0 num45

105. Linked Lists September 2004John Edgar105

106. RRemoving items from the front of the queue is straightforward IItems should be inserted at the back of the queue in constant time SSo we would like to avoid traversing through the list UUse a second node reference to keep track of the node at the back of the queue ▪R▪Requires a little extra administration September 2004John Edgar106

107. September 2004John Edgar107 front 6 back // C++ Code Queue q; q.insert(6); // C++ Code Queue q; q.insert(6);

108. September 2004John Edgar108 front 46 back //Java Code Queue q = new Queue(); q.insert(6); q.insert(4); //Java Code Queue q = new Queue(); q.insert(6); q.insert(4);

109. September 2004John Edgar109 front 46 back // C++ Code Queue q; q.insert(6); q.insert(4); q.insert(7); // C++ Code Queue q; q.insert(6); q.insert(4); q.insert(7); 7

110. September 2004John Edgar110 front 46 back //Java Code Queue q = new Queue(); q.insert(6); q.insert(4); q.insert(7); q.insert(3); //Java Code Queue q = new Queue(); q.insert(6); q.insert(4); q.insert(7); q.insert(3); 73

111. September 2004John Edgar111 front 46 back //Java Code Queue q = new Queue(); q.insert(6); q.insert(4); q.insert(7); q.insert(3); q.remove(); //Java Code Queue q = new Queue(); q.insert(6); q.insert(4); q.insert(7); q.insert(3); q.remove(); 73

112. September 2004John Edgar112 6 5 4 3 2 1

113.  Items in a priority queue are given a priority value  Which could be numerical or something else  The highest priority item is removed first  Uses include  System requests  Data structure to support Dijkstra’s Algorithm September 2004John Edgar113

114.  Can items be inserted and removed efficiently from a priority queue?  Using an array, or  Using a linked list?  Note that items are not removed based on the order in which they are inserted September 2004John Edgar114

115. September 2004John Edgar115

116.  Abstract Data Types (ADTs)  Specify data and operations ▪But not how they are stored nor how they are done ▪Allow usage without knowing all the details  Examples: Stacks and Queues ▪Array-based implementations ▪Linked list-based implementations September 2004John Edgar116

117.  Linked lists  Chain of Node data structures ▪Each Node contains data and reference to next Node  Can be used to store an a priori unknown amount of data ▪Allocate Nodes one at a time  Efficient insertion/deletion  Some overhead vs. array September 2004John Edgar117

118.  Memory  Arrays stored as contiguous block of memory ▪Fast access via offset calculations  Static memory (stack memory) versus dynamic memory (heap memory) ▪Variable in stack memory is gone after a function / method call is complete ▪Variable in heap memory sticks around September 2004John Edgar118

119.  Carrano  Ch. 3, 4, 6, 7 September 2004John Edgar119