Practical Session #4 - ADTs: Array, Queue, Stack, Linked List

Size: px

Start display at page:

Download "Practical Session #4 - ADTs: Array, Queue, Stack, Linked List"

Alannah Young
5 years ago
Views:

1 Practical Session #4 - ADTs: Array, Queue, Stack, Linked List Basic Data Structures and Abstract Data Types ADT Array Abstract Data Type A collection of data-storing entities with operations to create, access, change, etc. A linear sequence of elements that supports access to its elements by their indexes. Supports the following basic methods: elementat(i) returns the element at index i insertat(i, element) insert new element at index i removeat(i) remove the element in index i size() returns the size of the array FIFO - First In First Out ADT that supports the following operations: Queue Enqueue - insert new element at the tail of the queue Dequeue - remove element from the head of the queue isempty - returns true if the queue is empty LIFO - Last In First Out ADT that supports the following operations: Stack Push - add element to the head of the stack Pop - remove element from the head of the stack isempty - returns true if the stack is empty Linked List Doubly- Linked List A data structure with linear access to the elements in it. Each element has a pointer to the next element in the list A data structure with linear access to the elements in it. Each element has 2 pointers, one to the next element in the list and the other to the previous element Important! ADT s can be implemented in a variety of possibilities. Below we describe ADT s and demonstrate their implementations.

