Scribd
Upload
15 views

Trees

The document discusses different data structures for searching, including sequential searches of arrays and linked lists that have time complexity of O(n), binary searches of sorted arrays that are O(log n), and binary trees that allow finding, adding, and deleting in O(log n) time. While binary trees provide efficient searching, addition, and deletion, forming a balanced binary tree from an unsorted list of items can result in a skewed tree where some operations have O(n) time complexity rather than O(log n).

Uploaded by

virulentus999
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
15 views

Trees

The document discusses different data structures for searching, including sequential searches of arrays and linked lists that have time complexity of O(n), binary searches of sorted arrays that are O(log n), and binary trees that allow finding, adding, and deleting in O(log n) time. While binary trees provide efficient searching, addition, and deletion, forming a balanced binary tree from an unsorted list of items can result in a skewed tree where some operations have O(n) time complexity rather than O(log n).

Uploaded by

virulentus999
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 16

Data Structures and Algorithms

Searching
Searching
• Sequential Searches
• Time is proportional to n
• We call this time complexity O(n)
• Pronounce this “big oh” of n
• Both arrays (unsorted) and linked lists
• Binary search
• Sorted array
• Time proportional to log2 n
• Time complexity O(log n)
Searching - Binary search
• Creating the sorted array
• AddToCollection
• adds each item in correct place
• Find position c1 log2 n
• Shuffle down c2 n
• Overall c1 log2 n + c2 n
Dominant
or c2 n term
• Each add to the sorted array is O(n)
? Can we maintain a sorted array
with cheaper insertions?
Trees
• Binary Tree
• Consists of
• Node
• Left and Right sub-trees
• Both sub-trees are binary trees
Trees
• Binary Tree
• Consists of
• Node
• Left and Right sub-trees Note the
• Both sub-trees are binary trees recursive
definition!

Each sub-tree
is itself
a binary tree
Trees - Implementation
• Data structure

struct t_node {
void *item;
struct t_node *left;
struct t_node *right;
};

typedef struct t_node *Node;

struct t_collection {
Node root;
……
};
Trees - Implementation
• Find
extern int KeyCmp( void *a, void *b );
/* Returns -1, 0, 1 for a < b, a == b, a > b */

void *FindInTree( Node t, void *key ) { Less,


if ( t == (Node)0 ) return NULL; search
switch( KeyCmp( key, ItemKey(t->item) ) ) { left
case -1 : return FindInTree( t->left, key );
case 0: return t->item;
case +1 : return FindInTree( t->right, key );
}
} Greater,
search right
void *FindInCollection( collection c, void *key ) {
return FindInTree( c->root, key );
}
Trees - Implementation
• Find
• key = 22;
if ( FindInCollection( c , &key ) ) ….

n = c->root;
FindInTree( n, &key );
FindInTree(n->right,&key );

FindInTree(n->left,&key );

return n->item;
Trees - Performance
• Find
• Complete Tree

• Height, h
• Nodes traversed in a path from the root to a leaf
• Number of nodes, h
• n = 1 + 21 + 22 + … + 2h = 2h+1 - 1
• h = floor( log2 n )
Trees - Performance
• Find
• Complete Tree

• Since we need at most h+1 comparisons,


find in O(h+1) or O(log n)
• Same as binary search
Lecture 2 & 3 - Summary

Arrays Linked List Trees


Simple, fast Simple Still Simple
Inflexible Flexible Flexible
Add O(1) O(1)
O(n) inc sort sort -> no adv
Delete O(n) O(1) - any
O(n) - specific
Find O(n) O(n) O(log n)
O(logn) (no bin search)
binary search
Trees - Addition
• Add 21 to the tree

• We need at most h+1 comparisons


• Create a new node (constant time)
add takes c1(h+1)+c2 or c log n Ignoring
• So addition to a tree takes low order
terms
time proportional to log n
also
Trees - Addition - implementation
static void AddToTree( Node *t, Node new ) {
Node base = *t;
/* If it's a null tree, just add it here */
if ( base == NULL ) {
*t = new; return; }
else
if( KeyLess(ItemKey(new->item),ItemKey(base->item)) )
AddToTree( &(base->left), new );
else
AddToTree( &(base->right), new );
}

void AddToCollection( collection c, void *item ) {


Node new, node_p;
new = (Node)malloc(sizeof(struct t_node));
/* Attach the item to the node */
new->item = item;
new->left = new->right = (Node)0;
AddToTree( &(c->node), new );
}
Trees - Addition
• Find c log n
• Add c log n
• Delete c log n

• Apparently efficient in every respect!

• But there’s a catch ………..


Trees - Addition
• Take this list of characters and form a tree
A B C D E F

• ??
Trees - Addition
• Take this list of characters and form a tree
A B C D E F

• In this case
? Find
? Add
? Delete

You might also like