C Programming

By using the algorithm of bitwise EORing (Exclusive ORing) the numbers together:

If the two numbers are X and Y, then to swap them:

X = X EOR Y

Y = Y EOR X

X =X EOR Y

will swap them.

With knowledge of that algorithm, one then uses the syntax of Javascript to implement it.

In Java

// the string we want to process

final String str = "Mumbai";

// convenience conversion to characters

final char[] str_chars = str.toCharArray();

// letters used to keep track of which characters we've counted

final Set letters = new HashSet();

// iterate through each character in str

for (int i = 0; i < str_chars.length; ++i) {

// store lower case version of ch so we only need to convert once

final char ch_l = Character.toLowerCase(str_chars[i]);

// only process this letter if we haven't done so yet

if (!letters.contains(ch_l)) {

// store letter

letters.add(ch_l);

// count number of times this letter is in str

int count = 1;

for (int j = i + 1; j < str_chars.length; ++j) {

if (ch_l == Character.toLowerCase(str_chars[j])) {

++count;

}

}

// output

System.out.format("%c%d", str_chars[i], count);

}

}

Instance variables are not global nor local variables.

Variables in OOP are different from the counter parts in COBOL, FORTRAN, or C.

To define any variable in OOP, it must be defined within a class/struct, at instance or class level (static in C# or shared in VB.NET).

local variables usually referred to those defined within a method (of a class, instance-level or class-level) in OOP (object oriented programming).

global variables, to define one in OOP is difficult and violate the object oriented design principle. However, the singleton design pattern does address this issue.

Singleton pattern guarantees that the same instance (of that class) being the only one lives within your application (and globally accessible to that same instance), and hence the variables defined within this singleton may be treated as "global" variables

Breadth First Search is the technique to find the shortest distance between some starting node and the remaining nodes of the graph. This shortest distance is the minimum number of edges traversed in order to travel from the start node to the specific node being examined. It is called BFS because the distances are given breadth wise. It is the faster search technique as the representation of the nodes and the edges are in the form of adjacency list representation. We can also use this technique for searching.

Depth-first search (DFS) is an algorithm for traversing or searching a tree, tree structure, or graph. One starts at the root (selecting some node as the root in the graph case) and explores as far as possible along each branch before backtracking.

/******************************************************************

-> This Program is to implement Depth First search.

-> Data Structers:

Graph:Adjacency List

Stack:Array

-> This program works in Microsoft vc++ 6.0 environment.

*******************************************************************/

#include

int visit[100];

class graph

{

private:

int n;

graph*next;

public:

graph* read_graph(graph*);

void dfs(int); //dfs for a single node

void dfs(); //dfs of the entire graph

void ftraverse(graph*);

}*g[100];

int dfs_span_tree[100][100];

graph* graph::read_graph(graph*head)

{

int x;

graph*last;

head=last=NULL;

cout<<"Enter adjecent node ,-1 to stop:\n";

cin>>x;

while(x!=-1)

{

graph*NEW;

NEW=new graph;

NEW->n=x;

NEW->next=NULL;

if(head==NULL)

head=NEW;

else

last->next=NEW;

last=NEW;

cout<<"Enter adjecent node ,-1 to stop:\n";

cin>>x;

}

return head;

}

void graph::ftraverse(graph*h)

{

while(h!=NULL)

{

cout<n<<"->";

h=h->next;

}

cout<<"NULL"<

}

void graph::dfs(int x)

{

cout<<"node "<

visit[x]=1;

graph *p;

p=g[x];

while(p!=NULL)

{

int x1=p->n;

if(visit[x1]==0)

{

cout<<"from node "<

//Add the edge to the dfs spanning tree

dfs_span_tree[x][x1]=1;

dfs(x1);

}

p=p->next;

}

}

void graph::dfs()

{

int i;

cout<<"**********************************************************\n";

cout<<"This program is to implement dfs for an unweighted graph \n";

cout<<"**********************************************************\n";

cout<<"Enter the no of nodes ::";

cin>>n;

for(i=1;i<=n;i++)

g[i]=NULL;

for(i=1;i<=n;i++)

{

cout<<"Enter the adjacent nodes to node no. "<

cout<<"***************************************\n";

g[i]=read_graph(g[i]);

}

//display the graph

cout<<"\n\nThe entered graph is ::\n";

for(i=1;i<=n;i++)

{

cout<<" < "< ::";

ftraverse(g[i]);

}

for(i=1;i<=n;i++)

visit[i]=0; //mark all nodes as unvisited

cout<<"\nEnter the start vertex ::";

int start;

cin>>start;

for(i=1;i<=n;i++)

for(int j=1;j<=n;j++)

dfs_span_tree[i][j]=0;

cout<<"\nThe dfs for the above graph is ::\n";

dfs(start);

cout<<"\n\nThe required dfs spanning tree is ::\n";

for(i=1;i<=n;i++)

{

for(int j=1;j<=n;j++)

cout<

cout<

}

}

int main()

{

graph obj;

obj.dfs();

return 0;

}