0% found this document useful (0 votes)
28 views29 pages

Binary Trees: (And Big "O" Notation)

The document discusses binary trees, including their definition as a linked data structure where each element has two potential successors. It covers searching and adding elements to a binary tree recursively, and notes that a balanced binary tree can search for an element in O(log n) time compared to O(n) for a linked list. The document also discusses traversing binary trees in different orders like in-order, pre-order and post-order.

Uploaded by

ayene
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
0% found this document useful (0 votes)
28 views29 pages

Binary Trees: (And Big "O" Notation)

The document discusses binary trees, including their definition as a linked data structure where each element has two potential successors. It covers searching and adding elements to a binary tree recursively, and notes that a balanced binary tree can search for an element in O(log n) time compared to O(n) for a linked list. The document also discusses traversing binary trees in different orders like in-order, pre-order and post-order.

Uploaded by

ayene
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/ 29

Binary Trees

(and Big “O” notation)

CS-2303
System Programming Concepts
(Slides include materials from The C Programming Language, 2nd edition, by Kernighan and Ritchie and
from C: How to Program, 5th and 6th editions, by Deitel and Deitel)

CS-2303, C-Term 2010 Binary Trees 1


Definitions

• Linked List
• A data structure in which each element is
dynamically allocated and in which elements point
to each other to define a linear relationship
• Singly- or doubly-linked
• Stack, queue, circular list
• Tree
• A data structure in which each element is
dynamically allocated and in which each element
has more than one potential successor
• Defines a partial order
CS-2303, C-Term 2010 Binary Trees 2
Binary Tree

• A linked list but with payload


two links per item left right

struct treeItem {
type payload; payload payload
treeItem *left; left right left right
treeItem *right;
}; payload
left right payload payload
left right left right
payload
left right

CS-2303, C-Term 2010 Binary Trees 3


Binary Tree (continued)

• Binary tree needs a root


struct treeItem {
type payload;
treeItem *left; treeItem *right;
};
struct treeItem *root;

• Binary trees often drawn with root at top!


• Unlike ordinary trees in the forest
• More like the root systems of a tree

CS-2303, C-Term 2010 Binary Trees 4


Definitions (continued)
See Deitel & Deitel, §12.7
• Binary Tree K & R, §6.5
• A tree in which each element has two potential
successors
• Subtree
• The set of nodes that are successors to a specific
node, either directly or indirectly
• Root of a tree
• The node of the tree that is not the successor to any
other node, all other nodes are (directly or
indirectly) successors to it
CS-2303, C-Term 2010 Binary Trees 5
Binary Tree
struct treeItem { payload
type payload; left right
treeItem *left;
treeItem *right;
};
payload payload
struct treeItem *root; left right
left right

payload
left right payload payload
left right left right
payload
left right

CS-2303, C-Term 2010 Binary Trees 6


Purpose of a Tree

• (Potentially) a very large data structure


• Capable of storing very many items
• In an orderly way
• Need to find items by value
• I.e., need to search through the data structure to see if it
contains an item with the value we want
• Need to add new items
• If value is not already in the tree, add a new item …
• …so that it can be easily found in future

• Why not use a linked list?


CS-2303, C-Term 2010 Binary Trees 7
Searching and Adding to a Binary Tree
• Look recursively down
sequence of branches until payload
either left right
– Desired node is found; or
– Null branch is encountered
• Replace with ptr to new item payload payload
• Decide which branch to left right left right
follow based on payload
payload
left right payload payload
left right left right
payload
left right

CS-2303, C-Term 2010 Binary Trees 8


Example — Searching a Tree
typedef struct _treeItem {
char *word; // part of payload
int count; // part of payload
_treeItem *left, *right;
} treeItem;

treeItem *findItem(treeItem *p, char *w) {


if (p == NULL)
return NULL; // item not found

int c = strcmp(w, p->word);


if (c == 0)
return p;
else if (c < 0)
return findItem(p->left, w);
else
return findItem(p->right, w);
}

CS-2303, C-Term 2010 Binary Trees 9


Example — Adding an Item
treeItem *addItem(treeItem *p, char *w) {
if (p == NULL){
p = malloc(sizeof(treeItem));
char *c = malloc(strlen(w)+1);
p->word = strcpy(c, w); Why do this?
p->count = 1;
p->left = p->right = NULL;
return p;
};
int c = strcmp(w, p->word);
if (c == 0)
p->count++;
else if (c < 0)
p->left = addItem(p->left, w);
else
p->right = addItem(p->right, w);
return p;
}
CS-2303, C-Term 2010 Binary Trees 10
Binary Tree

• Question:– how many payload


calls to addItem for left right

a tree with 106 nodes?


– Assume balanced payload payload
– I.e., approx same number of left right left right
nodes on each subtree

payload
left right payload payload
left right left right
payload
left right

