My Techno World

C++ program to show animated dancing dolls in graphics

2015-07-25T01:05:00.002+05:30

#include<dos.h>
#include<iostream.h>
#include<conio.h>
#include<graphics.h>
class doll
{
public:
void dolldraw(int x)
{
int y=100;
circle(x,y+10,10);
line(x,y+20,x,y+100);
line(x,y+40,x-20,y+70);
line(x,y+40,x+20,y+70);
line(x,y+100,x-20,y+120);
line(x,y+100,x+20,y+120);
}
void dollmoll(int x)
{
int y=100;
circle(x,y+10,10);
line(x,y+20,x,y+100);
line(x,y+50,x-20,y+30);
line(x,y+50,x+20,y+30);
line(x,y+100,x-20,y+90);
line(x,y+100,x+20,y+90);
}

};
void main()
{
doll a,b,c,d,e;
int h,i,j,k;
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\TC\\BGI");
int w=50;
while(!kbhit())
{
a.dolldraw(w);
h=w+45;
b.dolldraw(h);
j=h+45;
c.dolldraw(j);
i=j+45;
d.dolldraw(i);
k=i+45;
e.dolldraw(k);
delay(500);
cleardevice();
w=150;
a.dollmoll(w);
b.dollmoll(h);
c.dollmoll(i);
d.dollmoll(j);
e.dollmoll(k);
delay(500);
cleardevice();
}
getch();
closegraph();
}

C++ Program to show animated pendulum clock in graphics

2015-07-25T01:04:00.000+05:30

#include<math.h>
#include<process.h>
#include<dos.h>
#include<iostream.h>
#include<conio.h>
#include<graphics.h>
int x1=300,y1=180,x,y;
void display(double i)
{
circle(300,130,50);
line(210,60,210,320);
line(210,60,390,60);
line(390,60,390,320);
line(210,320,390,320);
outtextxy(295,88,"12");
outtextxy(260,130,"9");
outtextxy(340,130,"3");
outtextxy(295,168,"6");
line(300,130,300,98);
line(300,98,297,101);
line(300,98,303,101);
line(337,130,300,130);
line(337,130,334,127);
line(337,130,334,133);
x=x1+95*cos(i);
y=y1+95*sin(i);
line(x1,y1,x,y);
circle(x,y,10);
delay(30);
clearviewport();
}

void main()
{
int gd=DETECT,gm;
double i;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
while(!kbhit())
{
for(i=2;i>1;i=i-0.01)
display(i);
for(i=1;i<2;i=i+0.01)
display(i);
}
getch();
}

C++ Program to show animated bouncing ball

2015-07-25T00:59:00.002+05:30

Program
#include<iostream.h>
#include<conio.h>
#include<graphics.h>
#include<dos.h>
void main()
{
clrscr();
int gd=0,gm,x=20,flag=0,y=200,uplimit=250;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
while(!kbhit())
{
setcolor(4);
line(0,400,679,400);
if(flag==0)
{
y+=2;
x+=1;
if(y>=385)
flag=1;
}
if(flag==1)
{
y-=2;
x+=1;
if(y<=uplimit)
{
flag=0;
uplimit+=20;

}
}

setcolor(15);
fillellipse(x,y,15,15);
delay(15);
setcolor(0);
setfillstyle(1,10);
fillellipse(x,y,15,15);
cleardevice();
}

getch();
}

C++ program to show animated traffic signal (Simple graphics)

2015-07-25T00:57:00.004+05:30

#include<iostream.h>
#include<conio.h>
#include<graphics.h>
#include<dos.h>
void main()
{
clrscr();
int gd=0,gm;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
rectangle(250,50,350,350);
circle(300,100,50);
circle(300,200,50);
circle(300,300,50);
line(80,80,80,500);
line(80,80,250,80);

while(!kbhit())
{
int x=100;
setfillstyle(1,RED);
floodfill(x+200,100,WHITE);
delay(500);
setfillstyle(1,BLACK);
floodfill(x+200,100,WHITE);
setfillstyle(1,YELLOW);
floodfill(x+200,200,WHITE);
delay(500);
setfillstyle(1,BLACK);
floodfill(x+200,200,WHITE);
setfillstyle(1,GREEN);
floodfill(x+200,300,WHITE);
delay(300);
setfillstyle(1,BLACK);
floodfill(x+200,300,WHITE);
}

getch();
closegraph();
}

