Programming II (CS300)

Transcription

1 1 Programming II (CS300) Chapter 10: Search and Heaps MOUNA KACEM Spring 2018

2 Search and Heaps 2 Linear Search Binary Search Introduction to trees Priority Queues Heaps

3 Linear Search 3 Search: Problem Statement Given a target value X, return the index of X in the array, if such X exists. Otherwise, return (-1). Sequential Search or linear search is a search technique used to find a target value (or key value) within a list (here an array). It checks each element of the array for the target value from the first position to the last position in a linear progression (i.e. until a match is found (successful search) or until all the elements have been searched (unsuccessful search)).

4 Sequential Search 4

5 Linear Search 5

6 Binary Search 6 Precondition: Sorted array If the values in the array are arranged in ascending or descending order, then we call the array sorted. Assumption: The array is sorted in an ascendant order Basic idea: The search is performed by examining the median of a sorted array (the middle element) If match, target element found. Otherwise, if target element is smaller than the median, search in the subarray that is to the left of the median. Otherwise, search in the subarray that is to the right of the median. This procedure presumes that the subarray is not empty; if it is, the target element is not found.

7 Binary Search - Example 7 Search for 77 in the array arr Execution Trace (trace of visited nodes): 38, 77 An introduction to Oriented Programming with Java, C. Thomas Wu, Fifth edition, McGraw-Hill Companies Higher Education edition, 2010

8 Search and Heaps 8 Linear Search Binary Search Introduction to trees Priority Queues Heaps

9 General Overview of Data Structures 9

10 Introduction to trees 10 Tree: Important non-linear data structure Non-linear thinking Organizational relationship: hierarchical A tree is an abstract data type that stores elements hierarchically edge root parent With the exception of the top element (called root of the tree), each element in a tree has a parent element and zero or more children elements. A directed edge connects the parent to the child child child child Nodes with the same parent are called siblings A leaf has no children

11 Introduction to trees 11 Tree: Formal definition A tree T is a set of nodes storing elements such that the nodes have a parent-child relationship that satisfies the following properties: If T is not empty, it has a special node, called the root of T, that has no parent. Each node v of T different from the root has a unique parent node w. Every node with parent w is a child of w.

12 Introduction to trees 12 Main Advantages Trees reflect structural and hierarchical relationships in the data Trees provide an efficient insertion and searching Trees are very flexible data, allowing to move subtrees around with minimum effort

13 Introduction to trees 13 Terminology The depth of a node is the number of edges from the root to the node The height of a node is the number of edges from the node to the deepest leaf The height of a tree is a height of the root Other specific definitions Height: Sometimes, it is worth to consider the number of nodes rather than the number of edges (links) Depth: is generally related to the index level of the node in the tree

14 Introduction to trees 14 Node Height Depth A 3 0 B 1 1 C 0 1 D 1 1 E 2 1 F 0 2 G 0 2 H 0 2 I 0 2 J 1 2 K 0 3

15 Introduction to trees 15 Terminology The depth of a node is the number of edges from the root to the node The height of a node is the number of edges from the node to the deepest leaf The height of a tree is a height of the root A subtree is a section of the tree that is a complete tree in its own right, except that its root has a parent. A binary tree is a tree in which no node can have more than two children called left and right

16 Introduction to trees 16 Tree Binary tree

17 Introduction to trees 17 Terminology A binary tree is a tree in which no node can have more than two children called left and right A full binary tree is a binary tree in which each node has exactly zero or two children A complete binary tree is a binary tree, which is completely filled, with the possible exception of the bottom level, which is filled from left to right

18 Introduction to trees 18 Full binary tree Complete binary tree The height h of a complete binary tree with N nodes is at most O(log N).

19 Introduction to trees 19 Binary tree traversals: breadth-first traversal or level-order traversal Visit nodes by levels from top to bottom and from left to right depth-first traversal PreOrder traversal visit the parent first and then left and right children InOrder traversal visit the left child, then the parent and the right child PostOrder traversal visit left child, then the right child and then the parent

20 Binary-Tree Level-order Traversal 20 Level 0 Level 1 Level 2 Level 3 Level-order traversal: F, B, G, A, D, I, C, E, H

21 Binary Tree Pre-order traversal Visit parent 2. Visit left child 3. Visit right child Preorder traversal: F, B, A, D, C, E, G, I, H

22 Binary tree In-order traversal Visit left child 2. Visit parent 3. Visit right child PreOrder traversal: A, B, C, D, E, F, G, H, I

23 Binary Tree Post-order traversal Visit left child 2. Visit right child 3. Visit parent PostOrder traversal: A, C, E, D, B, H, I, G, F

24 Search and Heaps 24 Linear Search Binary Search Introduction to trees Priority Queues Heaps

