This action might not be possible to undo. Are you sure you want to continue?

Welcome to Scribd! Start your free trial and access books, documents and more.Find out more

CS 1037a – Topic 15

Overview

• General trees and terminology • Binary trees and their traversals • Binary search trees (BST)

• a more efficient alternative to OrderedList

15-2

Related materials

from Main and Savitch “Data Structures & other objects using C++”

• Chapter 10: Trees

- Sec. 10.1: Introduction to Trees - Sec. 10.2: Tree representations - Sec. 10.3 Binary tree nodes - Sec. 10.4 Tree traversals - Sec. 10.5 Binary Search Trees

**Tree Data Structures
**

• Trees are non-linear data structures that are often used to represent entities in a hierarchical relationship. Examples:

• • • • • Class hierarchies in C++ programs Computer file system (folders, subfolders) Decision-making process (decision trees) Family tree Table of contents in a book

15-4

Example: Computer File System Root directory of C drive Documents and Settings Program Files My Music Desktop Favorites Start Menu Adobe Microsoft Office 15-5 .

Example: “Spanning Tree” (from Assignment 4) 9 8 9 5 2 15 pixels (nodes) 7 9 6 3 1 2 2 3 1 8 2 3 1 2 2 0 9 2 7 6 direction toParent 1 5 4 3 7 2 8 3 9 seed (root) 8 6 5 11 10 A tree spanning image pixels (describing live-wire paths to the seed) 15-6 .

a tree has a single root 15-7 . .Tree Data Structures • A tree is a collection of items stored in nodes • Relations between nodes are called edges • Root: the origin of the tree.

or a set of one or more nodes partitioned into disjoint subsets: • A single root node • The subtrees of the root. no edges • General tree is the empty tree. also general trees.General Trees • Simplest tree is the empty tree: no nodes. each connected to the root by a distinct edge 15-8 .

Root node General Trees Interior nodes Leaf nodes 15-9 .

General Trees Subtrees of the root node 15-10 .

General Trees E Subtrees of the node labeled E 15-11 .

the parent of the parent of X. are descendants of X 15-12 . etc. the parent of X.General Trees • If nodes X and Y are connected by an edge and X is “closer” to the root than Y • X is the parent (or predecessor) of Y • Y is a child (or successor) of X • The ancestors of Y are X. the children of the children of Y. …. the children of Y. and the root • Y.

ancestors of Y General Trees parent of Y X parent edges Y child of X child of X child child child descendants of X 15-13 .

Example: “Spanning Tree” (from Assignment 4) 9 8 9 5 2 15 7 9 6 3 1 2 2 3 1 8 child 2 3 1 parent 2 2 0 9 2 7 6 8 5 6 3 7 2 8 3 9 root (seed) edges 1 child 4 5 11 10 Tree spanning image pixels (describing live-wire paths to the seed) 15-14 .

General Trees • The root is the only node in a tree that has no parent • Every other node has exactly one parent • Leaves are nodes with no children • An interior node is a node that is not a leaf • Two nodes are siblings if they have the same parent 15-15 .

e.examples of paths from a node to the root 9 15 8 8 9 3 9 3 2 5 2 0 2 3 2 7 6 1 2 1 2 6 8 1 5 6 2 3 5 9 2 7 3 Part of the assignment was to compute a tree with optimal paths to the seed in case when a cost of a path from any given node includes weights of nodes on the path.General Trees • A path is a sequence of edges leading from one node to another .g. 1 4 7 8 11 10 9 6=1+2+1+2 Example 1 Example 2: live-wire (Assignment 4) .tracing a path along given spanning tree .

General Trees • A path is a sequence of edges leading from one node to another • The length of a path is the number of edges on the path • The depth of a node N is the length of the path from the root to N • The height of a tree rooted at node N is the length of the longest path from N to a leaf 15-17 .

