The survey of graphs and algorithms is really important in computing machine scientific discipline. In the last few decennaries the usage of algorithms has solved many hard jobs in a really easy mode. Therefore in many universities and colleges a batch of accent is made on the survey of graphs and algorithms. A batch of research work is being done on this stage of computing machine scientific discipline field.

In the last four decennaries graph and geometric jobs have been studied by computing machine scientific discipline research workers utilizing the model of analysis of algorithms. Graph theory is the survey of the belongingss of graphs. Graph algorithms are one of the oldest categories of algorithms and they have been studied for about 300 old ages. Graphs provide indispensable theoretical accounts for many applications countries of computing machine scientific discipline and mathematics. There have been a figure of exciting recent developments in graph theory that are of import for interior decorators of algorithms to cognize approximately. Correspondingly the algorithmic point of view of computing machine scientific discipline has stimulated much research in graph theory. Graph theory and graph algorithms are inseparably intertwined topics. On the other manus the chief drift for the development of geometric algorithms came from the advancement in computing machine artworks, computing machine aided design and fabrication. In many application domains- computing machine artworks, geographic information systems, robotics and others, geometric algorithms play a important function [ 10 ] .

The Importance Of Graphs And Algorithms... TOPICS SPECIFICALLY FOR YOU

Graphs are a cardinal portion in research of complex systems and the usage of graph theoretic algorithms to pull out utile information from a job is a primary method of analysis for complex systems. A graph representation is used to supply a peculiar position on a job and a graph theoretic representation is utile for a peculiar job depends on whether the interesting characteristics of the job are likely to be highlighted by the sort of thought that a graph-based representation may supply. Generally graph the representations of a job revolve around foregrounding facets of a job that are either structural ( like the connectivity of constituents or procedures in the job ) or that depend on structural belongingss ( like construction dependant kineticss ) . The most common types of job in which structural facets play a critical function are jobs affecting multiple interacting agents. In complex systems subjects [ 2 ] .

So my undertaking is planing and implementing comprehensiveness foremost hunt on inexplicit graph for web excavation application.

My web application will be educational application for BITS-Pilani, Dubai holding 3 countries of involvement:

Particular Interest Group ( SIG )

Conference Alerts ( CA )

Higher Education ( HE )


The present work is intended to run into the following aims

To study the maps of Web Structure Mining Algorithms

To plan BFS inexplicit graph and algorithm for web excavation application

To place the Academic Search related maps where Web Structure Mining and Breadth First Search can be applied efficaciously


The net construction of the World Wide Web ( World Wide Web ) is invariably altering due to the add-on and remotion of web pages ( i.e. nodes ) or the addition or lessening in the no. of incoming and surpassing links ( i.e. borders ) to or from a page. It is really indispensable to keep the web construction in an organized manner and implementing utilizing BFS under Graph Structure Analysis.

Problem Description





Phases 1: Literature Survey. ( mentioning to diaries, catalogues, web sites etc )

Phases 2: Data Collection, Learning of Necessary Software/Hardware Tools and Installation & A ; Configuration Steps, Problem Analysis.

Phase 3: Problem Analysis cont. & A ; Design and Generation of Real Data, Coding.

Phase 4: Cryptography Contd. & A ; Individual Modules Testing & A ; Debuging

Phase 5: Integration Testing & A ; Debugging, Implementation.

Phase 6 & A ; 7: Concluding Touches / Fine Tuning, Summary of Findings, Recommendations, Conclusion and Report authorship.

Phase 1


In-depth Research on Graph Structure Mining and comprehensiveness foremost hunt

Phase 2

Sept16th – Oct1st

Acquisition and installing of the intended platform.

Phase 3

Oct 2nd- Oct15th

Learning the coding linguistic communication of platform

Phase 4

Oct 16th – Nov1st

Submission of the mid-semester study, Design and coevals of existent informations, coding

Phase 5



Phase 6

Nov 16th- Dec 1st

Execution and Testing.

Phase 7

Dec1st- Dec 15th

Fine tuning of the study, decision and entry of the concluding study.

1.5.1 Plan of Work

Fig 1.5.1 Plan of Work


In this chapter I discussed about graphs and its usage in web excavation applications. My project trades with design and execution of comprehensiveness first hunt on inexplicit graph and Java cryptography for web excavation application i.e. an educational web site. I besides discussed about the job description, methodological analysis and program of work.

Chapter 2


2.1 Graphs, BFS and Web Mining

In depicting the running clip of a graph algorithm on a given graph G = ( V, E ) we normally measure the size of the input in footings of the figure of vertices |V| and the figure of borders |E| of the graph. We adopt a common notational convention for these parametric quantities. Inside asymptotic notation ( such as O notation or I? notation ) and the symbol V denotes |V| and the symbol E denotes |E|.e.g. “ the algorithm runs in clip O ( V E ) , ” means that the algorithm runs in clip O ( |V||E| ) [ 3 ] .

