Module 4

Trees, Binary Trees-Tree Operations, Binary Tree Representation, Tree Traversals, Binary
Search Trees- Binary Search Tree Operations
Graphs, Representation of Graphs, Depth First Search and Breadth First Search on Graphs,
Applications of Graphs

1. TREES AND GRAPHS

In linear data structure data is organized in sequential order and in non-linear data structure data is
organized in random order. A tree is a very popular non-linear data structure used in a wide range of
applications.

Tree is a non-linear data structure which organizes data in hierarchical structure and this is a
recursive definition.
In tree data structure, every individual element is called as Node. Node in a tree data structure stores
the actual data of that particular element and link to next element in hierarchical structure.

Terminology

1. Root
In a tree data structure, the first node is called as Root Node. Every tree must have a root node. We can
say that the root node is the origin of the tree data structure. In any tree, there must be only one root
node. We never have multiple root nodes in a tree.

2. Edge
In a tree data structure, the connecting link between any two nodes is called as EDGE. In a tree with 'N'
number of nodes there will be a maximum of 'N-1' number of edges.
3. Parent
In a tree data structure, the node which is a predecessor of any node is called as PARENT NODE. In
simple words, the node which has a branch from it to any other node is called a parent node. Parent
node can also be defined as "The node which has child / children".

4. Child
In a tree data structure, the node which is descendant of any node is called as CHILD Node. In simple
words, the node which has a link from its parent node is called as child node. In a tree, any parent node
can have any number of child nodes. In a tree, all the nodes except root are child nodes.

5. Siblings
In a tree data structure, nodes which belong to same Parent are called as SIBLINGS. In simple words,
the nodes with the same parent are called Sibling nodes.

6. Leaf
In a tree data structure, the node which does not have a child is called as LEAF Node. In simple words,
a leaf is a node with no child.
In a tree data structure, the leaf nodes are also called as External Nodes. External node is also a node
with no child. In a tree, leaf node is also called as 'Terminal' node.
7. Internal Nodes
In a tree data structure, the node which has atleast one child is called as INTERNAL Node. In simple
words, an internal node is a node with atleast one child.
In a tree data structure, nodes other than leaf nodes are called as Internal Nodes. The root node is
also said to be Internal Node if the tree has more than one node. Internal nodes are also called as
'Non-Terminal' nodes.

8. Degree
In a tree data structure, the total number of children of a node is called as DEGREE of that Node. In
simple words, the Degree of a node is total number of children it has. The highest degree of a node
among all the nodes in a tree is called as 'Degree of Tree'

9. Level
In a tree data structure, the root node is said to be at Level 0 and the children of root node are at Level 1 and the
children of the nodes which are at Level 1 will be at Level 2 and so on... In simple words, in a tree each step
from top to bottom is called as a Level and the Level count starts with '0' and incremented by one at each level .

10. Height
In a tree data structure, the total number of edges from leaf node to a particular node in the longest
path is called as HEIGHT of that Node. In a tree, height of the root node is said to be height of the tree.
In a tree, height of all leaf nodes is '0'.
11. Depth
In a tree data structure, the total number of egdes from root node to a particular node is called
as DEPTH of that Node. In a tree, the total number of edges from root node to a leaf node in the longest
path is said to be Depth of the tree. In simple words, the highest depth of any leaf node in a tree is said
to be depth of that tree. In a tree, depth of the root node is '0'.

12. Path
In a tree data structure, the sequence of Nodes and Edges from one node to another node is called
as PATH between that two Nodes. Length of a Path is total number of nodes in that path. In below
example the path A - B - E - J has length 4.

13. Sub Tree

In a tree data structure, each child from a node forms a subtree recursively. Every child node will form
a subtree on its parent node.

2. BINARY TREE

In a normal tree, every node can have any number of children. A binary tree is a special type of tree
data structure in which every node can have a maximum of 2 children. One is known as a left child and
the other is known as right child.
A tree in which every node can have a maximum of two children is called Binary Tree.
In a binary tree, every node can have either 0 children or 1 child or 2 children but not more than 2
children.
Example

There are different types of binary trees and they are...