the height of a tree is the length of the longest path from the root to a leaf node • Height of a tree with only one node is 0 • Height of the empty tree is often considered to be -1 15-18 .General Trees • The height of a (non-empty) tree is the height of its root node • In other words.

General Trees • All nodes with depth N are said to be at level N of the tree • The degree (or arity) of a node is the number of children it has • The degree (or arity) of a tree is the maximum of the degrees in the tree’s nodes 15-19 .

leaf nodes have degree 0 E Level 1 Level 2 The tree has height 3 Level 3 Node E has depth 1. the subtree rooted at E has height 2 Node E has degree 3 15-20 .General Trees Level 0 Root node has degree 4.

Binary Trees • Binary tree: a tree with degree (arity) 2 • Each node in a binary tree has a data portion. plus references to its left and right successors • Recursive nature of binary tree structure is very important when we design algorithms to operate on the tree 15-21 .

Binary Tree Nodes • We will use binary tree nodes that contain • data Item • two pointers to its left and right children comment: pointer to a parent node can also be used in trees (as in Assignment 4) data item In our drawings we use simplified diagrams Node* left Node* right 15-22 .

Binary Tree Traversals • Traversal of a data structure requires that each item in the data structure be visited once • What we do when we visit an item depends on the application (modify the value of the item. print out the value. etc) • There is no forced order for a traversal 15-23 .

which one(s) we use depends upon our needs 15-24 . there are several standard orders for traversal.Binary Tree Traversals • However. with linear data structures. there is usually a natural order we’d choose for a traversal • With trees.

Preorder Traversal • Start at the root. and use recursion: if the tree is not empty { Visit the item at the root node r /* 1 */ /* 2 */ Perform a preorder traversal of the left subtree of r Perform a preorder traversal of the right subtree of r /* 3 */ } 15-25 .

returns. and “visits” will be numbered in the order they occur 15-26 .Preorder Traversal A B C D E F G H I We’ll trace the different traversals using this tree. recursive calls.

. . . . Nodes are visited in the order ABDHECFIG . .Preorder Traversal A 2 1: visit A 24 23 45 B 3: visit B C 25: visit C 4 16 26 38 15 22 37 44 39: D 5: visit D E 17: visit E F 27: visit F G visit G 18 8 28 21 40 19 20 34 35 36 41 42 43 7 14 H 9: visit H I 29: visit I 30 33 10 13 1112 31 32 6 . . . 15-27 .

Inorder Traversal • Only difference from preorder traversal is that the data object is visited after the recursive call for the left subtree: if the tree is not empty { Perform an inorder traversal of the left subtree of r. /* 3 */ } 15-28 . Visit the item at the root node r. /* 2 */ /* 1 */ Perform an inorder traversal of the right subtree of r.