A graph is a manner of stand foring connexions between points or topographic points. Mathematically a graph is a aggregation of nodes and borders. Nodes are locations that are connected together by the borders of the graph. For illustration, if we had two little towns connected by a bipartisan route, we could stand for this as a graph with two nodes, each node stand foring a town, and one border, the route, linking the two towns together. In add-on to the adrift graph in which the border is a bipartisan connexion there are directed graph in which edges connect merely one manner.

Fig 2.1.1 a sample graph with nodes A, B, C, D, E, F

In Fig 2.1.1 A, B, C, D, E, F are called nodes and the linking lines between these nodes are called borders. The borders can be directed borders shown by pointers they can besides be weighted borders in which some Numberss are assigned to them. Therefore a graph can be a directed or adrift and weighted/un-weighted graph. So we will discourse about adrift and un-weighted graphs.

There are two standard ways to stand for a graph G = ( V, E ) as a aggregation of contiguity lists or as an contiguity matrix [ 4 ] . Either manner is applicable to both directed and adrift graphs. The adjacency-list representation is normally preferred because it provides a compact manner to stand for thin graphs-those for which |E| is much less than |V|2. Most of the graph algorithms presented in this book assumes that an input graph is represented in contiguity list signifier. An contiguity matrix representation may be preferred when the graph is heavy |E| is close to |V|2 or when we need to be able to state rapidly if there is an border linking two given vertices [ 4 ] .

The contiguity list representation of a graph G = ( V, E ) consists of an array Adj of |V| lists, one for each vertex in V. For each u A­ the contiguity list Adj [ u ] contains all the vertices v such that there is an border ( u, V ) A­ E. That is Adj [ u ] consists of all the vertices next to u in G. ( Alternatively it may incorporate arrows to these vertices ) . The vertices in each contiguity list are typically stored in an arbitrary order [ 3 ] . Figure 2.1.2 ( B ) is an contiguity list representation of the adrift graph in Figure 2.1.2 ( a ) . Similarly Figure 2.1.3 ( B ) is an adjacency-list representation of the directed graph in Figure 2.1.3 ( a ) .

Fig 2.1.2 ( a ) Fig 2.1.2 ( B ) Fig 2.1.2 ( degree Celsius )

Figure 2.1.2: Two representations of an adrift graph. ( a ) An adrift graph G holding five vertices and seven borders. ( B ) An adjacency-list representation of G. ( degree Celsius ) The contiguity matrix representation of G.

Fig 2.1.3 ( a ) Fig 2.1.3 ( B ) Fig 2.1.3 ( degree Celsius )

Figure 2.1.3: Two representations of a directed graph. ( a ) Angstrom directed graph G holding six vertices and eight borders. ( B ) An contiguity list representation of G. ( degree Celsius ) The contiguity matrix representation of G.

If G is a directed graph the amount of the lengths of all the contiguity lists is |E| since an border of the signifier ( u, V ) is represented by holding 5 appear in Adj [ u ] . If G is an adrift graph the amount of the lengths of all the contiguity lists is 2 |E| . If ( u, V ) is an adrift border, so u appears in V ‘s contiguity list and frailty versa. For both directed and adrift graphs the contiguity list representation has the desirable belongings that the sum of memory it requires is I? ( V + E ) [ 5 ] .

Adjacency lists can readily be adapted to stand for leaden graphs i.e. graphs for which each border has an associated weight represented by a weight map tungsten: Tocopherol a†’ R. For illustration, allow G = ( V, E ) be a leaden graph with weight map w. The weight tungsten ( u, V ) of the border ( u, V ) A­ E is merely stored with vertex V in U ‘s contiguity list. The contiguity list representation is rather robust in that it can be modified to back up many other graphs. A disadvantage of the contiguity list representation is that there is no quicker manner to find if a given border ( u, V ) is present in the graph than to seek for V in the contiguity list Adj [ u ] . This disadvantage can be overcome by an adjacency-matrix representation of the graph at the cost of utilizing more memory [ 3 ] .

For the contiguity matrix representation of a graph G = ( V, E ) , we assume that the vertices are numbered 1, 2.. |V| . Then the contiguity matrix representation of a graph G consists of a |V| A- |V| matrix A = ( aij ) such that

aij= 1 if ( I, J ) Tocopherol

aij= 0 otherwise

Figures 2.1.2 ( degree Celsius ) and 2.1.3 ( degree Celsius ) are the contiguity matrices of the adrift and directed graphs in Figures 2.1.2 ( a ) and 2.1.3 ( a ) severally. The contiguity matrix of a graph requires I? ( V2 ) memory ( running clip ) , independent of the figure of borders in the graph.