C++ Program to draw a moving jeep (Simple Graphics)

2015-07-25T00:56:00.000+05:30

Program

#include<iostream.h>
#include<conio.h>
#include<graphics.h>
#include<dos.h>
#include<math.h>
#include<stdlib.h>
#include<process.h>
void main()
{
clrscr();
int gd=DETECT,gm;
int x=320;
initgraph(&gd,&gm,"C:\\TC\\BGI");
while(!kbhit())
{
setcolor(RED);
line(x,200,x,290);
line(x,290,x+280,290);
line(x+280,290,x+280,100);
line(x+280,100,x+110,100);
line(x+110,100,x+85,200);
line(x+85,200,x,200);
rectangle(x+250,120,x+200,170);
setcolor(3);
circle(x+60,290,30);
circle(x+210,290,30);
delay(50);
cleardevice();
x=x-3;
}
getch();
closegraph();
}

C++ program to implement shearing in graphics

2015-07-25T00:51:00.003+05:30

A shear is a transformation that distorts the shape of an object along either or both of the axies. Like scale and translate, a shear can be done along just one or along both of the coordinate axes. A shear along one axis (say, the x-axis) is performed in terms of the point's coordinate in the other axis (the y-axis). Thus a shear of 1 in the x-axis will cause the x-coodinate of the point ot distort by 1*(y-coordinate).

http://www.gomezconsultants.com/CSE5280/Transformations/2DTrans.html

Pogram

#include<iostream.h>
#include<conio.h>
#include<graphics.h>
#include<dos.h>
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
float x1,y1,x2,y2;
float shx,shy;
char ch;
x1=50;y1=100;x2=100;y2=200;
rectangle(x1,y1,x2,y2);
delay(10);
cout<<"enter the direction of shear : ";
cin>>ch;
if(ch=='x')
{
cout<<"enter x-direction of shear : ";
cin>>shx;
y1=y1+shx*x1;
y2=y2+shx*x2;
setcolor(RED);
rectangle(x1,y1,x2,y2);
}
else
{
cout<<"enter y-direction of shear : ";
cin>>shy;
x1=x1+shy*y1;
x2=x2+shy*y2;
setcolor(RED);
rectangle(x1,y1,x2,y2);
}
getch();
closegraph();
}

C++ Program to implement reflection in graphics

2015-07-25T00:47:00.003+05:30

Reflection in computer graphics is used to emulate reflective objects like mirrors and shiny surfaces.

Reflection is accomplished in a ray trace renderer by following a ray from the eye to the mirror and then calculating where it bounces from, and continuing the process until no surface is found, or a non-reflective surface is found. Reflection on a shiny surface like wood or tile can add to the photorealistic effects of a 3D rendering.

https://en.wikipedia.org/wiki/Reflection_(computer_graphics)

Program

#include <iostream.h>
#include <conio.h>
#include <graphics.h>
#include <math.h>
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
int a=getmaxx();
int b=getmaxy();
int y=b⁄2;
int x=a⁄2;
line(x,0,x,b);
line(0,y,a,y);
int x1=x+100;
int y1=y-100;
int x2=x+150;
int y2=y-150;
line(x2,y2,x1,y1);
line(x2,y+150,x1,y+100);
line(x-100,y+100,x-200,y+100);
line(x-150,y+150,x-200,y+100);
line(x-100,y+100,x-150,y+150);
line(x-100,y-100,x-150,y-150);
line(x-150,y-150,x-200,y-100);
line(x-200,y-100,x-100,y-100);
getch();
closegraph();
}

C++ Program to implement scaling in graphics

2015-07-25T00:44:00.000+05:30

A scaling can be represented by a scaling matrix. To scale an object by a vector v = (v_x, v_y, v_z), each point p = (p_x, p_y, p_z) would need to be multiplied with this scaling matrix:

