Uploading Image to Sql Server Image Datatype in asp.net using fileupload Control

Design & Analysis of Algorithm Programs :


USING RECURSION
//Mazimum element using recursion
#include<iostream.h>
#include<conio.h>
class Max
{
 int No,A[10],N,i,j,k;
 public:
  void Get();
  int Maximum(int);
  void Put();
};
void Max :: Get()
{
 cout << "\n Enter the size of array : ";
 cin >> N;
 cout << "\n Enter the elements :\n ";
 for(int m=1;m<=N;m++)
 {
  cin >> A[m];
 }
}
int Max :: Maximum(int i)
{
 if(i<N)
 {
  j=Maximum(i+1);
  if(A[i] > A[j])
  {
   k=i;
  }
  else
  {
   k=j;
  }
 }
 else
 {
  k=N;
 }
 return(k);
}
void Max :: Put()
{
 int ans = Maximum(1);
 cout << "\n Maximum element is : " << A[ans];
}
void main()
{
 Max m;
 clrscr();
 m.Get();
 m.Put();
 getch();
}




//program for searching element using recursion :
#include<iostream.h>
#include<conio.h>
class Search
{
 int No,A[10],N,i,j,k;
 public:
  void Get();
  int Search1(int);
  void Put();
};
void Search :: Get()
{
 cout << "\n Enter the size of array : ";
 cin >> N;
 cout << "\n Enter the elements :\n ";
 for(int m=1;m<=N;m++)
 {
  cin >> A[m];
 }
 cout << "\n Enter the number to be searched : ";
 cin >> No;
}
int Search :: Search1(int i)
{
 if(i<=N)
 {
  if(A[i] == No)
  {
   k=i;
  }
  else
  {
   k=0;
   Search1(i+1);
  }
 }
 return(k);
}
void Search :: Put()
{
 int ans = Search1(1);
 if(ans == 0)
 {
  cout << "\n Element is not found.";
 }
 else
 {
  cout << "\n Element is found at position : " << ans;
 }
}
void main()
{
 Search m;
 clrscr();
 m.Get();
 m.Put();
 getch();
}











// Program for Binomial Coefficient. B(n,m)=B(n-1,m-1)+B(n-1,m),// B(n,n)=B(n,0)=1.
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
class Bino
{
 int k;
 public:
  Bino()
  {
   k=0;
  }
  int Binomial(int,int);
};
int Bino :: Binomial(int i,int j)
{
 if((i!=j) && (j!=0))
 {
  Binomial(i-1,j-1) + Binomial(i-1,j);
 }
 else
 {
  k++;
 }
 return(k);
}
void main()
{
 Bino B;
 clrscr();
 int a,b,val;
 cout << "\n\n Enter two values:";
 cin >> a >> b;
 if(a>b)
 {
  val=B.Binomial(a,b);
  cout << "\n\n Binomial coefficient of "<<a<<" & "<<b<<" is:"<<val;
 }
 else
 {
  cout << "\n\n Invalid Input";
 }
 getch();
}




//2. Removal of Recursion

//Program for Removal of Recursion for Finding the Element

//maximum element amon the array.
#include<iostream.h>
#include<conio.h>
class MaxEle
{
 int S[50],addr,top,A[50],n,i;
 public:
  MaxEle()
  {
   i=1;
  }
  void Get();
  void Max();
};
void MaxEle :: Get()
{
 cout << "\n Enter the numbers of elements :";
 cin >> n;
 cout << "\n Enter the elements : ";
 for(int m=1;m<=n;m++)
 {
  cin >> A[m];
 }
}
void MaxEle :: Max()
{
 int j,k;
 top=0;
 L1:if(i<n)
 {
  S[++top]=i;
  S[++top]=2;
  i++;
  goto L1;
  L2:j=S[top--];
  if(A[i] > A[j])
  {
   k=i;
  }
  else
  {
   k=j;
  }
 }
 else
 {
  k=n;
 }
 if(top==0)
  cout << "\n Maximum element is : " << A[k] ;
 else
 {
  addr=S[top--];
  i=S[top--];
  S[++top]=k;
  if(addr==2)
   goto L2;
 }
}