Like the contiguity list representation of a graph the contiguity matrix representation can be used for leaden graphs. For illustration if G = ( V, E ) is a leaden graph with border weight map tungsten, the weight tungsten ( u, V ) of the border E ( u, V ) is merely stored as the entry in row U and column V of the contiguity matrix. If an border does non be a NIL value can be stored as its matching matrix entry. Though for many jobs it is convenient to utilize a value such as 0 or a?z [ 6 ] .

2.1.1 Breadth First Search

In a comprehensiveness foremost traversal we visit the starting node and so on the first base on balls visit all of the nodes straight connected to it. In the 2nd base on balls we visit nodes that are two borders “ off ” from the get downing node. With each new base on balls we visit nodes that are one more border off. Because there can be rhythms in the graph it is possible for a node to be on two waies of different lengths from the get downing node. When we visit that node for the first clip along the shortest way from the get downing node that is non considered once more. Therefore, either we need to maintain a list of the nodes we have visited or we will necessitate to utilize a variable in the node to tag it as visited node to forestall multiple visits [ 6 ] .

Breadth first hunt is one of the simplest algorithms for seeking a graph and the architecture for many of import graph algorithms. Prim ‘s minimal spanning tree algorithm and Dijkstra ‘s individual beginning shortest waies algorithm uses the construct of comprehensiveness first hunt. Give a graph G = ( V, E ) and a distinguished beginning vertex “ s ” comprehensiveness foremost search consistently explores the borders of G to ‘discover ‘ every vertex that is approachable from s. It computes the distance ( smallest figure of borders ) from s to each approachable vertex. It besides produces a “ comprehensiveness first tree ” with root ‘s ‘ that contains all approachable vertices [ 5 ] . For any vertex V reachable from s the way in the comprehensiveness foremost tree from s to v corresponds to the “ shortest way ” from s to v in G i.e. a way incorporating the smallest figure of borders. The algorithm works on both directed and adrift graphs.

Breadth first hunt is so named because it expands the frontier between discovered and undiscovered vertices uniformly across the comprehensiveness of the frontier of an algorithm. The algorithm discovers all vertices at distance “ K ” from “ s ” before detecting any vertices at distance K + 1. To maintain path of advancement comprehensiveness foremost search colourss each vertex white, grey, or black. All vertices start out white and later may go grey and so black. A vertex is discovered the first clip it is encountered during the hunt, at which clip it becomes colored. Therefore Gray and black vertices have been discovered, but breadth first hunt distinguishes between them to guarantee that the hunt returns in a comprehensiveness first mode. If ( u, V ) A­ E and vertex U is black, so vertex V is either grey or black i.e. all vertices adjacent to black vertices have been discovered. Grey vertices may hold some next white vertices which represent the frontier between discovered and undiscovered vertices [ 7 ] .

Breadth first hunt constructs a comprehensiveness foremost tree ab initio incorporating merely the root, which is the beginning vertex “ s ” . Whenever a white vertex “ V ” is discovered during scanning the contiguity list of the ascertained vertex “ u ” , the vertex V and the border ( u, V ) are added to the tree. The vertex U is the predecessor or parent of V in the breadth-first tree. Since a vertex is discovered at most one time, it has at most one parent. Ancestor and descendent relationships in the breadth-first tree are defined comparative to the root s i.e. if u is on a way in the tree from the root s to vertex V so u is an ascendant of V and V is a descendent of u [ 3 ] .

Using the contiguity matrix representation and presuming that the figure of vertices is N, comprehensiveness foremost hunt can be written like this