2 Question 1 S is a set of at most n elements, where n is given. Each element has a unique key in the range [0...n-1]. (i.e. no 2 different elements have the same key) Find a data structure of size O(n), that supports the following operations in the given times: Operation Time Init(n) Initialize S (S is an empty set at the beginning) O(n) iselement(k) Check if S has an element whose key equals to k O(1) Insert(x) Add element x to S O(1) Remove(k) Remove element whose key equals to k O(1) isempty() Check if S is empty O(1) hasall Solution: (Direct Addressing) : Check if S contains all the elements whose keys are in the range [0...n-1] 1. Array A[1..n] of pointers to elements. if A[k] == null, the element whose key is k is not in S. 2. count = number of elements in S O(1) Init (n) for (i=0 ; i<n ; i++) A[i] = null; count = 0; iselement (k) return (A[k]!= null); Insert (x) If(!isElement (x.key){ A[x.key] = x; count++; Remove (k) If(isElement (k){ A[k] = null; count--; isempty () return (count == 0); hasall () return (count == n); Question 2 Suggest 2 ways to implement a Queue using 2 Stacks.

3 Solution: The queue/stack is abstract, meaning the implementation isn't known, only the interface. In order to implement a queue we need to implement the following methods: Enqueue(x),Dequeue(),isEmpty() We will use stack A in order to hold the queue's elements and stack B as a temporary stack. We will use the Stack ADT operations: Push(x), Pop() and isempty(). Enqueue (x) { moveelements(a,b) A.Push(x) moveelements(b,a) Dequeue ( ) { element = A.Pop() return element isempty ( ) { return A.isEmpty() Another way to implement a queue using 2 stacks: moveelements(x,y) { while (! X.isEmpty()){ temp = X.Pop() Y.Push(temp) Enqueue (x) { moveelements(a,b) A.Push(x) Question 3: Dequeue ( ) { moveelements(b,a) element = A.Pop() return element isempty ( ) { return ( A.isEmpty() && B.isEmpty( L1 and L2 are two linked lists which have a common part of size k. The length of L1, L2 until the 1 st common node is n, m respectively. Suggest a way to find the 1 st common node in O(n+m+k) time. (k,n,m are variables, not given) Solution : 1. find the length of L1 and L2 2. In the longer list, skip (L1.length-L2.legth) nodes. 3. Traverse both lists step by step together. In the shorter list start from the first node. In the longer list start from the node you found in 2. Stop when the next pointer of both lists points to the same node. time complexity: finding the length of L1: O(n+k) finding the length of L2: O(m+k) finding the common link: O(m+n) total: O(n+m+k)

4 Question 4: L is a singly linked list. Starting from the first element, suggest a way to traverse forward and backward from one element to its next or previous element at O(1). You can use only O(1) extra memory. Solution: Converting the list to a doubly-linked list can do the trick, but it is not allowed (will cost O(n) extra memory). We will use two pointers: current the current link we want to traverse from. prev the previous link in the traversal. As we traverse forward, all the links before current will be linked backward. As we traverse backward, all the links after current will be linked forward as usual. init() current=head prev=null moveforward() temp = prev prev=current curent=current.next prev.next=temp movebackward() temp=current current=prev prev=prev.next current.next=temp Question 5: A is a Boolean (1 or 0 values) matrix of size n*n. Find a data structure that supports the following operations in the given time: Operation Time init(n) Initialize A with the value 1 O(n 2 ) flip(i,j) A[i,j]=!A[i,j] O(1) hasrowof1 Return true iff A has a row that contains only 1-s O(1) hasrowof0 Return true iff A has a row that contains only 0-s O(1)

5 Solution: We will use the following data structures: A[n][n] the matrix Sum[n] An array containing sums of the rows in A. Sum[i] = the sum of the row i in A. count1 = how many cells in Sum contain n count0 = how many cells in Sum contain 0 init() fill A with 1 s fill Sum with n. count1=n count0=0 hasrowof1() return count1>0 hasrowof0() return count0>0 flip(i,j) if (A[i][j]==0) { if (Sum[i]=0) count0- - Sum[i]++ if (Sum[i]=n) count1++ A[i][j]=1 else { if (Sum[i]=n) count1- - Sum[i]-- if (Sum[i]=0) count0++ A[i][j]=0 Question 6: Suggest a way to implement an array of integers so that assignment of some value INIT_VAL to all cells of an array will take O(1) time. Remember that reading A[i] or writing to A[i] takes O(1) time. Solution: In order to implement an initialization of an array A of size n in O(1) time, we will create a new ADT called smartarray. The smartarray ADT uses the following data structures: A - the array of values top counts the number of defined elements in A INIT_VAL the value to initiate the array with C Array of defined and undefined indexes C[0..top-1] indexes of defined elements in A B array of pointers to the defined indexes in C B[k] = the index of k in the array C

6 Example: x = new smartarray[n] x.init(0) x.write(2,20) x.write(4,40) x.write(5,50) a = x.read(4) >> the value of a is 40 b = x.read(3) >> the value of b is A B C not set top Assumptions: The value of an undefined element B[i] is an unexpected non-negative number. Thus, for an undefined index, the comparison B[i]<top can be either true or false. The and expression is evaluated from left to right. Thus, C[B[i]]=i is evaluated only if B[i] < top. The smartarray ADT supports the following methods: NewSmartArray(n) A = new int[n] B = new int[n] C=new int[n] init(val) INIT_VAL = val top = 0 not_defined(i) return!((b[i] < top) and C[B[i]] = i)) Read(i) if (not_defined(i)) return INIT_VAL else return A[i] Write(i,val) if (not_defined(i)) C[top] = i B[i] = top top++ A[i] val

7 שאלה מס' 7 נגדיר "מחסנית מינימום" כמבנה נתונים התומך בפעולות הבאות: Create() אתחול מבנה הנתונים. Insert(x) הכנסת איבר x למבנה. RemoveLast() הוצאת האיבר שהוכנס אחרון. Min() החזרת האיבר הקטן ביותר במבנה )ללא הוצאתו(. k. שינוי ערך האיבר הקטן ביותר במבנה ל ChangeMin(k) הנחה: כל האיברים שונים זה מזה. הציעו מימוש ל"מחסנית מינימום", כאשר סיבוכיות הזמן הנדרשת לארבע הפעולות הראשונות היא (1)O, ולפעולה,O(t) ChangeMin כש t הינו מספר האיברים במבנה שהוכנסו אחרי האיבר המינימלי )הכוונה לאיבר המינימלי לפני שהפעולה ChangeMin בוצעה(. פתרון:

8. Fundamental Data Structures

172 8. Fundamental Data Structures Abstract data types stack, queue, implementation variants for linked lists, [Ottman/Widmayer, Kap. 1.5.1-1.5.2, Cormen et al, Kap. 10.1.-10.2] Abstract Data Types 173