void main()
{
 MaxEle M;
 int val;
 clrscr();

 M.Get();
 M.Max();
 getch();
}




// Program for Binomial Coefficient. B(n,m)=B(n-1,m-1)+B(n-1,m)



// B(n,n)=B(n,0)=1. Using Removal of Recursion Rules.
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
class Bino
{
 int k,S[30],add,top;
 public:
  int Binomial(int,int);
};
int Bino :: Binomial(int i,int j)
{
 top=-1;
 k=0;
 L1: if((i!=j) && (j!=0))
 {
  S[++top]=i-1;
  S[++top]=j-1;
  S[++top]=2;
  S[++top]=i-1;
  S[++top]=j;
  S[++top]=2;
 }
 else
  k++;
 if(top==-1)
  return(k);
 else
 {
  add=S[top--];
  j=S[top--];
  i=S[top--];
  if(add==2)
  {
   goto L1;
  }
 }
 return(0);
}
void main()
{
 Bino B;
 clrscr();
 int a,b,val;
 cout << "\n\n Enter two values:";
 cin >> a >> b;
 if(a>b)
 {
  val=B.Binomial(a,b);
  cout << "\n\n Binomial coefficient of "<<a<<" & "<<b<<" is:"<<val;
 }
 else
 {
  cout << "\n\n Invalid Input";
 }
 getch();
}



//Program for Removal of Recursion for Searching the element in the array.
#include<iostream.h>
#include<conio.h>
class SearchEle
{
 int S[50],addr,top,A[50],n,i,no,j,k;
 public:
  SearchEle()
  {
   i=1;
  }
  void Get();
  void Search();
};
void SearchEle :: Get()
{
 cout << "\n Enter the numbers of elements :";
 cin >> n;
 cout << "\n Enter the elements : ";
 for(int m=1;m<=n;m++)
 {
  cin >> A[m];
 }
 cout << "\n Enter the element to be searched:";
 cin >> no;
}
void SearchEle :: Search()
{
 int j,k;
 top=0;
 L1:if(i<=n)
 {
  S[++top]=i;
  S[++top]=2;
  i++;
  goto L1;
  L2:j=S[top--];
  if(A[j]==no)
  {
   k=j;
   cout << "\n Element is found at position : " << k ;
   return;
  }
  else
  {
   k=0;
  }
 }
 if(top==0 && k==0)
 {
  cout << "\n Element is not found.";
 }
 else
 {
  addr=S[top--];
  if(addr==2)
   goto L2;
 }
}

void main()
{
 SearchEle S;
 int val;
 clrscr();
 S.Get();
 S.Search();
 getch();
}


//3. Heap :


// Program for creating a min heap using Insert.
#include<iostream.h>
#include<conio.h>
class InsertMinHeap
{
 int a[10];
 int n;
public:
 void Insert(int);
 void Get();
 void Show();
};
void InsertMinHeap :: Get()
{
 cout << "\n Enter the size of heap:";
 cin >> n;
 cout << "\n Enter the elements:";
 for(int i=1;i<=n;i++)
 {
  cin >> a[i];
 }
 cout << "\n Before : \n";
 Show();
 for(i=1;i<=n;i++)
 {
  Insert(i);
 }
}
void InsertMinHeap :: Insert(int n)
{
 int i=n;
 int item = a[n];
 while(i>1 && a[i/2] > item)
 {
  a[i]=a[i/2];
  i=i/2;
 }
 a[i]=item;
}
void InsertMinHeap :: Show()
{
 for(int i=1;i<=n;i++)
  cout << a[i] << "\t";
}
void main()
{
 clrscr();
 InsertMinHeap a;
 a.Get();
 cout << "\n After Insert : \n";
 a.Show();
 getch();
}