Void BFS ( int startingVetex ) {

IntQueue waiting line ; // Start with an empty waiting line of whole numbers.

for ( int I = 0 ; I & lt ; N ; i++ ) {

visited [ I ] = false ; // Mark all vertices unvisited.


visited [ get downing Vertex ] = true ;

queue.enqueue ( get downing Vertex ) ;

while ( ! queue.isEmpty ( ) ) {

int V = queue.dequeue ( ) ; // Get following vertex from waiting line.

procedure ( V ) ; // Process the vertex.

for ( int U = 0 ; u & lt ; N ; u++ ) {

if ( border Exists [ V ] [ u ] & A ; & A ; visited [ u ] == faithlessly ) {

// we have an border from V to an unvisited vertex ;

// grade it as visited and add it to the waiting line.

visited [ u ] = true ;

queue.enqueue ( u ) ;





In this algorithm each vertex that is encountered is marked as visited and placed on the waiting line. It is processed when it comes off the waiting line. If it is encountered a 2nd clip ( by an alternate way from the get downing vertex ) , it has already been marked as visited and so is non placed on the waiting line once more. Since no vertex is placed on the waiting line more than one time the piece cringle is executed max N times. So it is easy to see that the tally clip for this algorithm is O ( N2 ) , where N is the figure of vertices. In the border list representation the tally clip would be O ( M ) where M is the figure of borders in the graph.

In this algorithm the first vertex on the waiting line is the get downing vertex. When the starting vertex is removed from the waiting line all vertices that are connected to the get downing vertex by a individual border are located and are placed on the waiting line i.e. the vertices at distance one from the get downing vertex. As these vertices are removed from the waiting line, the vertices to which they are straight connected are added to the waiting line. These are the vertices at distance two from the get downing vertex and they follow all the distance one vertices on the waiting line. As the distance two vertices are processed the distance three vertices are encountered and are added to line up following all the distance two vertices and so on. Vertexs are added to the waiting line in order of their distance from the get downing vertex i.e. they are added in comprehensiveness first order [ 5 ] .

2.1.2 Analysis of BFS

Before discoursing the assorted belongingss of comprehensiveness first hunt, analysis of its running clip on an input graph G = ( V, E ) is done. The operations of enqueuing and dequeuing take O ( 1 ) clip, so the entire clip taken by queue operations is O ( V ) . Because the contiguity list of each vertex is scanned merely when the vertex is dequeued, each contiguity list is scanned max one clip. Since the amount of the lengths of all the contiguity lists is I? ( E ) , the entire clip spent in scanning contiguity lists is O ( E ) . The running clip for low-level formatting is O ( V ) and therefore the entire running clip of BFS is O ( V + E ) . Thus comprehensiveness foremost hunt runs in clip linear in the size of the contiguity list representation of graph G [ 7 ] .

2.1.3 Web Mining

Web excavation is the integrating of information gathered by traditional informations excavation methodological analysiss and techniques with information gathered over the World Wide Web ( World Wide Web ) . Web excavation is used to understand client behavior, measure the effectivity of a peculiar Web site and aid quantify the success of a selling run [ 8 ] .

Web excavation allows us to look for forms in informations through content excavation, construction excavation and use excavation. Content excavation is used to analyze informations collected by hunt engines and Web spiders. Structure excavation is used to analyze informations related to the construction of a peculiar Web site. Use excavation is used to analyze informations related to a peculiar user ‘s browser every bit good as informations gathered by signifiers the user may hold submitted during Web minutess [ 7 ] .

The information gathered through Web excavation is evaluated ( sometimes utilizing package charting applications ) by utilizing traditional informations mining parametric quantities such as bunch and categorization, association and scrutiny of consecutive forms [ 8 ] .

Chapter 3


3.1 Introduction

Throughout the undertaking I will be planing and implementing the educational application i.e. BITS-Pilani, Dubai website through PHP package and will be executing Breadth First Search for this site utilizing JAVA cryptography. I will besides be utilizing graphs for BFS.

3.2 Hardware Software Requirements

The undertaking work is planned to be carried out utilizing a system with the undermentioned constellation


Processor- Intel Core 2 Duo T5450 @ 1.67 GHz

Motherboard – Gigabyte P43-ES3G – Intel P43 Chipset +ICH10

RAM – Lenovo 2.00 GB RAM ( DDR2 1066 MHz

Hard Disk – Seagate 160 GB SATA

Optical Drive – Lenovo SATA 32x DVD-writer

Network card – Onboard

Sound Card – Onboard high-definition Audio

Artworks card – NVIDIA GeForce 8400 GT-256 MB


Operating systems – Windows Vista SP 2

Office suite – Microsoft Office 2010

JCreator 4.50 Pro



Graph Traversal Applet

Chapter 4


4.1 User Interface

4.1.1 JCreator

JCreator is a Java IDE created by Xinox Software. Its interface is similar to that of Microsoft ‘s Ocular Studio.

Features of JCreator are:

Custom coloring material strategies

Wraping around of our bing undertakings

Different JDK profiles can be used

Quick codification composing via undertaking templets

Easy undertaking sing with the category browser

Debuging with an easy interface. No bid line prompts necessary

AutomaticA Class pathA constellation

UI customization ( similar to Microsoft Visual Studio )

The run-time environment can run our application as anA applet in a J-Unit environment or in a command-line window

JCreator ‘s IDE does non necessitate a Java Runtime Environment to put to death which may do it faster than Java-based IDE ‘s.

Get downing a new plan

If we write a plan from abrasion so we can get down our work in JCreator. It is ever best to put each of our plans into a separate directory.A JCreator will make the directory for us.

SelectA Project- & gt ; New Project ( fig 4.1.1 a ) A .In the duologue give a name to the undertaking. The best pick for the name is the name of the directory that contains the files. For illustration, if our prep files are contained inside a directoryA hw1, name the projectA hw1.

Edit theA LocationA field so that it contains the full directory way of your plan files, such asA degree Celsiuss: homeworkhw1.

Fig 4.1.1 a Making a new undertaking

Click on theA OkA button. Our undertaking is opened. JCreator adds a Java file with the same name as the undertaking such asA If we do non necessitate that file, chink on it in the undertaking window and selectA Edit- & gt ; DeleteA from the bill of fare. To add a new category to the undertaking, chooseA Project- & gt ; New classA from the bill of fare.

Fill in the name of the category ( such asA Hello ) . A new file ( such asA ) is added to the undertaking. Now we can type our plan into the beginning window. Note the codification completion characteristic that suggests how to finish partly typed looks.

Roll uping a plan

We will normally hold multiple undertakings open in JCreator. When we are ready to roll up and run a plan, make certain that the undertaking on which we are working is the active undertaking. SelectA Project- & gt ; Active Project and so choose the current undertaking from the hierarchical menu.

To roll up a plan, selectA Build- & gt ; Compile ProjectA or hit theA F7A key.A Compilation mistakes are displayed in a separate window ( fig 4.1.1 B ) .A

Fig 4.1.1 B Compliling the the undertaking

Runing a plan

When the plan compiles successfully, you can run it. SelectA Build- & gt ; Execute ProjectA or hit theA F5A key. The plan executes in a separate console window ( Fig 4.1.1 degree Celsius ) .

Fig 4.1.1 degree Celsius Runing the undertaking

4.1.2 The Graph Traversal Applet

The Graph Traversal Applet animates Breadth First Search ( BFS ) and Depth First Search ( DFS ) algorithms and shows how graphs are traversed in each algorithm.

The applet provides a simple user interface assisting users to command all the undertakings needed to run the life. For planing the user interface precedence is given to let users to command the life and the show at all times alternatively of the applet commanding the user actions and the rate of life [ 5 ] .

The user interface is shown below:

Figure 4.1.2: the user interface of the graph traverse applet

4.2 Architecture and Data

4.2.1 Java File Managing

File managing is an built-in portion for about all programming undertakings. Files provide the agencies by which a plan shops informations, entrees stored informations or portions informations. As a consequence there are really few applications that do non interact with a file in one signifier or another. Although no facet of file handling is peculiarly hard many categories, interfaces, and methods are involved. It is of import to understand that file I/O is a subset of Java ‘s overall I/O system. Furthermore Java ‘s I/O system is rather big. It supports two distinguishable I/O category hierarchies: one for bytes and one for characters. It contains categories that enable a byte array, character array or a twine to be used as beginning or mark of I/O operations. It besides provides the ability to put or obtain assorted properties associated with a file itself such as its read/write position, whether the file is a directory or if it is concealed. We even obtain a list of files within a directory.

Despite is size ; Java ‘s I/O system is surprisingly easy to utilize. One ground for this is its well thought-out design. By structuring the I/O system around a carefully crafted set of categories this really big API is made manageable. The I/O system ‘s consistence makes it easy to keep or accommodate codification and its rich functionality provides solutions to most file managing undertakings.

The nucleus of Java ‘s I/O system is packaged in It has been included with Java since version 1.0 and it contains the categories and interfaces that we will most frequently use when executing I/O operations including those that operate on files. Simply put when we need to read or compose files is the bundle that we will usually turn to

Another bundle that includes file managing categories is The categories in can make a tight file or uncompress a file. These categories build on the functionality provided by the I/O categories defined in Therefore, they are integrated in to Java ‘s overall I/O scheme.

Filename managing

To compose anything to a file foremost of all we need a file name we want to utilize. The file name is a simple twine like this:

Stringing filename = “ test.txt ” ;

If we want to compose in a file which is located elsewhere we need to specify the complete file name and way in your filename variable:

Stringing filename = “ degree Celsius: filedemo est.txt ” ;

However if we define a way in our file name so we have to take care the way centrifuge. On Windowss system the ‘ ‘ is used and we need to backslash it so we need to compose ‘ ‘ , in Unix, Linux systems the centrifuge is a simple cut ‘/ ‘ .

To do our codification OS independent we can acquire the centrifuge character as follows:

Stringing centrifuge = File.separator ;

Open a file

To open a file for composing usage the FileWriter category and make an case from it. The file name is passed in the builder like this:

FileWriter author = new FileWriter ( filename ) ;

This codification opens the file in overwrite manner. If we want to add on to the file so we need to utilize another builder like this:

FileWriter author = new FileWriter ( fileName, true ) ;

Besides this the builder can throw an IOException so we put all of the codification inside a try-catch block.

Write to register

At this point we have a author object and we can direct existent content to the file. We can make this utilizing the write ( ) method, which has more variant but the most normally used requires a twine as input parametric quantity. Naming the write ( ) method does n’t intend that it instantly writes the information into the file. The end product is possibly cached so if we want to direct our informations instantly to the file we need to name the flower ( ) method.

As last measure we should shut the file with the stopping point ( ) method and we are done.


public nothingness writeFile ( ) {

Stringing filename = “ degree Celsius: est.txt ” ;

seek {

BufferedWriter author = new BufferedWriter ( new FileWriter ( fileName, true ) ) ;

writer.write ( “ Test text. “ ) ;

writer.newLine ( ) ;

writer.write ( “ Line2 ” ) ;

writer.close ( ) ;

} gimmick ( IOException e ) {

e.printStackTrace ( ) ;



4.2.2 Breadth-first heuristic hunt

Frontier hunt is a memory efficient attack to chart hunt that merely shops the Open list and saves memory by non hive awaying the Closed list. It uses techniques to forestall regeneration of antecedently closed nodes that are no longer in memory as the traditional hint back method of solution recovery requires all closed nodes to be in memory. It besides uses a divide and conquer method of solution recovery in which each hunt node keeps path of an intermediate node along the best way that leads to it. When the end node is selected for spread outing the intermediate node associated with it must be on an optimum solution way. This intermediate node is used to split the original hunt job into two bomber jobs – 1. The job of happening an optimum way from the start node to the intermediate node. 2. The job of happening an optimum way from the intermediate node to the end node. Then these bombers jobs are solved recursively by the same hunt algorithm until all the nodes along an optimum solution way for the original job are identified [ 1 ] .

Java codification shows the execution of the BFS algorithm:

public nothingness bfs ( )


// BFS uses Queue informations construction

Queue q=new LinkedList ( ) ;

q.add ( this.rootNode ) ;

printNode ( this.rootNode ) ;

rootNode.visited=true ;

while ( ! q.isEmpty ( ) )


Node n= ( Node ) q.remove ( ) ;

Node child=null ;

while ( ( child=getUnvisitedChildNode ( n ) ) ! =null )


child.visited=true ;

printNode ( kid ) ;

q.add ( kid ) ;



// Clear visited belongings of nodes

clearNodes ( ) ;


My undertaking informations will be the web application i.e. educational application for BITS-Pilani, Dubai holding 3 countries of involvement:

Particular Interest Group ( SIG )

Conference Alerts

Higher Education

With the users:


Library staff


Therefore the root of the hunt tree will be BITS-Pilani, Dubai, parent nodes-SIG, CA, HE and children- pupils, library staff and module. For this tree BFS will be done.

Chapter 5


5.1 Introduction

In this chapter we will discourse about the algorithm sing the coevals of the graph by inputting the construction of the web site ( state ) and so implementing comprehensiveness foremost hunt for this graph generated. The cryptography of the plan is done with Java and the platform is JC Creator.

The plan is an unfastened plan i.e. it can be implemented for any web application and by any user.

5.2 Algorithm

Input signal

The inputs for the plan are the links associated with site these links act like nodes and borders for the graph.

For the category ProjGraph:

We need to be able to add and link vertices

A manner to parse a text file that holds the information of our graph

Possibly to overrule the toString ( ) method to look into if the graph is decently built

For the category BFS:

Get the borders of a specific vertex

To look into if a certain vertex is connected to some other vertex or non

Generating Graph

Creation of the contiguity list and parsing the informations file

As the graph is a adrift graph, so we can link vertex X to vertex Y and frailty versa by utilizing a private-helper method.

If vertex X already exists in the contiguity list, acquire its border list and add vertex Y to it.

If it does n’t be make a new Array List and add vertex Y to it and set it all in the contiguity List.

The map “ private nothingness connect ( ) ” returns true iff vertex X points to vertex Y.

The map “ return edges.contain ( ) ” returns all the borders of a certain vertex or throws an exclusion if the vertex does non be in this graph ( “ throw new RuntimeException ( ) ” ) .

The map “ private nothingness parseDataFile ( String file name ) ” reads a text file with the graph-data.

Then the threading representation of the graph is created.

The chief map of the plan takes the input from the informations file utilizing file handling and generates the graph.

Performing BFS

A stack is created to hive away all the vertices of our way.

First the ‘end ‘ vertex is pushed on the stack.

Then a cringle is put from the highest degree back to the first degree and a cringle through each degree.

Each vertex in that degree is checked whether it is connected to the vertex on the top of the stack. If a lucifer is found that lucifer is pushed on the stack and broken out of the cringle.

Now the stack is reversed before returning the way in the right order ( from start to complete ) .

Here is an illustration ASCII drawing of turn backing from the terminal vertex “ n ” to the get downing vertex “ g ” . The pointers & lt ; – denote the way that was found.

degree: 0 1 2 3 4 5 6 7 8

— — — — — — — — — — — — — — — — — — — — — — — — — — — — –

g & lt ; -+ IV e I a +- III & lt ; – O & lt ; – VI & lt ; – N

+- V & lt ; -+ f +- II & lt ; -+ b | P

+- degree Celsius & lt ; -+ | d |

J +- H & lt ; -+



First during the BFS traverse a ‘container ‘ is being created consisting of freshly discovered vertices where the first vertex ( the starting point ) is on index 0 i.e. ( flat 0 ) , it ‘s borders at index 1 ( degree 1 ) and so on.

Get the degree from the container which was added last and so a new degree is created to possible undiscovered vertices in.

Loop is done through each of the vertices from the last added degree and connects the neighbouring vertices to each vertex.

Then looping through each linking vertex and if the connecting vertex has non yet been visited, merely so add it to the freshly created level-list and grade it as visited in our set.

We do non necessitate to seek any farther if we stumble upon the ‘end ‘ vertex.In that instance merely ‘return ‘ from this method.

Merely do the recursive call if we have found vertices which have non been explored yet.

AnA emptyA ‘container’A is created toA storeA allA theA levelsA fromA theA ‘start ‘ vertex in. A degree is besides a list with one or more vertices.

TheA firstA levelA onlyA holdsA theA ‘start’A vertex, A whichA isA addedA foremost, thisA isA theA ‘initial’A list.

The ‘start ‘ vertex is besides stored in plus which keeps path of all the vertices we have encountered so that we do non track vertices twice ( or more ) .

Once the above 3 stairss are initialized, we can name the existent BFS-Algorithm

OnceA theA BFS-AlgorithmA isA done, A weA callA theA backTrack ( ) A method toA findA theA shortestA pathA betweenA ‘end’A andA ‘start’A betweenA theA exploredA levelsA ofA the graph.

5.3 Drumhead

Therefore the chief method in the plan involves acquiring the construction of the web site for which the BFS has to be performed and so parsing the text file ( java file managing ) that holds the information of our graph.

Therefore the chief method involves:

Creation of the graph

File managing

Geting the shortest way between 2 vertices ( BFS ) and publish the shortest way

Chapter 6


6.1 Performance Analysis of BFS





















1 msec


11 seconds

18 proceedingss

31 hours

128 yearss

35 old ages

3500 old ages

100 B

11 B

1 MB

111 MB

11 GB

1 Terbium

111 Terbium

11,111 Terbium

BFS deepness demands on clip and memory

6.2 Applications of BFS

Breadth first hunt can be used to work out many jobs in graph theory, for illustration:

Finding all nodes within one connected constituent

Copying Collection ‘Cheney ‘s algorithm ‘

Finding the shortest way between two nodes u and V

Testing a graph for bipartiteness

( Reverse ) Cuthill-McKee mesh enumeration

Ford-Fulkerson method for calculating the maximal flow in a flow web

Serialization or Deserialization of a binary tree vs. serialisation in sorted order allows the tree to be re-constructed in an efficient mode.

6.3 Advantages of BFS

BFS is an thorough hunt algorithm. It is simple to implement and it can be applied to any hunt job. Comparing BFS to depth first hunt algorithm BFS does non endure from any possible space cringle job, which may do the computing machine to crash. Breadth first hunt will ne’er acquire trapped researching the useless way everlastingly. If there is a solution, BFS will decidedly happen it out. If there is more than one solution so BFS can happen the minimum 1 that requires less figure of stairss.

BFS can be used to prove bipartiteness by get downing the hunt at any vertex and giving jumping labels to the vertices visited during the hunt i.e. give label 0 to the get downing vertex, 1 to all its neighbors, 0 to those neighbors ‘ neighbors and so on. If at any measure a vertex has ( visited ) neighbors with the same label as itself, so the graph is non bipartite. If the hunt ends without such a state of affairs occurring, so the graph is bipartite.

6.4 Disadvantages of BFS

One disadvantage of BFS is that it is a ‘blind ‘ hunt i.e. when the hunt infinite is big the hunt public presentation will be hapless compared to other heuristic hunts. BFS will execute good if the hunt infinite is little. It performs best if the end province lies in upper left manus side of the tree. But it will execute comparatively ill comparative to other hunt algorithms if the end province lies in the underside of the tree. BFS will ever happen the shortest way if the weight on the links are unvarying. The chief drawback of Breadth first hunt is its memory demand. Since each degree of the tree must be saved in order to bring forth the following degree, and the sum of memory is relative to the figure of nodes stored, the infinite complexness of BFS is O ( Bachelor of Divinity ) . As a consequence, BFS is badly space-bound in pattern so will wash up the memory available on typical computing machines in a affair of proceedingss. If the solution is further off from the root, breath first hunt will devour batch of clip.

Chapter 7


My Undertaking can be implemented in hereafter for Image Processing Problems.

The footing of my undertaking i.e. comprehensiveness first hunt can be used as the breadth-first graph traverse for the processing of digital images by utilizing efficient algorithms for gnawing, distending, skeletonizing, and distance-transforming parts. These algorithms work by tracking parts in a breadth-first mode, utilizing a waiting line for storage of unrefined pels. They use memory expeditiously. The pels are removed from the waiting line every bit shortly as their processing has been completed and they process merely pels in the part ( and their neighbors ) , instead than necessitating a complete scan of the image. The image is still represented as a pel matrix in memory ; the graph is merely a convenient model for believing about the algorithms. All the algorithms will be based on sing a raster image non as a pel matrix but as a graph whose vertices represent pels and whose borders represent vicinity between pels. This suggests that pels in the image can be traversed in a breadth-first mode, instead than with the traditional raster scan. Because pels to be processed are stored in a waiting line, breadth-first traverse outputs extension patterns that grow or shrivel uniformly across their boundary like moving ridge foreparts.

The algorithm will be utilizing following:

Flood Filling ( or Object labelling )

Storing Boundary Pixels

Repeated Erosions

Distance Transformation


My undertaking can besides be implemented in future for making an educational web site where the user can choose keywords that are present in global web. Then utilizing comprehensiveness foremost hunt to pull out the nodes and their values in a web page and map them to a proper format so that it is easy for the users to seek for a peculiar informations whenever they want.

Chapter 8


In my undertaking sing BFS I have learnt that BFS is an thorough hunt algorithm. It is simple to implement and it can be applied to any hunt job.

BFS does non endure from any possible space cringle job, which may do the computing machine to crash. Breadth first hunt will ne’er acquire trapped researching the useless way everlastingly. If there is a solution, BFS will decidedly happen it out.

Furthermore I have learnt batch about web excavation, graphs, Java file handling, parsing etc. and their usage in computing machine scientific discipline.

Chapter 9


The above study concludes the 4 months of my undertaking work on Design and Implementation of BFS on Implicit Graph for Web Mining Application. My work chiefly revolved around analyzing and analysing every bit much literature as possible on subjects like running clip of algorithms, graphs, comprehensiveness foremost hunt, graph traverse applet, web excavation, JCreator, PHP etc. In this study I discussed about the literature, algorithm, design ( informations, plan and interface ) Java cryptography, execution of the algorithm of BFS, executing clip of the algorithm, creative activity and traverse of the graph for BFS.

Therefore in this study where I got to larn, understand and grok the assorted facets of my undertaking subject practically. The last 4 months ‘ worth of cognition and information helped me in analysing my undertaking. I would reason by stating that thorough cognition about the aforesaid subjects will supply for a concrete foundation for my aspirations of pull offing technology in the close hereafter.


Barnat, J. ; Brim, L. ; and Chaloupka, J. 2003. Parallel breadth-first hunt LTL theoretical account look intoing. In Proceedings of the 18th IEEE International Conference on Automated Software Engineering ( ASE’03 ) , 106-115

Bang-Jensen, J. & A ; Gutin, G. : Digraph: Theory, Algorithms and Applications. Springer-Verlag ( 2002 )

Mehlhorn, K. : Graph Algorithms and NP-Completeness. Springer-Verlag ( 1984 )

Reinhard Diestel Graph Theory Electronic Edition 2000 Springer-Verlag New York 1997, 2000

Introduction to Algorithms, Second Edition Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein, The MIT Press Cambridge, Massachusetts London, England, McGraw-Hill Book Company Boston Burr Ridge, IL Dubuque, IA Madison, WI New York San Francisco St. Louis Montreal Toronto

Analysis of Algorithms: An Active Learning Approach, Jeffrey J. McConnell, Jones and Bartlett Publishers

Introduction to The Design and Analysis of Algorithms, 2nd edition, Pearson International Edition, Anany Levitin

Jeyalatha Sivaramkrishnan, Vijayakumar Balakrishnan, “ Web Mining Functions in an Academic Search Applications ” , Informatica EconomicA? vol. 13, no. 3/2009.

Java Breadth First Search job,

hypertext transfer protocol: //

“ Introduction to Graph with Breadth First Search ( BFS ) and Depth First Search ( DFS ) Traversal Implemented in JAVA ”

hypertext transfer protocol: //

Share this Post!

Kylie Garcia

Hi there, would you like to get such a paper? How about receiving a customized one?

Check it out