Inorder Traversal A 1 23: visit A 24 22 45 B 14: visit B C 37: visit C 2 15 25 38 13 21 36 44 41: D 5: visit D E 18: visit E F 33: visit F G visit G 16 6 26 20 39 17 19 32 34 35 40 42 43 4 12 H 9: visit H I 29: visit I 27 31 7 11 8 10 28 30 3 . . . Nodes are visited in the order DHBEAIFCG . . . . . . 15-29 .

} /* 3 */ 15-30 .Postorder Traversal • In this case. /* 2 */ Visit the item at the root node r. the data object in a node is not visited until after the contents of both its subtrees have been visited: if the tree is not empty { Perform a postorder traversal of the left subtree of r. /* 1 */ Perform a postorder traversal of the right subtree of r.

. . .Postorder Traversal A 1 45: visit A 23 22 44 B 21: visit B C 43: visit C 2 14 24 36 13 20 35 42 41: D 12: visit D E 19: visit E F 34: visit F G visit G 15 5 25 18 37 16 17 31 32 33 38 39 40 4 11 H 10: visit H I 30: visit I 26 29 6 9 7 8 27 28 3 . 15-31 . Nodes are visited in the order HDEBIFGCA . . . . .

Recursive Binary Tree Traversals • Note that the relative order of the recursive calls in preorder. inorder and postorder traversals is the same • The only differences stem from where the visiting actually takes place 15-32 .

the programmer keeps track • Iterative traversal uses a container to store (addresses of) nodes not yet visited • Order of visiting will depend on the type of container being used (stack.Iterative Traversals of Tree Nodes • Recursive tree traversals use the call stack to keep track of where we’re working in the tree • In iterative traversals. etc) 15-33 . bag. queue.

Iterative Traversals of Tree Nodes // PRECONDITION: the tree is not empty Create an empty container to hold (pointers to) nodes to be visited Put the root node address into the container While the container is not empty { Remove a pointer T from the container Visit the node T points to Put pointers to all non-empty successors of T in the container } NOTE: image pixels in labs 9-10 and assignment 4 form a grid (graph). . iterative traversals of tree nodes are graph nodes (e. not a tree. image pixels) are similar. Compare this code with floodFill_xxx() based on different active front containers.g. Yet.

and we push the right child of a node before the left child. we get a level order traversal (analogous to Breadth-First-Search in labs 9-10) 15-35 .Iterative Traversals of Tree Nodes • If the container is a bag. we get preorder traversal (analogous to Depth-First-Search in labs 9-10) • If the container is a queue. order of visits will be unpredictable (exercise: implement FloodFill_Bag() in lab 9-10) • If the container is a stack. and we enqueue the left successor before the right.

Level Order Traversal A B C D E F G H I Nodes will be visited in the order ABCDEFGHI 15-36 .

**Tree Traversal Exercises
**

• Trace the iterative tree traversal algorithm using different kinds of containers (bag, stack, queue) • Try to figure out iterative traversal algorithms that will yield inorder and postorder traversals

15-37

**Algorithms Based on Traversals
**

• Example 1: The shape of a binary tree can be described by a string of zeroes and ones; each node is described by two digits:

• • • • 00 – a leaf: no successors 01 – has a right successor only 10 – has a left successor only 11 – has both left and right successors

15-38

**Algorithms Based on Traversals
**

11

(1)

11

(2)

01

(6)

String representing a tree can be built using a preorder traversal of the tree: visiting a node corresponds to appending two digits to the string.

00

(3)

10

(4)

00

(7)

00

(5)

This tree is described by string

11110010000100

root left and right sub-trees

**Algorithms Based on Traversals
**

11 11 00 00

Tree can be re-build from string Conversely, a tree can be built from the string description in preorder fashion: Save first two digits from the string. Build the root node.

01 10 00

If first digit is 1, use remainder of string to recursively build left sub-tree of root If second digit is 1, use remainder of string to recursively build right sub-tree of root

11110010000100

shown later 15-41 .Algorithms Based on Traversals • Example 2: The destructor for a binary tree can be written using a postorder traversal: • Visiting a node is node deletion • Both subtrees of a node N are deleted before N is deleted • We do this in the binary search tree code.

(1) (3) (5) delete root. deleteSubtree( right child ). } // “visiting” a node (2) .Algorithms Based on Traversals (7) a tree can be deleted in post-order fashion (using pseudo-code): deleteSubtree ( root ) { (4) (6) deleteSubtree( left child ).

Often. algorithm may vary depending on the application 15-43 .Operations on Binary Trees • Searching a general binary tree to locate an object requires a traversal of the tree. we may have to visit all nodes • Removal involves searching for a node with a specific value and deleting the node. this requires reconfiguring the tree so that it’s still a binary tree.

the algorithm may depend on the application 15-44 . again.Operations on Binary Trees • Inserting involves searching for an appropriate location and then adding a node in such a way that the resulting structure is still a binary tree.

Binary Search Trees (BST) 15-45 .