CS-2303, C-Term 2010 Binary Trees 11


Answer

• Approximately 20 calls to addItem

• Note:–
– 210 = 1024  103
– Therefore 106  220
– Therefore it takes approximately 20 two-way branches
to cover 106 items!

• How many comparisons would it take to search a


linked list of 106 items?
CS-2303, C-Term 2010 Binary Trees 12
Observation

• Problems like this occur in real life all the


time
• Need to maintain a lot of data
• Usually random
• Need to search through it quickly
• Need to add (or delete) items dynamically
• Need to sort “on the fly”
• I.e., as you are adding and/or deleting items

CS-2303, C-Term 2010 Binary Trees 13


Questions?

CS-2303, C-Term 2010 Binary Trees 14


Binary Trees (continued)

• Binary tree does not need to be “balanced”


• i.e., with approximate same # of nodes hanging
from right or left

• However, it often helps with performance

• Multiply-branched trees
• Like binary trees, but with more than two links per
node

CS-2303, C-Term 2010 Binary Trees 15


Binary Trees (continued)

• Binary tree does not need to be “balanced”


• i.e., with approximate same # of nodes hanging from
right or left :–
tion ta
” n o r o f”
ig - O “o r d e
“ B ns
e a
• However, it helps with performance m
• Time to reach a leaf node is O(log2 n), where n is
number of nodes in tree

• Multiply-branched trees
• Like binary trees, but with more than two links per
node
CS-2303, C-Term 2010 Binary Trees 16
Order of Traversing Binary Trees
• In-order
• Traverse left sub-tree (in-order)
• Visit node itself
• Traverse right sub-tree (in-order)
• Pre-order
• Visit node first
• Traverse left sub-tree
• Traverse right sub-tree
• Post-order
• Traverse left sub-tree
• Traverse right sub-tree
• Visit node last
CS-2303, C-Term 2010 Binary Trees 17
Question

• Suppose we wish to print out the strings


stored in the tree of the previous example in
alphabetical order?

• What traversal order of the tree should we


use?

CS-2303, C-Term 2010 Binary Trees 18


Another Example of Binary Tree
x = (a.real*b.imag - b.real*a.imag) /
sqrt(a.real*b.real – a.imag*b.imag)
=

x /
- sqrt

* * -


. . . .

a real b imag b real a imag


CS-2303, C-Term 2010 Binary Trees 19
Question

• What kind of traversal order is required for


this expression?
• In-order?
• Pre-order?
• Post-order?

CS-2303, C-Term 2010 Binary Trees 20


Binary Trees in Compilers

• Used to represent the structure of the


compiled program
Note: Deitel & Deitel, Ch 12 exercises,
• Optimizations contain a series on building a compiler
• Common sub-expression detection
• Code simplification
• Loop unrolling
• Parallelization
• Reductions in strength – e.g., substituting additions
for multiplications, etc.
• Many others
CS-2303, C-Term 2010 Binary Trees 21
Questions?

CS-2303, C-Term 2010 Binary Trees 22


“Big O” notation

New Topic

CS-2303, C-Term 2010 Binary Trees 23


Linked Lists Again

• Linear data structure n ,


a l to
on f
• Easy to grow and shrink p
ti
or er o st
p ro m b e l i
., u h
• Easy to add and delete items I.e the n s in t
m
ite

• Time to search for an item – O(n)

CS-2303, C-Term 2010 Binary Trees 24


Binary Trees Again

• Non-linear data structure


al to f
on r o
• Easy to grow and shrink p
ti
or mbe st
p ro n u e l i
., f h
• Easy to add and delete items I.e log o s in t
m
ite

• Time to search for an item – O(log n)

CS-2303, C-Term 2010 Binary Trees 25


Definition — Big-O
“Of the order of …”
• A characterization of the number of
operations in an algorithm in terms of a
mathematical function of the number of
data items involved

• O(n) means that the number of operations to


complete the algorithm is proportional to n

• E.g., searching a list with n items requires,


on average, n/2 comparisons with payloads
CS-2303, C-Term 2010 Binary Trees 26
Big-O (continued)

• O(n): proportional to n – i.e., linear


• O(n2): proportional to n2 – i.e., quadratic
• O(kn) – proportional to kn – i.e., exponential
• …
• O(log n) – proportional to log n – i.e.,
sublinear
• O(n log n)
• Worse than O(n), better than O(n2)
• O(1) – independent of n; i.e., constant
CS-2303, C-Term 2010 Binary Trees 27
Anecdote & Questions:–

• In the design of electronic adders, what is the


order of the carry-propagation?

• What is the order of floating point divide?

• What is the order of floating point square root?

• What program have we studied in this course that


is O(2n)? i.e., exponential?

CS-2303, C-Term 2010 Binary Trees 28


Questions on Big-O?

CS-2303, C-Term 2010 Binary Trees 29

You might also like