As shown below, the multiplication will give the expected result:

Such a scaling changes the diameter of an object by a factor between the scale factors, the area by a factor between the smallest and the largest product of two scale factors, and the volume by the product of all three.

https://en.wikipedia.org/wiki/2D_computer_graphics

Program

#include <iostream.h>
#include <conio.h>
#include <graphics.h>
void main()
{
int gd=DETECT,gm;
float x1,y1,x2,y2,sx,sy;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
cout<<"SCALING OF A LINE\n";
cout<<"Enter the first coordinate of a line:";
cin>>x1>>y1;
cout<<"Enter the second coordinate of a line:";
cin>>x2>>y2;
line(x1,y1,x2,y2);
cout<<"Enter the scaling factor:";
cin>>sx>>sy;
setcolor(RED);
x1=x1*sx;
y1=y1*sy;
x2=x2*sx;
y2=y2*sy;
line(x1,y1,x2,y2);
getch();
closegraph();
}

C++ Program to implement rotation in graphics

2015-07-25T00:40:00.003+05:30

In linear algebra, a rotation matrix is a matrix that is used to perform a rotation in Euclidean space. For example the matrix

rotates points in the xy-Cartesian plane counterclockwise through an angle θ about the origin of the Cartesian coordinate system. To perform the rotation using a rotation matrixR, the position of each point must be represented by a column vector v, containing the coordinates of the point. A rotated vector is obtained by using the matrix multiplication Rv. Since matrix multiplication has no effect on the zero vector (i.e., on the coordinates of the origin), rotation matrices can only be used to describe rotations about the origin of the coordinate system.

https://en.wikipedia.org/wiki/2D_computer_graphics

Program

#include <math.h>
#include <iostream.h>
#include <conio.h>
#include <graphics.h>
void main()
{
int gd=DETECT,gm,x1,x2,y1,y2,x4,y4;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
float angle=0,ang;
cout<<"\nROTATION OF A LINE\n";
cout<<"Enter the first coordinate of a line:";
cin>>x1>>y1;
cout<<"Enter the second coordinate of a line:";
cin>>x2>>y2;
line(x1,y1,x2,y2);
cout<<"Enter the angle:";
cin>>ang;
angle=(ang*3.14)⁄180;
setcolor(RED);
x4=x2-(((x2-x1)*cos(angle))-((y2-y1)+sin(angle)));
y4=y2-(((x2-x1)*sin(angle))+((y2-y1)*cos(angle)));
line(x2,y2,x4,y4);
getch();
closegraph();
}

C++ Program to implement translation in graphics

2015-07-25T00:37:00.003+05:30

A translation is an affine transformation but not a linear transformation, homogeneous coordinates are normally used to represent the translation operator by a matrix and thus to make it linear. Thus we write the 3-dimensional vector w = (w_x, w_y, w_z) using 4 homogeneous coordinates as
w = (w_x, w_y, w_z, 1).^[1]

https://en.wikipedia.org/wiki/2D_computer_graphics

Program

#include <iostream.h>
#include <conio.h>
#include <graphics.h>
void main()
{
int gd=DETECT,gm,x1,x2,y1,y2,tx,ty;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
cout<<"Enter the first co-ordinate of a line:";
cin>>x1>>y1;
cout<<"Enter the second co-ordinate of a line:";
cin>>x2>>y2;
line(x1,y1,x2,y2);
cout<<"Enter the translation vector:";
cin>>tx>>ty;
setcolor(RED);
x1=x1+tx;
y1=y1+ty;
x2=x2+tx;
y2=y2+ty;
line(x1,y1,x2,y2);
getch();
closegraph();
}

C++ Program to implement boundary fill algorithm

2015-07-25T00:34:00.001+05:30

Start at a point inside the figure and paint with a particular color. Filling continues until a boundarycolor is encountered. Thjere are two ways to do this:

https://www.siggraph.org/education/materials/HyperGraph/scanline/outprims/polygn6a.htm

Programs

#include <iostream.h>
#include <conio.h>
#include <graphics.h>
#include <dos.h>