25 Priority Queue 25 QueueADT Objects are added and removed according to the First-In, First-Out (FIFO) principle PriorityQueueADT A collection of prioritized elements that allows Arbitrary element insertion of a new element, and Removal of the element having highest priority The priority of an element added to a priority-queue is designated by a key The element with minimal value of key will have the highest priority

26 Priority-Queue Examples 26

27 Priority Queue 27 public interface PriorityQueueADT<T extends Comparable<T>>{ public void enqueue(t newobject); public T dequeue(); // removes and returns the element with the highest priority } public T peek(); // returns without removing the element with the highest priority public boolean isempty();

28 Java.lang.Comparable Interface 28 Interface providing a mean for defining comparison between two objects Comparable interface Includes a single method: compareto a.compareto(b) must return an integer i such that i < 0 designated that a < b i = 0 designated that a = b i > 0 designated that a > b for more details about the interface Comparable, please visit

29 Implementation Strategies for a Priority-Queue Implementing a priorityqueue with an Unsorted LinkedList head 29 tail (18, 3) (15, 1) (45, 0) (10, 2) Method enqueue dequeue peek isempty Running Time O(1) O(n) O(n) O(1)

30 Implementation Strategies for a Priority-Queue Implementing a priorityqueue with a Sorted LinkedList head 30 tail (45, 0) (15, 1) (10, 2) (18, 3) Method enqueue dequeue peek isempty Running Time O(n) O(1) O(1) O(1)

31 Implementation Strategies for a Priority-Queue 31 Using Unsorted LinkedList Using Sorted LinkedList Method Running Time Method Running Time enqueue O(1) enqueue O(n) dequeue O(n) dequeue O(1) peek O(n) peek O(1) isempty O(1) isempty O(1)

32 Search and Heaps 32 Linear Search Binary Search Introduction to trees Priority Queues Heaps

33 Heaps 33 Recall: A complete binary tree All levels of a complete binary tree are completely filled except possibly the last level and the last level has all keys as left as possible Binary Heap is a binary tree that should satisfy these two constraints Structural constraint A Heap is a complete binary tree

34 Heaps 34 Structural Constraint (complete binary tree) Non-Heap Heap Non-Heap Heap Heap Non-Heap

35 Heaps 35 Binary Heap is a binary tree that should satisfy these two constraints Structural constraint A Heap is a complete binary tree Value-relationship constraint A Heap must satisfy the heap ordering property. There are two ordering properties: min-heap property: the value of each node is greater than or equal to the value of its parent, with the minimum-value element at the root. max-heap property: the value of each node is less than or equal to the value of its parent, with the maximum-value element at the root.

36 Heaps 36 Value-Relationship Constraint Max-Heap Min-Heap Max-Heap Max-Heap Min-Heap

37 Non-Heaps 37

38 Array-Representation of a Heap 38

39 Implementing a Priority-Queue using a min-heap 39 public interface PriorityQueueADT<T extends Comparable<T>>{ public void enqueue(t newobject); // insert an element to the priority Queue public T dequeue(); // removes and returns the element with the highest priority public T peek(); // returns without removing the element with the highest priority } public boolean isempty(); // checks whether the priority Queue is empty or not

40 Implementing a Priority-Queue using a min-heap 40 Adding an element to the Heap (enqueue operation) Michael T. Goofrich, et al., "Data Structures & Algorithms", Wiley, six edition, 2014, pp

41 Implementing a Priority-Queue using a min-heap 41 Adding an element to the Heap (enqueue operation) 1. First Step: Maintain the complete binary tree property If the heap is empty or the bottom level is already full Place the new node at the leftmost position of a new level

42 Implementing a Priority-Queue using a min-heap 42 Adding an element to the Heap (enqueue operation) 1. First Step: Maintain the complete binary tree property If the heap is not empty and the bottom level is not already full Place the new node just beyond the rightmost node at the bottom level of the heap

43 Implementing a Priority-Queue using a min-heap 43 Adding an element to the Heap (enqueue operation) 1. First Step: Maintain the complete binary tree property 2. Second Step: Restore the heap-order property (Up-Heap Bubbling) After the first step, the tree representing the heap is complete. But, it may violate the heap-order property

44 Implementing a Priority-Queue using a min-heap 44 Adding an element to the Heap (enqueue operation) 1. Second Step: Restore the heap-order property (Up-Heap Bubbling) After the first step, the tree representing the heap is complete. But, it may violate the heap-order property if the priority queue was empty before the insertion Nothing to do

45 Implementing a Priority-Queue using a min-heap 45 Adding an element to the Heap (enqueue operation) 1. Second Step: Restore the heap-order property (Up-Heap Bubbling) if the priority queue was not empty before the insertion Suppose that The new node is inserted at the position p of the priority queue. (p cannot be the position of the root as the priority queue was not empty before the insertion operation) The new inserted node s parent is located at the position q of the priority queue We compare the key (aka priority) at position p to that of p s parent at position q

46 Implementing a Priority-Queue using a min-heap 46 Adding an element to the Heap (enqueue operation) 1. Second Step: Restore the heap-order property (Up-Heap Bubbling) if the priority queue was not empty before the insertion We compare the key (aka priority) at position p to that of p s parent at position q if key k p k q, the heap-order property is satisfied and the algorithm terminates if key k p < k q, then restore the heap-order property swap the entries stored at positions p and q Again, the heap-order property may be violated, so repeat the process: Going up in the binary tree until no violation of the heap-order property occurs

47 Implementing a Priority-Queue using a min-heap 47 Adding an element to the Heap (enqueue operation) (a) (b)

48 Implementing a Priority-Queue using a min-heap 48 Adding an element to the Heap (enqueue operation) (c) (d)

49 Implementing a Priority-Queue using a min-heap 49 Adding an element to the Heap (enqueue operation) (e) (f)

50 Implementing a Priority-Queue using a min-heap 50 Adding an element to the Heap (enqueue operation) (g)

51 Implementing a Priority-Queue using a min-heap 51 Adding an element to the Heap (enqueue operation) The upward movement of the newly inserted entry by means of swaps is conventionally called up-heap bubbling A swap either resolves the violation of the heap-order property or propagates it one level up in the heap. In the worst case, upheap bubbling causes the new entry to move all the way up to the root of heap. In the worst case, the number of swaps performed in the execution of method insert is equal to the height of the heap (O(log(n))) The enqueue operation using a heap is of time complexity: O(log(n)) where n represents the number of elements in the heap (i.e. size of the heap)

52 Implementation Strategies for a Priority-Queue 52 Using Unsorted LinkedList Method Running Time enqueue O(1) dequeue O(n) peek O(n) isempty O(1) Using Sorted LinkedList Method Running Time enqueue O(n) dequeue O(1) peek O(1) isempty O(1) Using a Heap Method Running Time enqueue O(log(n)) dequeue peek isempty

53 Implementing a Priority-Queue using a min-heap 53 Removing an element to the Heap (dequeue operation) Using a min-heap, the entry with the highest priority (with the smallest key) is stored at the root r of the binary tree representing the heap Deleting the root node would leave two disconnected subtrees

54 Implementing a Priority-Queue using a min-heap 54 Removing an element to the Heap (dequeue operation) Using a min-heap, the entry with the highest priority (with the smallest key) is stored at the root r of the binary tree representing the heap Deleting the root node would leave two disconnected subtrees

55 Implementing a Priority-Queue using a min-heap 55 Removing an element to the Heap (dequeue operation) Using a min-heap, the entry with the highest priority (with the smallest key) is stored at the root r of the binary tree representing the heap Deleting the root node would leave two disconnected subtrees Solution: Delete the leaf at the last position p of the tree and copy its value to the root r Then, perform a Heap-Down Bubbling process after the removal

56 Implementing a Priority-Queue using a min-heap 56 Removing an element to the Heap (dequeue operation)

57 Implementing a Priority-Queue using a min-heap 57 Removing an element to the Heap (dequeue operation)

58 Implementing a Priority-Queue using a min-heap 58 Removing an element to the Heap (dequeue operation)

59 Implementing a Priority-Queue using a min-heap 59 Removing an element to the Heap (dequeue operation)

60 Implementation Strategies for a Priority-Queue 60 Using Unsorted LinkedList Method Running Time enqueue O(1) dequeue O(n) peek O(n) isempty O(1) Using Sorted LinkedList Method Running Time enqueue O(n) dequeue O(1) peek O(1) isempty O(1) Using a Heap Method Running Time enqueue O(log(n)) dequeue O(log(n)) peek isempty

61 Implementation Strategies for a Priority-Queue 61 Using Unsorted LinkedList Method Running Time enqueue O(1) dequeue O(n) peek O(n) isempty O(1) Using Sorted LinkedList Method Running Time enqueue O(n) dequeue O(1) peek O(1) isempty O(1) Using a Heap Method Running Time enqueue O(log(n)) dequeue O(log(n)) peek O(1) isempty O(1)

62 Array-Based implementation of a Heap 62

63 Array-Based implementation of a Heap 63 The array-based representation of a binary tree is suitable for a complete binary tree. The elements of the tree are stored in an array T such that the element at position p is stored in T with index equal to the level number f (p) of p, defined as follows: If p is the root, then f (p) = 0. If p is the left child of position q, then f (p) = 2 f (q)+1. If p is the right child of position q, then f (p) = 2 f (q)+2. For a tree with of size n, the elements have contiguous indices in the range [0,n 1] The last position of is always at index n 1.