1. Strictly Binary Tree

In a binary tree, every node can have a maximum of two children. But in strictly binary tree, every node
should have exactly two children or none. That means every internal node must have exactly two
children. A strictly Binary Tree can be defined as follows...

A binary tree in which every node has either two or zero number of children is called Strictly Binary Tree.

Strictly binary tree is also called as Full Binary Tree or Proper Binary Tree or 2-Tree

Strictly binary tree data structure is used to represent mathematical expressions.

2. Complete Binary Tree

In a binary tree, every node can have a maximum of two children. But in strictly binary tree, every node
should have exactly two children or none and in complete binary tree all the nodes must have exactly
two children and at every level of complete binary tree there must be 2 level number of nodes. For
example at level 2 there must be 22 = 4 nodes and at level 3 there must be 23 = 8 nodes.
A binary tree in which every internal node has exactly two children and all leaf nodes are at same level
is called Complete Binary Tree.
Complete binary tree is also called as Perfect Binary Tree

3. Extended Binary Tree

A binary tree can be converted into Full Binary tree by adding dummy nodes to existing nodes wherever
required.
The full binary tree obtained by adding dummy nodes to a binary tree is called as Extended Binary Tree.

In above figure, a normal binary tree is converted into full binary tree by adding dummy nodes.
3. BINARY TREE REPRESENTATIONS
A binary tree data structure is represented using two methods. Those methods are as follows...
 Array Representation
 Linked List Representation
Consider the following binary tree...

a. Array Representation/ Sequential representation of Binary Tree

In array representation of a binary tree, we use one-dimensional array (1-D Array) to represent a binary
tree.
Consider the above example of a binary tree and it is represented as follows...
Let us consider that we have a tree T. Let our tree T is a binary tree that is a complete binary tree. Then
there is an efficient way of representing T in the memory called the sequential representation or array
representation of T. This representation uses only a linear array TREE as follows:
The root N of T is stored in TREE [1].
If a node occupies TREE [k] then its left child is stored in TREE [2 * k] and its right child is stored
into TREE [2 * k + 1].
To represent a binary tree using array representation, we need one dimensional array with a maximum
size of 2n + 1 nodes where n is the number of nodes in a tree.
b. Linked List Representation of Binary Tree
We use a double linked list to represent a binary tree. In a double linked list, every node consists of
three fields. First field for storing left child address, second for storing actual data and third for storing
right child address.
In this linked list representation, a node has the following structure...

The above example of the binary tree represented using Linked list representation is shown as follows...

4. TREE OPERATIONS
The following operations can be done on a tree
 Inserting a new node.
 Deleting a specific node.
 Searching a specific node. (Searching can be done by traversal).

4. BINARY TREE TRAVERSALS

In any binary tree, displaying order of nodes depends on the traversal method.
Displaying (or) visiting order of nodes in a binary tree is called as Binary Tree Traversal.
There are three types of binary tree traversals.
 In - Order Traversal
 Pre - Order Traversal
 Post - Order Traversal
Consider the following binary tree...

a. In - Order Traversal ( leftChild - root - rightChild )