void bfill(int x,int y,int fill,int border)
{
if((getpixel(x,y)!=border)&&(getpixel(x,y)!=fill))
{
delay(8);
putpixel(x,y,fill);

bfill(x+1, y,fill,border);
bfill(x, y+1,fill,border);
bfill(x-1, y,fill,border);
bfill(x, y-1,fill,border);
}
}
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
rectangle(10,50,50,10);
bfill(11,12,MAGENTA,WHITE);
getch();
closegraph();
}

C++ Program to implement flood fill algorithm (graphics)

2015-07-25T00:26:00.002+05:30

Flood fill, also called seed fill, is an algorithm that determines the area connected to a given node in a multi-dimensional array. It is used in the "bucket" fill tool of paint programs to fill connected, similarly-colored areas with a different color, and in games such as Go and Minesweeper for determining which pieces are cleared. When applied on an image to fill a particular bounded area with color, it is also known as boundary fill.

https://en.wikipedia.org/wiki/Flood_fill

Program

#include <iostream.h>
#include <conio.h>
#include <graphics.h>
#include <dos.h>
void ffill(int x,int y,int fill,int old)
{
if((getpixel(x,y)!=old)&&(getpixel(x,y)!=fill))
{
delay(8);
putpixel(x,y,fill);
ffill(x+1,y,fill,old);
ffill(x-1,y,fill,old);
ffill(x,y+1,fill,old);
ffill(x,y-1,fill,old);
}
}
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
rectangle(10,50,50,10);
ffill(15,30,MAGENTA,WHITE);
getch();
closegraph();
}

C++ Program to implement Bresenham's circle algorithm (Graphics)

2015-07-25T00:20:00.003+05:30

In computer graphics, the midpoint circle algorithm is an algorithm used to determine the points needed for drawing a circle. Bresenham's circle algorithm is derived from the midpoint circle algorithm. The algorithm can be generalized to conic sections.^[1]

https://en.wikipedia.org/wiki/Midpoint_circle_algorithm

Program

#include <iostream.h>
#include <graphics.h>
#include <conio.h>
#include <dos.h>
void circlebres(float x1,float y1,float r)
{
float x,y,p;
x=0;
y=r;
p=3-(2*r);
while(x<=y)
{
putpixel(x1+x,y1+y,WHITE);
putpixel(x1-x,y1+y,WHITE);
putpixel(x1+x,y1-y,WHITE);
putpixel(x1-x,y1-y,WHITE);
putpixel(x1+y,y1+x,WHITE);
putpixel(x1+y,y1-x,WHITE);
putpixel(x1-y,y1+x,WHITE);
putpixel(x1-y,y1-x,WHITE);
x=x+1;
if(p<0)
{
p=p+4*(x)+6;
}
else
{
p=p+4*(x-y)+10;
y=y-1;

}
delay(20);

}
}
void main()
{
float x1,y1,r;
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
cout<<"Enter the starting co-ordinates of a center:";
cin>>x1>>y1;
cout<<"Enter the value of radius:";
cin>>r;
circlebres(x1,y1,r);
getch();
closegraph();
}

C++ Program to implement Bresenham's line algorithm (Graphics)

2015-07-25T00:14:00.003+05:30

Bresenham's line algorithm is an algorithm that determines the points of an n-dimensional raster that should be selected in order to form a close approximation to a straight line between two points. It is commonly used to draw lines on a computer screen, as it uses only integer addition, subtraction and bit shifting, all of which are very cheap operations in standard computer architectures. It is one of the earliest algorithms developed in the field of computer graphics. An extension to the original algorithm may be used for drawing circles.

https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm

Program

#include <iostream.h>
#include <conio.h>
#include <graphics.h>
#include<dos.h>
void bsline(int x,int y,int x2,int y2)
{
int dx,dy,p;
dx=x2-x;
dy=y2-y;
p = 2 * (dy) - (dx);
while(x <= x2)
{
if(p < 0)
{
x=x+1;
y=y;
p = p + 2 * (dy);
}
else
{
x=x+1;
y=y+1;
p = p + 2 * (dy - dx);
}
putpixel(x,y,RED);
delay(10);
}
}
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
int x1,x2,y1,y2;
cout<<"Enter the x1,y1,x2,y2 values : ";
cin>>x1>>y1>>x2>>y2;
bsline(x1,y1,x2,y2);
getch();
closegraph();
}