// Program for creating a max heap using Insert.
#include<iostream.h>
#include<conio.h>
class InsertMaxHeap
{
 int a[10];
 int n;
public:
 void Insert(int);
 void Get();
 void Show();
};
void InsertMaxHeap :: Get()
{
 cout << "\n Enter the size of heap:";
 cin >> n;
 cout << "\n Enter the elements:";
 for(int i=1;i<=n;i++)
 {
  cin >> a[i];
 }
 cout << "\n Before : \n";
 Show();
 for(i=1;i<=n;i++)
 {
  Insert(i);
 }
}
void InsertMaxHeap :: Insert(int n)
{
 int i=n;
 int item = a[n];
 while(i>1 && a[i/2] < item)
 {
  a[i]=a[i/2];
  i=i/2;
 }
 a[i]=item;
}
void InsertMaxHeap :: Show()
{
 for(int i=1;i<=n;i++)
  cout << a[i] << "\t";
}
void main()
{
 clrscr();
 InsertMaxHeap a;
 a.Get();
 cout << "\n After Insert : \n";
 a.Show();
 getch();
}



// Write program for creating heap tree by adjust & heapyfy function.

#include<iostream.h>
#include<conio.h>
int arr[50];int n;
class HeapTree
{
 public:
 void read();
 void adjust(int[],int,int);
 void heapyfy(int[],int);
 void display();
};
void HeapTree::read()
{
 cout<<"\nEnter how many no.s you want to insert :";
 cin>>n;
 cout<<"\nEnter elements for the tree :";
 for(int i=1;i<=n;i++)
 {
  cin>>arr[i];
 }
}
void HeapTree::adjust(int arr1[],int i,int n1)
{
 int j=2*i;
 int item=arr1[i];
 while(j<=n1)
 {
  if((j<n1)&&(arr1[j])<arr1[j+1])
  {
   j=j+1;
  }
  if(item>arr1[j])
  break;
  arr1[j/2]=arr1[j];
  j=2*j;
 }
 arr1[j/2]=item;
}
void HeapTree::heapyfy(int arr1[],int n1)
{
 for(int i=n1/2;i>=1;i--)
 {
  adjust(arr1,i,n1);
 }
}
void HeapTree::display()
{
 cout<<"\nList is :";
 for(int i=1;i<=n;i++)
 {
  cout<<arr[i]<<endl;
 }
}
void main()
{
 clrscr();
 HeapTree h;
 h.read();
 h.heapyfy(arr,n);
 h.display();
 getch();
}



4. Sortings

//Merge Sort
#include<iostream.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>
class number
{
 int a[50],n;
public:
 void getdata();
 void mergesort(int low,int high);
 void merge(int low,int mid,int high);
};
void number :: getdata()
{
 int i;
 clrscr();
 cout<<"\n\n NUMBER OF ELEMENTS? :";
 cin>>n;
 cout << "\n ENTER THE ELEMENTS : \n";
       // randomize();
 for (i=1; i<=n; i++)
 {
  // a[i]=rand()%100;
  cin>>a[i];
        // cout << a[i] << endl;
 }
 cout<<"\n\nYOUR ARRAY IS:\n";
 for (i=1; i<=n; i++)
  cout<<a[i]<<"\t";
 mergesort(1,n);
 cout<<"\n\nTHE ARRAY AFTER SORTING  :\n";
 for (i=1; i<=n; i++)
  cout<<a[i]<<"\t";
}
void number :: mergesort(int low,int high)
{
 int mid;
 if (low < high)
 {
  mid = floor((low + high) / 2);
  mergesort(low,mid);
  mergesort(mid+1,high);
  merge(low,mid,high);
 }
}
void number :: merge(int low,int mid,int high)
{
 int h,i,j,k,b[5000];
 h = low;
 i = low;
 j = mid+1;
 while ((h <= mid) && (j <=high))
 {
  if(a[h] <= a[j])
  {
   b[i] = a[h];
   h=h+1;
  }
  else
  {
   b[i] = a[j];
   j=j+1;
  }
  i=i+1;
 }
 if (h > mid)
 {
  for (k=j; k<=high; k++)
  {
   b[i] = a[k];
   i=i+1;
  }
 }
 else
 {
  for (k=h; k<=mid; k++)
  {
   b[i] = a[k];
   i=i+1;
  }
 }
 for (k=low; k<=high; k++)
  a[k] = b[k];
}
void main()
{
 number a;
 int start,end;
 clrscr();
 start = clock();
 a.getdata();
 end = clock();
 cout << "\n The execution time is : " << (end - start) / CLK_TCK;
 getch();
}