Binary Search Trees • A binary search tree (BST) is a special case of binary tree (its nodes should satisfy BST property. insert and remove) for BST have better complexity than similar operations for OrderedList 15-46 . see next slide) • BST is a very efficient data structures for storing and maintaining an ordered set of data • a better alternative to our OrderedList • basic operations (e.g.

<=.Binary Search Trees • Definition: BST is a binary tree where each node N satisfies the following BST property: • all nodes L in the left sub-tree of N have data items such that (Item at L) <= (Item at N) • all nodes R in the right sub-tree of N have data items such that (Item at R) >= (Item at N) • Items in BST should have at least one overloaded comparison operator <. >. or >= 15-47 .

Binary Search Trees • A binary tree is a binary search tree if all nodes in the tree have the BST property 5 3 7 7 2 5 8 5 5 8 15-48 2 3 .

Traversal of Binary Search Tree • An inorder traversal visits the nodes of the binary search tree in sorted order 5 (4) if the tree is not empty { Perform an inorder traversal of the left subtree of r. 3 (2) 7 (5) } Perform an inorder traversal of the right subtree of r* 2 (1) 5 (3) 8 (6) Print out: 235578 15-49 . print out item value at the root node r.

return false. return true 15-50 . 8 26 If k < item at root Return the result from recursively searching the left sub-tree 3 12 19 Else if item at root < k Return the result from recursively 9 23 searching the right sub-tree Else root item is equivalent to k.Searching Binary Search Trees 14 To find item k starting at tree root: If the tree is empty.

return false when node containing 12 has no right successor Search for 22: return false when node containing 23 has no left successor 15-51 .Searching Binary Search Trees 14 14 8 26 8 26 3 12 19 3 12 19 9 23 9 23 Search for 13: visited nodes are coloured red.

Binary Search Tree Insertion • When we insert an item. we need to add the new node in such a way that the resulting tree is still a BST • New node will be added as a leaf • Algorithm is very similar to the search algorithm 15-52 .

Binary Search Tree Insertion To insert a value k into a tree with a given "root" If the tree is empty (no root node) Build a new root node containing k Else if k < (item at root) Insert value k into the left sub-tree of the root Else Insert value k into the right sub-tree or the root 15-53 .

3 12 19 9 23 13 15-54 . build the new node. attach it as the right successor of the node containing 12. Instead of returning false when the node containing 12 has no right successor. and return true.Binary Search Tree Insertion 14 To insert 13: 8 26 Same nodes are visited as when searching for 13.

Removing Min/Max from Binary Search Tree 5 4 6 To remove min: . then the node with min value is found and its value (1) can be returned 1 5 7 4 8 11 3 2 15-55 .go to the left from the root until no left child.

but what to do about its possible right sub-tree? 1 5 7 4 8 11 3 2 15-56 . then the node with min value is found and its value (1) can be returned .Removing Min/Max from Binary Search Tree 5 4 6 To remove min: .the node should be deleted.go to the left from the root until no left child.

its parent can "adopt” it. but what to do about its possible right sub-tree? 1 5 7 4 8 11 . then the node with min value is found and its value (1) can be returned .since the node has one child only. 3 2 BST property is preserved.Removing Min/Max from Binary Search Tree 5 4 6 To remove min: .go to the left from the root until no left child. why? 15-57 .the node should be deleted.

15-58 .save current root value as SAVED .Removing Min/Max from Binary Search Tree To remove minimum Item from a BST tree PRECONDITION: the tree root can not be empty If root has a left child .return SAVED value Maximum item can be removed and returned similarly. the old root is deleted . thus its value is the minimum in the tree . the root has no left child.return min Item removed from the left sub-tree (recursively) Else.the right child (if any) becomes a new root.

the tree needs no further arrangement as it still satisfies the BST property • if Item is an interior node with one child • Re-link the node's parent with its only child and then delete the node Why BST property is preserved? 15-59 .Removing Arbitrary Item from Binary Search Tree • if Item is a leaf node (no children) • delete the node.

but replace its value with the minimum Item removed from the right sub-tree • alternatively.Removing Arbitrary Item from Binary Search Tree • if Item is an interior node with both children • keep the node. replace node's value by the maximum Item removed from the left sub-tree Why BST property is preserved? 15-60 .

and remove operations are O(tree height) . insert. . it’s O(log2(n)) 15-61 .in the worst case. this is O(n).Time Complexities for Tree Operations • Binary Tree: • All traversals are O(n): each node is visited exactly once • Binary Search Tree: • find.in best and average cases.

h" template <class Item. 15-62 . Node * left. // constructor for empty binary search tree // BST destructor // cont’d. *right. BST( ).h #include “Queue. Node* ln = NULL.h” #include "StandardFunctors. ~BST( ). left(ln). class Order=IsLess> class BST { public: class Node { public: Node( Item val. right(rn) { } Item value.BST. Node* rn=NULL ) : value(val). }..

and false otherwise void insert( Item item ). // true if BST is empty.. 15-63 . // insert item in a new leaf node // at an appropriate place in the tree Item removeMin( ). // removes the minimum Item from BST // Precondition: BST should not be empty Item removeMax( ).BST. // true if an Item equivalent to key // is found. // removes the minimum Item from BST // Precondition: BST should not be empty // cont’d.h bool isEmpty( ) const. false otherwise // number of nodes in the BST bool find( Item key ) const. int size( ) const.

h Queue<Item> * preorder( ) const.BST. // Return a queue that contains. // copies of items stored inside BST cont’d. 15-64 . in inorder traversal order. // Return a queue that contains. // copies of items stored inside BST Queue<Item> * inorder( ) const. // copies of items stored inside BST Queue<Item> * postorder( ) const. // Return a queue that contains. in postorder traversal order. in preorder traversal order..

return false otherwise void insert( Item item.BST. Node * here ) const. // call by reference // delete the subtree rooted at here bool find( Item key. void deleteSubtree( Node * &here ). 15-65 .. // call by reference // insert item in the sub-tree rooted at node here cont’d. int m_size. Node* &here ). // return true if item identical to key is found in the sub-tree // rooted at here.h private: Node * m_root.

BST. // call by reference // removes the Minimum item from the sub-tree rooted at // node here and returns its value. 15-66 .h Item removeMax( Node* &here ). // call by reference // removes the Maximum item from the sub-tree rooted at // node here and returns its value. // PRECONDITION: sub-tree can not be empty cont’d. // PRECONDITION: sub-tree can not be empty Item removeMin( Node* &here )..

Node * here ) const.template” // end of BST. // Traverse the nodes in the sub-tree rooted at here in preorder // fashion. // Traverse the nodes in the sub-tree rooted at here in postorder // fashion. // Traverse the nodes in the sub-tree rooted at here in inorder // fashion. Node * here ) const. Node * here ) const.h 15-67 . and enqueue copies of Items into q in that order } #include “BST. and enqueue copies of Items into q in that order void postorder( Queue<Item> *q. and enqueue copies of Items into q in that order void inorder( Queue<Item> *q.BST.h void preorder( Queue<Item> *q.

. } template <class Item .Order> :: BST( ) : m_root (NULL).Order> :: size( ) const {return m_size. class Order> BST<Item. class Order> bool BST<Item. // call by reference } template <class Item . 15-68 .BST. class Order> BST<Item. } // cont’d. class Order> int BST<Item.template template <class Item. m_size (0) { } template <class Item .Order> :: isEmpty( ) const {return (m_size == 0).Order> :: ~BST( ) { deleteSubtree( m_root ).

m_root ). 15-69 ..Order> :: insert( Item item ) { insert( item.Order> :: find( Item key ) const { return find( key. } template <class Item . class Order> void BST<Item.BST.template template <class Item . // call by reference } // cont’d. class Order> bool BST<Item. m_root ).

Order> :: removeMin( ) { // PRECONDITION: tree can not be empty return removeMin( m_root ).template template <class Item . class Order> Item BST<Item. // call by reference } // cont’d.. 15-70 . class Order> Item BST<Item.BST.Order> :: removeMax( ) { // PRECONDITION: tree can not be empty return removeMax( m_root ). // call by reference } template <class Item .

Order> :: postorder( ) const { Queue<Item> * q = new Queue<Item>( ). template template <class Item . m_root ). preorder( q. return q.Order> :: preorder( ) const { Queue<Item> * q = new Queue<Item>( ). class Order > Queue<Item> * BST<Item. } template <class Item . m_root ). class Order> Queue<Item> * BST<Item. inorder( q. return q. m_root ). 15-71 . class Order> Queue<Item> * BST<Item.BST. postorder( q.Order> :: inorder( ) const { Queue<Item> * q = new Queue<Item>( ).. return q. } // cont’d. } template <class Item .

here = NULL.. 15-72 . // base case deleteSubtree( here->left ). // call by reference delete here. // call by reference deleteSubtree( here->right ). // this is where call by reference helps!!! } // cont’d. m_size--. template template <class Item .Order> :: deleteSubtree( Node * &here ) { if (here == NULL) return.BST. class Order> void BST<Item.

current)) return find(key. 15-73 . key)) return find(key. else } /* "current == key" */ return true.here->left). if (Order::compare(key .here->right).Order> :: find( Item key. class Order> bool BST<Item. // base case Item current = here->value. // cont’d.BST.. else if (Order::compare(current . Node * here ) const { if (here == NULL) return false. template template <class Item .

Node* &here ) { if ( here == NULL ) { // base case here = new Node(item). } else if (Order::compare(item . } // cont’d.here->right).BST. here->value)) insert(item.here->left). else insert(item. class Order> void BST<Item. template template <class Item. 15-74 .Order> :: insert( Item item. // this is where call by reference helps!!! m_size++..

// deleting a node m_size--. return saved. // this is where call by reference helps!!! delete tmp. } } // 15-75 cont’d.BST.e.. else { // no right child => here is a node with MAX value Item saved = here-> value.Order> :: removeMax( Node* &here ) { // PRECONDITION: sub-tree can not be empty (i. template template <class Item. here = here->left. . class Order> Item BST<Item. here!=NULL) if (here->right != NULL) return removeMax(here->right). Node * tmp = here.

// deleting a node m_size--.BST. template template <class Item. return saved. class Order> Item BST<Item.Order> :: removeMin( Node* &here ) { // PRECONDITION: sub-tree can not be empty (i. // this is where call by reference helps!!! delete tmp. here!=NULL) if (here->left != NULL) return removeMin(here->left). here = here->right. } } // 15-76 cont’d.e. else { // no left child => here is a node with MIN value Item saved = here-> value. Node * tmp = here.. .

} // cont’d. template template <class Item.. // base case q->enqueue( here->value ). 15-77 . preorder( q.Order>:: preorder( Queue<Item> *q. class Order> void BST<Item. Node * here ) const { if ( here == NULL ) return. here->left ). preorder( q. here->right ).BST.

class Order> void BST<Item.Order> :: inorder( Queue<Item> *q. here->right ).. template template <class Item. q->enqueue( here->value ). // base case inorder( q. } // cont’d. inorder( q. Node * here ) const { if ( here == NULL ) return. 15-78 . here->left ).BST.

} // end of BST. q->enqueue( here->value ). postorder( q.Order> :: postorder( Queue<Item> *q. here->right ). // base case postorder( q. Node * here ) const { if ( here == NULL ) return. template template <class Item. here->left ).template 15-79 .BST. class Order> void BST<Item.

Node * & here ). otherwise // do not change tree and return false. // if item identical to key is in the BST. HINT: see code for function find() and slides 53-54 15-80 . do nothing and return false. // if item identical to key is in the sub-tree rooted at node here. // remove it and return true.Additional BST Functions • Exercise: implement two extra member functions public: bool remove ( Item key ). o. private: bool remove ( Item key.w. // remove it and return true.

OrderedList operations insert and remove are O(n) .additional tricks maybe necessary to keep the tree “balanced” (height log2(n)) • In contrast.BST vs Ordered List • Binary Search Tree is a very efficient data structure for maintaining ordered data sets with average case complexity O(log2(n)) for insert and remove operations .applies to array-based and LinkedList-based OrderedLists (as discussed earlier) 15-81 .

the items are dequeued according to their priorities. For example.BST as a Priority Queue priority queue differs from standard queue as follows: instead of FIFO order.O(log2(n)) Question: what would be complexity of enqueue and dequeue if priority queue used OrderedList container? 15-82 . which can be defined by overloaded comparison operators < or >. For example. dequeue for priority queue can return an item with the largest (or the smallest) value in the queue. average case complexity - Can use BST to implement a priority queue. use for enqueue use insert for dequeue use removeMax .O(log2(n)) .

• based on binary trees (heaps) different from BST .1 “Heaps” 15-83 . priority queue can be implemented even more efficiently with guaranteed worst case complexity O(log2(n)) for enqueue and dequeue. 11.optional text-book reading: Sec.Priority Queue • In fact.

That is it for CS1037! (see summary on the next slide) .

. stacks. .. sorting) and analysis of their complexity This is only where it starts. queues. object-oriented programming basic data structures: (array-based lists...Summary of CS1037 • • • • dynamic and static memory allocation.. if you take Computer Science courses on algorithms. pointers C++. classes. trees) basic algorithms (e.g. optimization. data structures. linked-lists. templates.

- Important Information 11.4.nopeq
- sml401 Term Paper IIT Delhi.pdf
- dp5725
- Instructions
- Xiaomiindia Service Center Locations 0729 Wo Phone
- Vivek12
- Download Brochure
- Polity, Art & Culture , C.a.(Sep - Oct) Dec Disp
- IITD_TNF
- Complex Analysishhh
- Proxy Setting best ever
- New Online Appointment Booking Process
- SemScheduleII1314.PDF
- Going Global.pdf
- 1-s2.0-S0378720601001343-main.pdf
- 1631513
- 852241.pdf
- bsnlprepaid.pdf
- 852241.pdf
- ROOM 3rd YR.docx
- CYL230.docx
- nomenclature.pdf
- bsnlprepaid.pdf
- s.pdf

hrzzzz

hrzzzz

- Data Structures
- BOB Placement Paper | Freshers Choice
- Semantically Partitioned Object sap bw 7.3
- CCNA3 M7 Spanning-Tree Protocol
- A Tree-Based Peer-to-Peer Network with Quality Guarantees
- Dirac Spec Latest
- Discrete Cosine Transform
- Cs102 Data Struct
- Syllabus
- Complex Tr1
- Fast and Efficient QoS-Guaranteed Adaptive Transmission Algorithm in the Mobile WiMAX System
- WebGL
- 03 Data Types
- Jasper Report Tutorial
- Chapter 4 Ql
- Amazon - Manoftoday
- Polymorph is m
- Pug Latest
- Dos and Bios Interrupts
- r Montecarlo
- Data Compersion
- LLRB
- Discipulus - Decompiled Program Interface
- Zerotree Coding Iccvgip 00
- OQL Reference
- CitectSCADA+Cicode+Reference
- SQL Data Types
- Object Oriented Programming
- Compilers
- c Pointers fdshgh fdshhfh

Are you sure?

This action might not be possible to undo. Are you sure you want to continue?

We've moved you to where you read on your other device.

Get the full title to continue

Get the full title to continue listening from where you left off, or restart the preview.

scribd