C++ Program to implement Digital differential analyzer (DDA graphics algorithm)

2015-07-25T00:09:00.001+05:30

In computer graphics, a digital differential analyzer (DDA) is hardware or software used for linear interpolation of variables over an interval between start and end point. DDAs are used for rasterization of lines, triangles and polygons. In its simplest implementation, the DDA algorithm interpolates values in interval by computing for each x_i the equations x_i = x_i−1+1/m, y_i = y_i−1 + m, where Δx = x_end − x_start and Δy = y_end − y_start and m = Δy/Δx

https://en.wikipedia.org/wiki/Digital_differential_analyzer_(graphics_algorithm)

Program

#include <iostream.h>
#include <conio.h>
#include <graphics.h>
#include <math.h>
#include <process.h>
void main()
{
float i,x1,x2,y1,y2,dx,dy,x,y,step,xinr,yinr;
int gd=DETECT,gm;
clrscr();
initgraph(&gd,&gm,"C:\\Tc\\BGI");
cout<<"Enter the values\n";
cin>>x1>>y1>>x2>>y2;
dx=x2-x1;
dy=y2-y1;
if(dx==0&&dy==0)
{
putpixel(x1,y1,15);
getch();
exit(0);
}
if(abs(dx)>=abs(dy))
step=abs(dx);
else
step=abs(dy);
xinr=dx⁄step;
yinr=dy⁄step;
x=x1;
y=y1;
for(i=1;i<=step;i++)
{
putpixel(x,y,15);
x=x+xinr;
y=y+yinr;
}
getch();
closegraph();
}

C++ Program to draw umbralla couple (Simple Graphics)

2015-07-25T00:05:00.001+05:30

#include <iostream.h>

#include <conio.h>

#include <graphics.h>

void main()

{

int gd=DETECT,gm;

initgraph(&gd,&gm,"C:\\Tc\\BGI");

arc(150,150,80,230,70);

line(164,81,105,204);

line(133,145,179,180);

circle(200,120,30);

line(185,146,160,280);

line(215,146,212,283);

line(160,280,212,283);

line(163,280,180,350);

line(200,282,220,350);

line(200,180,250,250);

line(298,175,242,250);

circle(300,130,30);

line(285,156,260,280);

line(315,156,335,280);

line(260,280,335,280);

line(285,280,285,350);

line(310,280,310,350);

circle(335,150,10);

circle(335,168,7);

circle(335,180,5);

getch();

closegraph();

}

Output

C++ Program to draw a snail (Simple Graphics)

2015-07-25T00:02:00.001+05:30

#include <iostream.h>
#include <conio.h>
#include <graphics.h>
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
setcolor(GREEN);
setfillstyle(SOLID_FILL,YELLOW);
circle(300,150,20);
floodfill(300,150,GREEN);
circle(300,190,19);
floodfill(300,190,GREEN);
circle(300,228,18);
floodfill(300,228,GREEN);
circle(263,230,19);
floodfill(265,230,GREEN);
circle(227,230,17);
floodfill(231,230,GREEN);
circle(198,230,12);
floodfill(202,230,GREEN);
line(280,120,289,135);
setfillstyle(SOLID_FILL,GREEN);
circle(280,115,5);
floodfill(280,115,GREEN);
line(310,115,305,130);
circle(310,110,5);
floodfill(310,110,GREEN);
setfillstyle(SOLID_FILL,BROWN);
circle(292,140,2);
floodfill(292,140,GREEN);
circle(300,140,2);
floodfill(300,140,GREEN);
arc(295,150,180,360,5);
circle(220,185,30);
circle(220,185,26);
circle(220,185,21);
circle(220,185,10);
circle(220,185,13);
circle(220,185,6);
getch();
closegraph();
}

Output