//Heap Sort
#include<iostream.h>
#include<conio.h>
#define Max 100
#include<time.h>
#include<stdlib.h>
class Heap
{
 int Sort[Max];
 int N;
public:
 void GetData();
 void Heap_Sort(int [],int);
 void Adjust(int [],int,int);
 void Heapify(int [],int);
 void PutData();
};
void Heap::GetData()
{
 cout << "\nENTER THE TOTAL ELEMENTS :";
 cin >> N;
 cout << "\nENTER THE ELEMENTS :" << endl;
       // randomize();
 for(int i=1;i<=N;i++)
 {
       // Sort[i]=rand()%100;
  cin>>Sort[i];
       // cout << Sort[i] << endl;
 }
 Heap_Sort(Sort,N);
}
void Heap::Heap_Sort(int Sort[],int N)
{
 Heapify(Sort,N);
 for(int i=N;i>=2;i--)
 {
  int Temp=Sort[i];
  Sort[i]=Sort[1];
  Sort[1]=Temp;
  Adjust(Sort,1,i-1);
 }
}
void Heap::Heapify(int Sort[],int N)
{
 for(int i=(N/2);i>=1;i--)
 {
  Adjust(Sort,i,N);
 }
}

void Heap::Adjust(int Sort[],int i,int N)
{
 int j=2*i;
 int Item=Sort[i];
 while(j<=N)
 {
  if(j<N && Sort[j]<Sort[j+1])
  {
   j=j+1;
  }
  if(Item>=Sort[j])
   break;
  else
  {
   Sort[j/2]=Sort[j];
   j=j*2;
  }
 }
 Sort[j/2]=Item;
}

void Heap::PutData()
{
 cout << "\nAFTER SORTING ELEMENTS ARE :\n";
 for(int i=1;i<=N;i++)
 {
  cout << Sort[i] << endl;
 }
}
void main()
{
 int start, end;
 clrscr();
 Heap B;
 start = clock();
 B.GetData();
 B.PutData();
 end = clock();
 cout << "\n The execution time is : " << (end - start) / CLK_TCK;
 getch();
}



// Program for Quick sort.

 #include<iostream.h>
 #include<conio.h>
 #include<math.h>
 #include<stdlib.h>
 #include<time.h>
 class Quick
 {
  public:
  int A[5000],n;
  void getdata(void);
  void quicksort(int p,int q);
  int Partition(int m,int p);
  void swap(int &a,int &b);
  void putdata(void);
 };
 void Quick::quicksort(int p,int q)
 {
 if( p < q)
 {
  int j=q+1;
  j=Partition(p,j);
  quicksort(p,j-1);
  quicksort(j+1,q);
 }
 }
 int Quick::Partition(int m,int p)
 {
 int i;
 int v=A[m];
 i=m;
 do
 {
  do
  {
   i++;
  }while(A[i] <= v);
  do
  {
   p--;
  }while(A[p] > v);
  if(i<p)
  {
   swap(A[i],A[p]);
  }
  else
  break;
 }while(1);
 A[m]=A[p];
 A[p]=v;
 return(p);
 }
 void Quick::swap(int &a,int &b)
 {
 int temp=a;
 a=b;
 b=temp;
 }
 void Quick :: getdata(void)
 {
 cout << "\n\n\t Enter the limit of the array : ";
 cin >> n;
 cout << "\n\t Enter the elements of the array : ";
 randomize();
 for(int p = 1;p <= n;p++)
 {
  A[p]=rand()%100;
  cout << A[p] << endl;
 }
 }
 void Quick :: putdata(void)
 {
 cout << "\n Elements after sorting are :\n ";
 for(int k =1 ;k<=n;k++)
  cout<<"\t"<<A[k];
 }
 void main(void)
 {
 Quick Q;
 int start,end;
 clrscr();
 start = clock();
 Q.getdata();
 Q.quicksort(1,Q.n);
 Q.putdata();
 end = clock();
 cout << "\n The execution time is : " << (end - start) / CLK_TCK;
 getch();
 }



