Lecture No.07. // print the final avaerage wait time.

Transcription

1 Lecture No.0 Code for Simulation // print the final avaerage wait time. double avgwait = (totaltime*1.0)/count; cout << "Total time: " << totaltime << endl; cout << Customer: " << count << endl; cout << "Average wait: " << avgwait << endl; 1

2 Priority Queue #include "Event.cpp" #define PQMAX 0 class PriorityQueue { public: PriorityQueue() { size = 0; rear = -1; }; ~PriorityQueue() {}; int full(void) { return ( size == PQMAX )? 1 : 0; }; Priority Queue Event* remove() { if( size > 0 ) { Event* e = nodes[0]; for(int j=0; j < size-2; j++ ) nodes[j] = nodes[j+1]; size = size-1; rear=rear-1; if( size == 0 ) rear = -1; return e; } return (Event*)NULL; cout << "remove - queue is empty." << endl; }; 2

3 Priority Queue int insert(event* e) { if(!full() ) { rear = rear+1; nodes[rear] = e; size = size + 1; sortelements(); // in ascending order return 1; } cout << "insert queue is full." << endl; return 0; }; int length() { return size; }; }; Tree Data Structures There are a number of applications where linear data structures are not appropriate. Consider a genealogy tree of a family. Kamran Safdar Sohail Safdar Javed Safdar Yasmeen Safdar Haaris Saad Qasim Asim Fahd Ahmad Sara Omer

4 Tree Data Structure A linear linked list will not be able to capture the tree-like relationship with ease. Shortly, we will see that for applications that require searching, linear data structures are not suitable. We will focus our attention on binary trees. Binary Tree A binary tree is a finite set of elements that is either empty or is partitioned into three disjoint subsets. The first subset contains a single element called the root of the tree. The other two subsets are themselves binary trees called the left and right subtrees. Each element of a binary tree is called a node of the tree.

5 Binary Tree Binary tree with nodes. A B C D E F G H I Binary Tree root A B C D E F G H I Left subtree Right subtree

6 Binary Tree Recursive definition root A B C D E F Left subtree G H I Right subtree Binary Tree Recursive definition A B root C D E F G H I Left subtree 6

7 Binary Tree Recursive definition A B C D E F G root H I Binary Tree Recursive definition A root B C D E F G H I Right subtree

8 Binary Tree Recursive definition A B C root D E F G H I Left subtree Right subtree Not a Tree Structures that are not trees. A B C D E F G H I 8

9 Not a Tree Structures that are not trees. A B C D E F G H I Not a Tree Structures that are not trees. A B C D E F G H I

10 Binary Tree: Terminology parent A Left descendant B C Right descendant D E F G H I Leaf nodes Leaf nodes Binary Tree If every non-leaf node in a binary tree has non-empty left and right subtrees, the tree is termed a strictly binary tree. A B C D E J F G K H I 10

11 Level of a Binary Tree Node The level of a node in a binary tree is defined as follows: Root has level 0, Level of any other node is one more than the level its parent (father). The depth of a binary tree is the maximum level of any leaf in the tree. Level of a Binary Tree Node A 0 Level 0 B 1 C 1 Level 1 D E F Level 2 G H I Level 11

12 Complete Binary Tree A complete binary tree of depth d is the strictly binary all of whose leaves are at level d. A 0 B 1 C 1 D 2 E 2 F 2 G 2 H I J K L M N O Complete Binary Tree A Level 0: 2 0 nodes B C Level 1: 2 1 nodes D E F G Level 2: 2 2 nodes H I J K L M N O Level : 2 nodes 12

13 Complete Binary Tree At level k, there are 2 k nodes. Total number of nodes in the tree of depth d: d = 2 j = 2 d+1 1 In a complete binary tree, there are 2 d leaf nodes and (2 d - 1) non-leaf (inner) nodes. d j=0 Complete Binary Tree If the tree is built out of n nodes then n = 2 d+1 1 or log 2 (n+1) = d+1 or d = log 2 (n+1) 1 I.e., the depth of the complete binary tree built using n nodes will be log 2 (n+1) 1. For example, for n=1,000,000, log 2 ( ) is less than 20; the tree would be 20 levels deep. The significance of this shallowness will become evident later. 1

14 Operations on Binary Tree There are a number of operations that can be defined for a binary tree. If p is pointing to a node in an existing tree then left(p) returns pointer to the left subtree right(p) returns pointer to right subtree parent(p) returns the father of p brother(p) returns brother of p. info(p) returns content of the node. Operations on Binary Tree There are a number of operations that can be defined for a binary tree. If p is pointing to a node in an existing tree then left(p) returns pointer to the left subtree right(p) returns pointer to right subtree parent(p) returns the father of p brother(p) returns brother of p. info(p) returns content of the node.

15 Operations on Binary Tree In order to construct a binary tree, the following can be useful: setleft(p,x) creates the left child node of p. The child node contains the info x. setright(p,x) creates the right child node of p. The child node contains the info x. Applications of Binary Trees A binary tree is a useful data structure when two-way decisions must be made at each point in a process. For example, suppose we wanted to find all duplicates in a list of numbers:,,,,,,,, 16,, 20, 1,,,

16 Applications of Binary Trees One way of finding duplicates is to compare each number with all those that precede it.,,,,,,,, 16,, 20, 1,,,,,,,,,,, 16,, 20, 1,,, If the list of numbers is large and is growing, this procedure involves a large number of comparisons. A linked list could handle the growth but the comparisons would still be large. The number of comparisons can be drastically reduced by using a binary tree. The tree grows dynamically like the linked list. 16

17 The binary tree is built in a special way. The first number in the list is placed in a node that is designated as the root of a binary tree. Initially, both left and right subtrees of the root are empty. We take the next number and compare it with the number placed in the root. If it is the same then we have a duplicate. Otherwise, we create a new tree node and put the new number in it. The new node is made the left child of the root node if the second number is less than the one in the root. The new node is made the right child if the number is greater than the one in the root. 1

18 ,,,,,,,, 16,, 20, 1,,,,,,,,,, 16,, 20, 1,,,

19 ,,,,,,, 16,, 20, 1,,,,,,,,, 16,, 20, 1,,, 1

20 ,,,,,, 16,, 20, 1,,,,,,,, 16,, 20, 1,,, 20

21 ,,,,, 16,, 20, 1,,,,,,, 16,, 20, 1,,, 21

22 ,,,, 16,, 20, 1,,,,,, 16,, 20, 1,,, 22

23 ,,, 16,, 20, 1,,,,, 16,, 20, 1,,, 2

24 ,, 16,, 20, 1,,,, 16,, 20, 1,,, 2

25 , 16,, 20, 1,,, 16 16,, 20, 1,,, 2

26 16 16,, 20, 1,,, 16, 20, 1,,, 26

27 , 1,,, , 1,,, 2

28 ,,, ,,, 28

29 ,, C++ Implementation #include <stdlib.h> template <class Object> class TreeNode { public: // constructors TreeNode() { this->object = NULL; this->left = this->right = NULL; }; TreeNode( Object* object ) { this->object = object; this->left = this->right = NULL; }; 2

30 C++ Implementation Object* getinfo() { return this->object; }; void setinfo(object* object) { this->object = object; }; TreeNode* getleft() { return left; }; void setleft(treenode *left) { this->left = left; }; C++ Implementation TreeNode *getright() { return right; }; void setright(treenode *right) { this->right = right; }; int isleaf( ) { if( this->left == NULL && this->right == NULL ) return 1; return 0; }; 0

31 C++ Implementation private: Object* object; TreeNode* left; TreeNode* right; }; // end class TreeNode C++ Implementation #include <iostream> #include <stdlib.h> #include "TreeNode.cpp" int main(int argc, char *argv[]) { int x[] = {,,,,,,,, 16,, 20, 1,,,, -1}; TreeNode<int>* root = new TreeNode<int>(); root->setinfo( &x[0] ); for(int i=1; x[i] > 0; i++ ) { insert(root, &x[i] ); } } 1

32 C++ Implementation void insert(treenode<int>* root, int* info) { TreeNode<int>* node = new TreeNode<int>(info); TreeNode<int> *p, *q; p = q = root; while( *info!= *(p->getinfo()) && q!= NULL ) { p = q; if( *info < *(p->getinfo()) ) q = p->getleft(); else q = p->getright(); } C++ Implementation if( *info == *(p->getinfo()) ){ cout << "attempt to insert duplicate: " << *info << endl; delete node; } else if( *info < *(p->getinfo()) ) p->setleft( node ); else p->setright( node ); } // end of insert 2

33 Trace of insert 1 p q ,,, Trace of insert 1 p q ,,,

34 Trace of insert 1 p q ,,, Trace of insert 1 p q ,,,

35 Trace of insert 1 p q ,,, Trace of insert 1 p q ,,,

36 Trace of insert 1 p q ,,, Trace of insert 1 p q 1,,, 6

37 Trace of insert p ,,, node 1 p->setright( node );