C++ Program to draw a bird (Simple Graphics)

2015-07-24T23:59:00.001+05:30

#include <iostream.h>
#include <conio.h>
#include <graphics.h>
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
setcolor(RED);
setfillstyle(SOLID_FILL,YELLOW);
ellipse(345,180,190,189,89,50);
floodfill(345,180,RED);
setfillstyle(SOLID_FILL,YELLOW);
circle(224,150,40);
floodfill(225,150,RED);
setfillstyle(SOLID_FILL,BLACK);
circle(200,143,2);
floodfill(200,143,RED);
line(135,183,190,170);
line(135,183,185,143);
line(379,290,379,227);
line(340,280,345,230);
arc(371,295,30,160,10);
arc(331,286,20,160,10);
setfillstyle(SOLID_FILL,YELLOW);
ellipse(507,160,110,109,80,20);
floodfill(510,160,RED);
setfillstyle(SOLID_FILL,YELLOW);
ellipse(503,160,108,107,70,10);
floodfill(503,160,RED);
getch();
closegraph();
}

Output

C++ Program to draw a cockroach (Simple Graphics)

2015-07-24T23:56:00.002+05:30

#include <iostream.h>
#include <conio.h>
#include <graphics.h>
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
setfillstyle(SOLID_FILL,BROWN);
fillellipse(310,160,80,50);
ellipse(310,160,110,109,80,50);
setfillstyle(SOLID_FILL,BROWN);
fillellipse(400,160,20,20);
circle(400,160,20);
setcolor(RED);
arc(468,150,80,180,50);
arc(468,165,180,290,50);
ellipse(355,136,120,284,105,23);
ellipse(355,185,77,240,105,23);
arc(310,70,300,40,50);
arc(270,67,300,40,50);
arc(282,221,300,15,60);
arc(240,224,300,15,60);
circle(410,170,3);
circle(410,150,3);
getch();
}

Output

C++ Program to draw a bird with nest (Simple graphics)

2015-07-24T23:52:00.003+05:30

#include <iostream.h>
#include <conio.h>
#include <graphics.h>
void main()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"C:\\Tc\\BGI");
setcolor(RED);
setfillstyle(SOLID_FILL,YELLOW);
ellipse(345,180,190,189,89,50);
floodfill(345,180,RED);
setfillstyle(SOLID_FILL,YELLOW);
circle(224,150,40);
floodfill(225,150,RED);
setfillstyle(SOLID_FILL,BLACK);
circle(200,143,2);
floodfill(200,143,RED);
line(135,183,190,170);
line(135,183,185,143);
line(379,290,379,227);
line(340,280,345,230);
arc(371,295,30,160,10);
arc(331,286,20,160,10);
ellipse(325,280,110,417,135,70);
circle(300,275,15);
circle(365,320,15);
circle(395,300,15);
setfillstyle(SOLID_FILL,YELLOW);
ellipse(507,160,110,109,80,20);
floodfill(510,160,RED);
setfillstyle(SOLID_FILL,YELLOW);
ellipse(503,160,108,107,70,10);
floodfill(503,160,RED);
getch();
closegraph();
}

Output

C++ Program to implement Depth-first search in binary tree

2014-08-26T19:51:00.000+05:30

In depth-first order, we always attempt to visit the node farthest from the root node that we can, but with the caveat that it must be a child of a node we have already visited. Unlike a depth-first search on graphs, there is no need to remember all the nodes we have visited, because a tree cannot contain cycles. Pre-order is a special case of this. See depth-first search for more information.

For more visit : http://en.wikipedia.org/wiki/Binary_tree