5. Matrix Multiplication :


// Program for Strassen's Matrix Multiplication.
#include<iostream.h>
#include<conio.h>
class Matrix
{
 int A[2][2],B[2][2],Result[2][2];
public:
 void Get();
 void Mult();
 void Put();
};
void Matrix :: Get()
{
 cout << "\n Enter the first 2X2 matrix :\n";
 for(int i=1;i<=2;i++)
 {
  for(int j=1;j<=2;j++)
  {
   cin >> A[i][j];
  }
 }
 cout << "\n Enter the second 2X2 matrix :\n";
 for(i=1;i<=2;i++)
 {
  for(int j=1;j<=2;j++)
  {
   cin >> B[i][j];
  }
 }
}
void Matrix :: Mult()
{
 int p,q,r,s,t,u,v;
 p=(A[1][1]+A[2][2])*(B[1][1]+B[2][2]);
 q=(A[2][1]+A[2][2])*B[1][1];
 r=A[1][1]*(B[1][2]-B[2][2]);
 s=A[2][2]*(B[2][1]-B[1][1]);
 t=(A[1][1]+A[1][2])*B[2][2];
 u=(A[2][1]-A[1][1])*(B[1][1]+B[1][2]);
 v=(A[1][2]-A[2][2])*(B[2][1]+B[2][2]);
 Result[1][1] = p+s-t+v;
 Result[1][2] = r+t;
 Result[2][1] = q+s;
 Result[2][2] = p+r-q+u;
}
void Matrix :: Put()
{
 cout << "\n Result is : \n";
 for(int i=1;i<=2;i++)
 {
  for(int j=1;j<=2;j++)
  {
   cout << "\t" << Result[i][j];
  }
  cout << "\n";
 }
}
void main()
{
 Matrix m;
 clrscr();
 m.Get();
 m.Mult();
 m.Put();
 getch();
}


6. Knapsack Problem :



//Progrm for find solution of knapsack instant.
#include<iostream.h>
#include<conio.h>
class Data
{
public:
 float p,w,x,Ratio;
 char Name;
};
class Knapsack
{
public:
 Data d[10];
 int m,n;
 void Show();
 void Get();
 Knapsack();
};
void Knapsack :: Get()
{
 cout <<"\n Size of Kanpsack : ";
 cin >> m;
 cout << "\n Enter the size : ";
 cin >> n;
 for(int i=1;i<=n;i++)
 {
  cout << "\n Enter the weight : ";
  cin >> d[i].w;
  cout << "\n Enter the profit : ";
  cin >> d[i].p;
  cout << "\n Enter the Name : ";
  cin >>d[i].Name;
  d[i].Ratio=d[i].p/d[i].w;
 }
}
Knapsack :: Knapsack()
{
 Get();
 for(int i=1;i<=n;i++)
 {
  for(int j=1;j<=n;j++)
  {
   if(d[i].Ratio > d[j].Ratio)
   {
    Data t = d[i];
    d[i]=d[j];
    d[j]=t;
   }
  }
 }
 for(i=1;i<=n;i++)
  d[i].x=0.0;
  int u=m;
 for(i=1;i<=n;i++)
 {
  if(d[i].w > u)
   break;
  d[i].x=1.0;
  u=u-d[i].w;
 }
 if(i<n)
 {
  d[i].x=u/d[i].w;
 }
 Show();
}
void Knapsack :: Show()
{
 cout << "\n================================================";
 cout << "\nName  Weight  Profit    Ratio          x\n";
 cout << "\n================================================\n";
 for(int i=1;i<=n;i++)
 cout <<d[i].Name<<"\t"<<d[i].w<<"\t"<<d[i].p<<"\t"<<d[i].Ratio<<"        "<<d[i].x<<"\n";
 float pf=0.0;
 for(i=1;i<=n;i++)
 {
  pf=pf+(d[i].p*d[i].x);
 }
 cout << "\n Total Profit : " << pf << endl;
}
void main()
{
 clrscr();
 Knapsack k;
 getch();
}