In In-Order traversal, the root node is visited between the left child and right child. In this traversal, the
left child node is visited first, then the root node is visited and later we go for visiting the right child
node. This in-order traversal is applicable for every root node of all subtrees in the tree. This is
performed recursively for all nodes in the tree.
In the above example of a binary tree, first we try to visit left child of root node 'A', but A's left child 'B'
is a root node for left subtree. So we try to visit its (B's) left child 'D' and again D is a root for subtree
with nodes D, I and J. So we try to visit its left child 'I' and it is the leftmost child. So first we visit 'I' then
go for its root node 'D' and later we visit D's right child 'J'. With this we have completed the left part of
node B. Then visit 'B' and next B's right child 'F' is visited. With this we have completed left part of node
A. Then visit root node 'A'. With this we have completed left and root parts of node A. Then we go for
the right part of the node A. In right of A again there is a subtree with root C. So go for left child of C and
again it is a subtree with root G. But G does not have left part so we visit 'G' and then visit G's right child
K. With this we have completed the left part of node C. Then visit root node 'C' and next visit C's right
child 'H' which is the rightmost child in the tree. So we stop the process.
That means here we have visited in the order of I - D - J - B - F - A - G - K - C - H using In-Order Traversal.
In-Order Traversal for above example of binary tree is I - D - J - B - F - A - G - K - C – H

2. Pre - Order Traversal ( root - leftChild - rightChild )

In Pre-Order traversal, the root node is visited before the left child and right child nodes. In this
traversal, the root node is visited first, then its left child and later its right child. This pre-order traversal
is applicable for every root node of all subtrees in the tree.
In the above example of binary tree, first we visit root node 'A' then visit its left child 'B' which is a root
for D and F. So we visit B's left child 'D' and again D is a root for I and J. So we visit D's left child 'I' which
is the leftmost child. So next we go for visiting D's right child 'J'. With this we have completed root, left
and right parts of node D and root, left parts of node B. Next visit B's right child 'F'. With this we have
completed root and left parts of node A. So we go for A's right child 'C' which is a root node for G and H.
After visiting C, we go for its left child 'G' which is a root for node K. So next we visit left of G, but it does
not have left child so we go for G's right child 'K'. With this, we have completed node C's root and left
parts. Next visit C's right child 'H' which is the rightmost child in the tree. So we stop the process.

That means here we have visited in the order of A-B-D-I-J-F-C-G-K-H using Pre-Order Traversal.
Pre-Order Traversal for above example binary tree is A - B - D - I - J - F - C - G - K – H

3. Post - Order Traversal ( leftChild - rightChild - root )

In Post-Order traversal, the root node is visited after left child and right child. In this traversal, left child
node is visited first, then its right child and then its root node. This is recursively performed until the
right most node is visited.
Here we have visited in the order of I - J - D - F - B - K - G - H - C - A using Post-Order Traversal.
Post-Order Traversal for above example binary tree is I - J - D - F - B - K - G - H - C – A

5. BINARY SEARCH TREE

Binary Search Tree is a binary tree in which every node contains only smaller values in its left subtree
and only larger values in its right subtree.

In a binary search tree, all the nodes in the left subtree of any node contains smaller values and all the
nodes in the right subtree of any node contains larger values as shown in the following figure...

The above tree is a Binary Search Tree. In this tree, left subtree of every node contains nodes with
smaller values and right subtree of every node contains larger values.
Every binary search tree is a binary tree but every binary tree need not to be binary search tree.

6. OPERATIONS ON A BINARY SEARCH TREE

The following operations are performed on a binary search tree...
 Search
 Insertion
 Deletion
Search Operation in BST
In a binary search tree, the search operation is performed with O(log n) time complexity. The search
operation is performed as follows...
Step 1 - Read the search element from the user.
Step 2 - Compare the search element with the value of root node in the tree.
Step 3 - If both are matched, then display "Given node is found!!!" and terminate the function
Step 4 - If both are not matched, then check whether search element is smaller or larger than that node
value.
Step 5 - If search element is smaller, then continue the search process in left subtree.
Step 6- If search element is larger, then continue the search process in right subtree.
Step 7 - Repeat the same until we find the exact element or until the search element is compared with
the leaf node
Step 8 - If we reach to the node having the value equal to the search value then display "Element is
found" and terminate the function.
Step 9 - If we reach to the leaf node and if it is also not matched with the search element, then display
"Element is not found" and terminate the function.
Insertion Operation in BST
In a binary search tree, the insertion operation is performed with O(log n) time complexity. In binary
search tree, new node is always inserted as a leaf node. The insertion operation is performed as
follows...
Step 1 - Create a newNode with given value and set its left and right to NULL.
Step 2 - Check whether tree is Empty.
Step 3 - If the tree is Empty, then set root to newNode.
Step 4 - If the tree is Not Empty, then check whether the value of newNode is smaller or larger than the
node (here it is root node).
Step 5 - If newNode is smaller than or equal to the node then move to its left child. If newNode
is larger than the node then move to its right child.
Step 6- Repeat the above steps until we reach to the leaf node (i.e., reaches to NULL).
Step 7 - After reaching the leaf node, insert the newNode as left child if the newNode is smaller or
equal to that leaf node or else insert it as right child.
Deletion Operation in BST
In a binary search tree, the deletion operation is performed with O(log n) time complexity. Deleting a
node from Binary search tree includes following three cases...
Case 1: Deleting a Leaf node (A node with no children)

Case 2: Deleting a node with one child

Case 3: Deleting a node with two children

Case 1: Deleting a leaf node

We use the following steps to delete a leaf node from BST...
Step 1 – Find the node to be deleted using search operation
Step 2 - Delete the node using free function (If it is a leaf) and terminate the function.
Case 2: Deleting a node with one child
We use the following steps to delete a node with one child from BST...
Step 1 – Find the node to be deleted using search operation
Step 2 - If it has only one child then create a link between its parent node and child node.
Step 3 -Delete the node using free function and terminate the function.
Case 3:Deleting a node with two children
We use the following steps to delete a node with two children from BST...
Step 1 –Find the node to be deleted using search operation
Step 2 - If it has two children, then find the largest node in its left subtree (OR) the smallest node in
its right subtree.
Step 3 - Swap both deleting node and node which is found in the above step.
Step 4 - Then check whether deleting node came to case 1 or case 2 or else goto step 2
Step 5 - If it comes to case 1, then delete using case 1 logic.
Step 6- If it comes to case 2, then delete using case 2 logic.
Step 7 - Repeat the same process until the node is deleted from the tree.
Example
Construct a Binary Search Tree by inserting the following sequence of numbers...
10,12,5,4,20,8,7,15 and 13
Above elements are inserted into a Binary Search Tree as follows...
Program of BST
#include <stdio.h>
#include<stdlib.h>

struct Node
{
int data;
struct Node *left;
struct Node *right;
};
struct Node *root=NULL;
struct Node* search(int data);
void insert(int);
struct Node* minValueNode(struct Node*);
struct Node* deleteNode(struct Node*, int);
void inOrder(struct Node* );
void preOrder(struct Node* );
void postOrder(struct Node*);

void main()
{
int choice, value;
printf("\n----- Binary Tree -----\n");
while(1){
printf("\n***** MENU *****\n");
printf("1. Insert\n2.search\n 3.inOrder\n4.preOrder\n 5.postOrder\n6.Delete\n 7.Exit");
printf("\nEnter your choice: ");
scanf("%d",&choice);
switch(choice)
{
case 1: printf("\nEnter the value to be insert: ");
scanf("%d", &value);
insert(value);
break;

case 2: printf("\nEnter the value to be search: ");

scanf("%d", &value);
struct Node * x=search(value);
if(x!=NULL)
printf("Found");
else
printf("Not found");
break;
case 3: inOrder(root);
break;
 case 4: preOrder(root);
break;

case 5: postOrder(root);
break;

case 6: printf("\nEnter the value to be delete: ");

scanf("%d",&value);
deleteNode(root,value);
break;

case 7: exit(0);
default: printf("\nPlease select correct operations!!!\n");
}
}
}

struct Node* minValueNode(struct Node *root)

{
struct Node *current = root;
if(current->left!=NULL)
current=current->left;
return current;
}

struct Node* search(int data)

{
struct Node *current = root;
printf("Visiting elements: ");
while(current->data != data)
{
if(current != NULL)
{
printf("%d ",current->data);
//go to left tree
if(current->data > data)
{
current = current->left;
}//else go to right tree
else
{
current = current->right;
}

//not found
if(current == NULL)
 {
return NULL;
}
}
}
return current;
}

void insert(int data)

{
struct Node *tempNode = (struct Node*) malloc(sizeof(struct Node));
struct Node *current;
struct Node *parent;

tempNode->data = data;
tempNode->left = NULL;
tempNode->right = NULL;

//if tree is empty

if(root == NULL)
{
root = tempNode;
}
else
{
current = root;
parent = NULL;
while(1)
{
parent = current;
//go to left of the tree
if(data < parent->data)
{
current = current->left;
//insert to the left
if(current == NULL)
{
parent->left = tempNode;
return;
}
}//go to right of the tree
else
{
current = current->right;
//insert to the right
if(current == NULL)
 {
parent->right = tempNode;
return;
}
}
}
}
}

struct Node* deleteNode(struct Node* root, int data)

{

if (root == NULL)
// root=tempNode;
printf("NULL");

if (data < root->data)

root->left = deleteNode(root->left, data);
else if (data > root->data)
root->right = deleteNode(root->right, data);
else
{
if (root->left == NULL)
{
struct Node *temp = root->right;
free(root);
return temp;
}
else if (root->right == NULL)
{
struct Node *temp = root->left;
free(root);
return temp;
}
else
{
struct Node* temp = minValueNode(root->right);
root->data = temp->data;
root->right = deleteNode(root->right, temp->data);
}

}
return root;

}
void inOrder(struct Node* root)
{
// Base case
if (root == NULL)
{
return;
}
// Travel the left sub-tree first.
inOrder(root->left);
// Print the current Node value
printf("%d ", root->data);
// Travel the right sub-tree next.
inOrder(root->right);
}

void preOrder(struct Node* root)

{
if (root == NULL)
{
return;
}
// Print the current Node value
printf("%d ", root->data);
// Travel the left sub-tree first.
preOrder(root->left);
// Travel the right sub-tree next.
preOrder(root->right);
}

void postOrder(struct Node* root)

{
if (root == NULL)
{
return;
}
// Travel the left sub-tree first.
postOrder(root->left);
// Travel the right sub-tree next.
postOrder(root->right);
// Print the current Node value
printf("%d ", root->data);
}
7. GRAPH

Graph is a non-linear data structure. It contains a set of points known as nodes (or vertices) and a set
of links known as edges (or Arcs). Here edges are used to connect the vertices. A graph is defined as
follows...

Graph is a collection of vertices and arcs in which vertices are connected with arcs or
Graph is a collection of nodes and edges in which nodes are connected with edges.

Generally, a graph G is represented as G = ( V , E ), where V is set of vertices and E is set of edges.

Example
The following is a graph with 5 vertices and 6 edges. This graph G can be defined as G = ( V , E )
Where V = {A,B,C,D,E} and E = {(A,B),(A,C)(A,D),(B,D),(C,D),(B,E),(E,D)}.

Graph Terminology
We use the following terms in graph data structure...

Vertex
Individual data element of a graph is called as Vertex. Vertex is also known as node. In above example
graph, A, B, C, D & E are known as vertices.

Edge
An edge is a connecting link between two vertices. Edge is also known as Arc. An edge is represented
as (startingVertex, endingVertex). For example, in above graph the link between vertices A and B is
represented as (A,B). In above example graph, there are 7 edges (i.e., (A,B), (A,C), (A,D), (B,D), (B,E),
(C,D),(D,E)).
Edges are three types.
1. Undirected Edge - An undirected egde is a bidirectional edge. If there is undirected edge
between vertices A and B then edge (A , B) is equal to edge (B , A).
2. Directed Edge - A directed egde is a unidirectional edge. If there is directed edge between
vertices A and B then edge (A , B) is not equal to edge (B , A).
3. Weighted Edge - A weighted egde is a edge with value (cost) on it.

Undirected Graph
A graph with only undirected edges is said to be undirected graph.

Directed Graph
A graph with only directed edges is said to be directed graph.

Mixed Graph
A graph with both undirected and directed edges is said to be mixed graph.

End vertices or Endpoints

The two vertices joined by edge are called end vertices (or endpoints) of that edge.
Origin
If a edge is directed, its first endpoint is said to be the origin of it.

Destination
If a edge is directed, its first endpoint is said to be the origin of it and the other endpoint is said to be
the destination of that edge.

Adjacent
If there is an edge between vertices A and B then both A and B are said to be adjacent. In other words,
vertices A and B are said to be adjacent if there is an edge between them.

Incident
Edge is said to be incident on a vertex if the vertex is one of the endpoints of that edge.

Outgoing Edge
A directed edge is said to be outgoing edge on its origin vertex.

Incoming Edge
A directed edge is said to be incoming edge on its destination vertex.

Degree
Total number of edges connected to a vertex is said to be degree of that vertex.

Indegree
Total number of incoming edges connected to a vertex is said to be indegree of that vertex.

Outdegree
Total number of outgoing edges connected to a vertex is said to be outdegree of that vertex.

Parallel edges or Multiple edges

If there are two undirected edges with same end vertices and two directed edges with same origin and
destination, such edges are called parallel edges or multiple edges.

Self-loop
Edge (undirected or directed) is a self-loop if its two endpoints coincide with each other.

Simple Graph
A graph is said to be simple if there are no parallel and self-loop edges.

Path
A path is a sequence of alternate vertices and edges that starts at a vertex and ends at other vertex such
that each edge is incident to its predecessor and successor vertex.

8. GRAPH REPRESENTATIONS

Graph data structure is represented using following representations...

1. Adjacency Matrix
2. Incidence Matrix
3. Adjacency List
Adjacency Matrix

In this representation, the graph is represented using a matrix of size total number of vertices by a total
number of vertices. That means a graph with 4 vertices is represented using a matrix of size 4X4. In this
matrix, both rows and columns represent vertices. This matrix is filled with either 1 or 0. Here, 1
represents that there is an edge from row vertex to column vertex and 0 represents that there is no
edge from row vertex to column vertex.
For example, consider the following undirected graph representation...

Directed graph representation...

Incidence Matrix
In this representation, the graph is represented using a matrix of size total number of vertices by a total
number of edges. That means graph with 4 vertices and 6 edges is represented using a matrix of size
4X6. In this matrix, rows represent vertices and columns represents edges. This matrix is filled with 0
or 1 or -1. Here, 0 represents that the row edge is not connected to column vertex, 1 represents that the
row edge is connected as the outgoing edge to column vertex and -1 represents that the row edge is
connected as the incoming edge to column vertex.

For example, consider the following directed graph representation...

Adjacency List

In this representation, every vertex of a graph contains list of its adjacent vertices.
For example, consider the following directed graph representation implemented using linked list.

This representation can also be implemented using an array as follows

9. GRAPH TRAVERSAL
Graph traversal is a technique used for a searching vertex in a graph. The graph traversal is also used
to decide the order of vertices is visited in the search process. A graph traversal finds the edges to be
used in the search process without creating loops. That means using graph traversal we visit all the
vertices of the graph without getting into looping path.

There are two graph traversal techniques and they are as follows...
1. DFS (Depth First Search)
2. BFS (Breadth First Search)

DFS (Depth First Search)

DFS traversal of a graph produces a spanning tree as final result. Spanning Tree is a graph without
loops. We use Stack data structure with maximum size of total number of vertices in the graph to
implement DFS traversal.

We use the following steps to implement DFS traversal...

 Step 1 - Define a Stack of size total number of vertices in the graph.
 Step 2 - Select any vertex as starting point for traversal. Visit that vertex and push it on to the
Stack.
 Step 3 - Visit any one of the non-visited adjacent vertices of a vertex which is at the top of stack
and push it on to the stack.
 Step 4 - Repeat step 3 until there is no new vertex to be visited from the vertex which is at the
top of the stack.
 Step 5 - When there is no new vertex to visit then use back tracking and pop one vertex from
the stack.
 Step 6 - Repeat steps 3, 4 and 5 until stack becomes Empty.
  Step 7 - When stack becomes Empty, then produce final spanning tree by removing unused
edges from the graph
Back tracking is coming back to the vertex from which we reached the current vertex.

Example
BFS (Breadth First Search)

BFS traversal of a graph produces a spanning tree as final result. Spanning Tree is a graph without
loops. We use Queue data structure with maximum size of total number of vertices in the graph to
implement BFS traversal.

We use the following steps to implement BFS traversal...

 Step 1 - Define a Queue of size total number of vertices in the graph.
 Step 2 - Select any vertex as starting point for traversal. Visit that vertex and insert it into the
Queue.
 Step 3 - Visit all the non-visited adjacent vertices of the vertex which is at front of the Queue
and insert them into the Queue.
 Step 4 - When there is no new vertex to be visited from the vertex which is at front of the Queue
then delete that vertex.
 Step 5 - Repeat steps 3 and 4 until queue becomes empty.
 Step 6 - When queue becomes empty, then produce final spanning tree by removing unused
edges from the graph
BFS Versus DFS
S.NO BFS DFS
1. BFS stands for Breadth First Search. DFS stands for Depth First Search.
BFS(Breadth First Search) uses Queue data DFS(Depth First Search) uses Stack data
2. structure for finding the shortest path. structure.
BFS can be used to find single source shortest
path in an unweighted graph, because in BFS, we
reach a vertex with minimum number of edges In DFS, we might traverse through more edges to
3. from a source vertex. reach a destination vertex from a source.
BFS is more suitable for searching vertices which DFS is more suitable when there are solutions
4. are closer to the given source. away from source.
DFS is more suitable for game or puzzle
BFS considers all neighbors first and therefore problems. We make a decision, then explore all
not suitable for decision making trees used in paths through this decision. And if this decision
5. games or puzzles. leads to win situation, we stop.
The Time complexity of BFS is O(V + E) when The Time complexity of DFS is also O(V + E)
6. Adjacency List is used and O(V^2) when when Adjacency List is used and O(V^2) when
 Adjacency Matrix is used, where V stands for Adjacency Matrix is used, where V stands for
vertices and E stands for edges. vertices and E stands for edges.
7. Here, siblings are visited before the children Here, children are visited before the siblings

10. APPLICATIONS OF GRAPHS

Since they are powerful abstractions, graphs can be very important in modeling data. In fact, many
problems can be reduced to known graph problems. Some of the many applications of graphs.
1. Social network graphs: to tweet or not to tweet. Graphs that represent who knows whom, who
communicates with whom, who influences whom or other relationships in social structures.
An example is the twitter graph of who follows whom. These can be used to determine how
information flows, how topics become hot, how communities develop, or even who might be a
good match for who, or is that whom.

2. Transportation networks. In road networks vertices are intersections and edges are the road
segments between them, and for public transportation networks vertices are stops and edges are
the links between them. Such networks are used by many map programs such as Google maps,
Bing maps and now Apple IOS 6 maps to find the best routes between locations. They are also
used for studying traffic patterns, traffic light timings, and many aspects of transportation.
3. Utility graphs. The power grid, the Internet, and the water network are all examples of graphs
where vertices represent connection points, and edges the wires or pipes between them.
Analyzing properties of these graphs is very important in understanding the reliability of such
utilities under failure or attack, or in minimizing the costs to build infrastructure that matches
required demands.
4. Document link graphs. The best known example is the link graph of the web, where each web
page is a vertex, and each hyperlink a directed edge. Link graphs are used, for example, to analyze
relevance of web pages, the best sources of information, and good link sites.
5. Protein-protein interactions graphs. Vertices represent proteins and edges represent
interactions between them that carry out some biological function in the cell. These graphs can be
used, for example, to study molecular pathways—chains of molecular interactions in a cellular
process. Humans have over 120K proteins with millions of interactions among them.

6. Network packet traffic graphs. Vertices are IP (Internet protocol) addresses and edges are the
packets that flow between them. Such graphs are used for analyzing network security, studying
the spread of worms, and tracking criminal or non-criminal activity.
7. Scene graphs. In graphics and computer games scene graphs represent the logical or spacial
relationships between objects in a scene. Such graphs are very important in the computer games
industry.
8. Finite element meshes. In engineering many simulations of physical systems, such as the flow of
air over a car or airplane wing, the spread of earthquakes through the ground, or the structural
vibrations of a building, involve partitioning space into discrete elements. The elements along
with the connections between adjacent elements forms a graph that is called a finite element
mesh.
9. Robot planning. Vertices represent states the robot can be in and the edges the possible
transitions between the states. This requires approximating continuous motion as a sequence of
discrete steps. Such graph plans are used, for example, in planning paths for autonomous vehicles.
10. Neural networks. Vertices represent neurons and edges the synapses between them. Neural
networks are used to understand how our brain works and how connections change when we
learn. The human brain has about 1011 neurons and close to 1015 synapses.