#include<iostream.h>
#include<conio.h>
struct node
{
int info;
node *left;
node *right;
}*root;
void insert(int,node*);
void insert(int item)
{
if(root!=NULL)
insert(item, root);
else
{
root=new node;
root->info=item;
root->left=NULL;
root->right=NULL;
}
}
void insert(int item, node *leaf)
{
if(item< leaf->info)
{
if(leaf->left!=NULL)
insert(item,leaf->left);
else
{
leaf->left=new node;
leaf->left->info=item;
leaf->left->left=NULL;
leaf->left->right=NULL;
}
}
else if(item>=leaf->info)
{
if(leaf->right!=NULL)
insert(item, leaf->right);
else
{
leaf->right=new node;
leaf->right->info=item;
leaf->right->left=NULL;
leaf->right->right=NULL;
}
}
}
int DFS(node *leaf,int search)
{
static found =0;
if(leaf!=NULL)
{
if(leaf->info==search)
found=1;
DFS(leaf->left,search);
DFS(leaf->right,search);
cout<<" "<<leaf->info;
}
return found;
}
void main()
{
clrscr();
int op;
int item;
while(op!=3)
{
cout<<"\nSelect Option\n1.Insert item\n2.Search item\n3.exit\n";
cin>>op;
switch(op)
{
case 1:
cout<<"Enter the item to insert in tree :";
cin>>item;
insert(item);
break;
case 2:
cout<<"Enter item to search :";
cin>>item;
cout<<" DFS :";
if(DFS(root,item))
cout<<"\t Item Found\n";
else
cout<<"\t Item Not Found\n";
break;
case 3:
cout<<"Press any to exit";
break;
default:
cout<<"Invalid option";
}
getch();
}

}

C++ Program to implement Traversal in Binary tree.

2014-08-26T19:47:00.001+05:30

In computer science, tree traversal (also known as tree search) refers to the process of visiting (examining and/or updating) each node in a tree data structure, exactly once, in a systematic way. Such traversals are classified by the order in which the nodes are visited. The following algorithms are described for a binary tree, but they may be generalized to other trees as well.

1.Pre-order

In-order (symmetric)

3.Post-order

For more visit : http://en.wikipedia.org/wiki/Tree_traversal

#include<iostream.h>
#include<conio.h>
struct node
{
int info;
node *left;
node *right;
}*root;
void insert(int,node*);
void insert(int item)
{
if(root!=NULL)
insert(item, root);
else
{
root=new node;
root->info=item;
root->left=NULL;
root->right=NULL;
}
}
void insert(int item, node *leaf)
{
if(item< leaf->info)
{
if(leaf->left!=NULL)
insert(item,leaf->left);
else
{
leaf->left=new node;
leaf->left->info=item;
leaf->left->left=NULL;
leaf->left->right=NULL;
}
}
else if(item>=leaf->info)
{
if(leaf->right!=NULL)
insert(item, leaf->right);
else
{
leaf->right=new node;
leaf->right->info=item;
leaf->right->left=NULL;
leaf->right->right=NULL;
}
}
}
void preorder(node *leaf)
{
if(leaf!=NULL)
{
cout<<" "<<leaf->info;
preorder(leaf->left);
preorder(leaf->right);
}
}
void inorder(node*leaf)
{
if(leaf!=NULL)
{
inorder(leaf->left);
cout<<" "<<leaf->info;
inorder(leaf->right);
}
}
void postorder(node *leaf)
{
if(leaf!=NULL)
{
postorder(leaf->left);
postorder(leaf->right);
cout<<" "<<leaf->info;
}
}
void main()
{
clrscr();
int op;
int item;
while(op!=5)
{
cout<<"\nSelect Option\n1.Insert item\n2.preorder\n3.inorder\n4.postorder\n5.exit\n";
cin>>op;
switch(op)
{
case 1:
cout<<"Enter the item to insert in tree :";
cin>>item;
insert(item);
break;
case 2:
cout<<"Preorder :";
preorder(root);
break;
case 3:
cout<<"Inorder :";
inorder(root);
break;
case 4:
cout<<"Postorder :";
postorder(root);
break;
case 5:
cout<<"Press any to exit";
break;
default:
cout<<"Invalid option";
}
getch();
}

}

C++ Program to Show the working of Doubly linked list

2014-08-26T19:35:00.002+05:30

In a doubly linked list, each node contains, besides the next-node link, a second link field pointing to the previous node in the sequence. The two links may be called forward(s) and backwards, or next and prev(previous).

For More Visit : http://en.wikipedia.org/wiki/Linked_list