//0/1 knapsack by dynamic programming#include<conio.h>
#include<iostream.h>
#define max(a,b) (a > b ? a : b)
class knap
{
 int matrix[100][100];
 int item[100][100];
 int i,j,n,size,wt[10],val[10],Max,index;
 char name[10];
 public:
 knap()
 {
    for(i=0;i<100;i++)
  {
  for(j=0;j<100;j++)
  {
   matrix[i][j] = 0 ;
   item[i][j]=0;
  }
  }
 }
 void getdata();
 int knapsack(int index, int size, int weights[],int values[],char name[]);
 void display(int n, int size, int weights[],char name[]);
};
void knap::getdata()
{
 cout<<"\n Enter no of Items: " ;
 cin >> n;
 cout<<"\n Enter knapsack size:";
 cin>>size;
 cout<<"\n Enter weight:";
 for(i=0;i<n;i++)
 {
  cin>>wt[i];
 }
 cout<<"\n Enter Values:";
 for(j=0;j<n;j++)
 {
  cin>>val[j];
 }
 cout<<"\n Enter the Names:";
 for(i=0;i<n;i++)
 {
  cin>>name[i];
 }
  Max=knapsack(n-1,size,wt,val,name);
  cout<<"\n Max Profit is:"<<Max;
  cout<<"\n Items in the knapsack are:\n";
  display(n,size,wt,name);
  getch();
}
int knap::knapsack(int index, int size, int weights[],int values[],char name[])
{
    int take,dontTake;
    take = dontTake = 0;
    if (matrix[index][size]!=0)
    {
 return matrix[index][size];
    }
    if (index==0)
    {
 if (weights[0]<=size)
 {
     item[index][size]=1;
     matrix[index][size] = values[0];
     return values[0];
 }
 else
 {
     item[index][size]=-1;
     matrix[index][size] = 0;
     return 0;
 }
    }
    if (weights[index]<=size)
 take = values[index] + knapsack(index-1, size-weights[index], weights, values,name);
    dontTake = knapsack(index-1, size, weights, values,name);
    matrix[index][size] = max (take, dontTake);
    if(take>dontTake)
 item[index][size]=1;
    else
 item[index][size]=-1;
    return matrix[index][size];
}
void knap::display(int index, int size, int weights[], char name[])
{
    while(index>=0)
    {
 if(item[index][size]==1)
 {
  cout<<name[index];
  cout<<"\n";
  size-=weights[index];
  index--;
 }
 else
 {
  index--;
 }
    }
 return;
}
void main()
{
   knap k;
   k.getdata();
}
/****************************OUTPUT********************************
 Enter no of Items: 4
 Enter knapsack size:10
 Enter weight:
5 4 6 3
 Enter Values:
10 40 30 50
 Enter the Names:a b c d
 Max Profit is:90
 Items in the knapsack are:
d
b
*************************************************************************/


7.  Shortest Path