#include<iostream.h>
#include<conio.h>
struct node
{
int info;
node *back;
node *forw;

}*list;
void add(int item)
{
node *tem=new node;
tem->info=item;
list->forw=tem;
tem->back=list;
list=tem;
cout<<"\nItem Added";
}
void remove(int item)
{
if(list==NULL)
{
cout<<"\nUnder flow :List is empty";
return;
}
node *tem=list;
while(tem!=NULL)
{
if(tem->info==item)
{
node *ltem=tem->forw;
ltem->back=tem->back;
ltem=tem->back;
ltem->forw=tem->forw;
delete tem;
cout<<"\nItem Deleted";
return;
}
tem=tem->back;

}
cout<<"\nItem not found";
}
void show()
{
node *tem=list;
cout<<"\nList Item :";
while(tem!=NULL)
{
cout<<" "<<tem->info;
tem=tem->back;
}
}
void main()
{
clrscr();
int op;
int item;
while(op!=4)
{
cout<<"\nSelect Option\n1.add\n2.remove\n3.show\n4.exit\n";
cin>>op;
switch(op)
{
case 1:
cout<<"\nEnter the item to add : ";
cin>>item;
add(item);
break;
case 2:
cout<<"\nEnter the item to remove : ";
cin>>item;
remove(item);
break;
case 3:
show();
break;
case 4:
cout<<"Press any key to exit";
break;
default:
cout<<"Invalid";

}
getch();
}
}

C++ Program to Show working of Singly linked list

2014-08-26T19:25:00.004+05:30

In computer science, a linked list is a data structure consisting of a group of nodes which together represent a sequence. Under the simplest form, each node is composed of a data and a reference (in other words, a link) to the next node in the sequence; more complex variants add additional links. This structure allows for efficient insertion or removal of elements from any position in the sequence.

For more visit : http://en.wikipedia.org/wiki/Linked_list .

#include<iostream.h>
#include<conio.h>
struct node
{
int info;
node *ptr;
}*list;
void add(int item)
{
node *tem=new node;
tem->info=item;
tem->ptr=list;
list=tem;
cout<<"\nItem Added";
}
void remove(int item)
{
if(list==NULL)
{
cout<<"\nUnder flow :List is empty";
return;
}
node *tem=list;
node *ltem;
ltem->ptr=list;
while(tem!=NULL)
{
if(tem->info==item)
{
ltem->ptr=tem->ptr;
delete tem;
cout<<"\nItem Deleted";
return;
}
ltem=tem;
tem=tem->ptr;

}
cout<<"\nItem not found";
}
void show()
{
node *tem=list;
cout<<"\nList Item :";
while(tem!=NULL)
{
cout<<" "<<tem->info;
tem=tem->ptr;
}
}
void main()
{
clrscr();
int op;
int item;
while(op!=4)
{
cout<<"\nSelect Option\n1.add\n2.remove\n3.show\n4.exit\n";
cin>>op;
switch(op)
{
case 1:
cout<<"\nEnter the item to add : ";
cin>>item;
add(item);
break;
case 2:
cout<<"\nEnter the item to remove : ";
cin>>item;
remove(item);
break;
case 3:
show();
break;
case 4:
cout<<"Press any key to exit";
break;
default:
cout<<"Invalid";

}
getch();
}
}

How to Write in Hindi in Computer

2014-08-19T21:03:00.000+05:30

You can use this method to write Hindi or language in computer

To my friend Joby.

Follow the step one by one:

Step 1 : Download and extract Hindi font , from here : http://www.mediafire.com/download/15amzk8wicr0kc8/Hindi_Font.zip

Step 2 : Install the font.

(Click to enlarge picture)

Step 3 : Open Character Map by searching in start.

(Click to enlarge picture)

Step 4 : Set font and use to select characters .

(Click to enlarge picture)

Step 5 : Copy the selected characters and past it in notepad or MS office.

(Click to enlarge picture)

*Note : you should set same Hindi font in notepad or MS office.

(Click to enlarge picture)

Now enjoy typing in different language.
(Click to enlarge picture)