//All pairs shortest path algorithm
#include<iostream.h>
#include<conio.h>
class Allpath
{
 int cost[20][20],n;
 public:
  void get();
  void path();
  int min(int,int);
};
void Allpath::get()
{
 cout<<"\nEnter no. of vertices :";
 cin>>n;
 cout<<"\nEnter cost :";
 for(int i=1;i<=n;i++)
 {
  for(int j=1;j<=n;j++)
  {
   cin>>cost[i][j];
  }
 }
}
void Allpath::path()
{
 int A[20][20];
 for(int i=1;i<=n;i++)
 {
  for(int j=1;j<=n;j++)
  {
   A[i][j]=cost[i][j];
  }
 }
 for(int k=1;k<=n;k++)
 {
  for(int i=1;i<=n;i++)
  {
   for(int j=1;j<=n;j++)
   {
    A[i][j]=min(A[i][j],A[i][k]+A[k][j]);
   }
  }
  cout<<endl<<"A"<<k<<endl;
  for(i=1;i<=n;i++)
  {
  cout<<"\n";
  for(int j=1;j<=n;j++)
  {
   cout<<"\t";
   cout<<A[i][j];
  }
  }
 }
}
int Allpath::min(int a,int b)
{
 if(a>b)
  return b;
 else
  return a;
}
void main()
{
 clrscr();
 Allpath p;
 p.get();
 p.path();
 getch();
}
/*//////////////////////////////////////////////////////////////////////////////////////////
Enter no. of vertices :4
Enter cost :1 0 1 2
1 2 0 4
1 4 5 0
2 4 5 0
A1
 1       0       1       2
 1       1       0       3
 1       1       2       0
 2       2       3       0
A2
 1       0       0       2
 1       1       0       3
 1       1       1       0
 2       2       2       0
A3
 1       0       0       0
 1       1       0       0
 1       1       1       0
 2       2       2       0
A4
 1       0       0       0
 1       1       0       0
 1       1       1       0
 2       2       2       0

  */




// Program for Breadth First Traversal.
#include<iostream.h>
#include<conio.h>
class BFS
{
 int Matrix[10][10],n;
 int visited[10],Res[10];
 int q[10],Rear,Front;
public:
 void BFT();
 void Get();
 void Bfs(int);
};
void BFS :: BFT()
{
 for(int i=1;i<=n;i++)
  visited[i]=0;
 for(i=1;i<=n;i++)
  if(visited[i]==0)
   Bfs(i);
}
void BFS :: Get()
{
 Rear=Front=1;
 cout << "\n Enter the size of matrix : ";
 cin >> n;
 cout << "\n Enter the matrix : ";
 for(int i=1;i<=n;i++)
  for(int j=1;j<=n;j++)
   cin >> Matrix[i][j];
 for(i=1;i<=n;i++)
  visited[i]=0;
}
void BFS :: Bfs(int v)
{
 for(int i=1;i<=n;i++)
  visited[i]=0;
 int u=v;
 visited[v]=1;
 cout << v << "\t";
 do
 {
  for(int w=1;w<=n;w++)
  {
   if(Matrix[u][w] == 1)
   {
    if(visited[w]==0)
    {
     q[Rear++]=w;
     visited[w]=1;
     cout << w<<"\t";
    }
   }
  }
  if(Front == Rear)
   break;
  u=q[Front++];
 }while(1);
}
void main()
{
 clrscr();
 BFS b;
 b.Get();
 b.BFT();
 getch();
}





// Program for Depth First Traversal.
#include<iostream.h>
#include<conio.h>
class DFS
{
 int Matrix[10][10],n;
 int visited[10],Res[10];
public:
 void DFT();
 void Get();
 void Dfs(int);
};
void DFS :: DFT()
{
 for(int i=1;i<=n;i++)
  visited[i]=0;
 for(i=1;i<=n;i++)
  if(visited[i]==0)
   Dfs(i);
}
void DFS :: Get()
{
 cout << "\n Enter the size of matrix : ";
 cin >> n;
 cout << "\n Enter the matrix : ";
 for(int i=1;i<=n;i++)
  for(int j=1;j<=n;j++)
   cin >> Matrix[i][j];
      // for(i=1;i<=n;i++)
 // visited[i]=0;
}
void DFS :: Dfs(int v)
{
 visited[v]=1;
 cout << v << "\t";
 for(int w=1;w<=n;w++)
 {
  if(Matrix[v][w]==1)
  {
   if(visited[w]==0)
   {
    Dfs(w);
   }
  }
 }
}
void main()
{
 clrscr();
 DFS d;
 d.Get();
 d.DFT();
 getch();
}