PRIM'S ALGORITHM TO FIND MINIMUM SPANNING TREE

#include<stdio.h>
#define max 25
int g[max][max],v[max],n,sum;
void prims(int s);
int main(){
int s;
sum=0;
printf("enter number of vertices\n");
scanf("%d",&n);
printf("enter adjacent matrix\n");
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
scanf("%d",&g[i][j]);
}}
prims(0);
printf("min cost req is:%d\n",sum);
return 0;
}
void prims(int s){
int i,j,m=9999,k,m1,l;
v[s]=1;
m1++;
do{
for(i=0;i<n;i++){
m=9999;
if(v[i]==1){
for(j=0;j<n;j++){
if((g[i][j]!=0)&&(m>=g[i][j])&&v[j]!=1)
{
m=g[i][j];
k=i;
l=j;}
}
}}
printf("edge:%d--->%d\n",k,l);
printf("visited:%d",v[l]);
sum+=g[k][l];
v[l]=1; m1++;}while(m1!=n);
return;
}

SINGLE SOURCE SHORTEST PATH PROBLEM(DIJKSTRA'S ALGORITHM) 'C' PROGRAM

1. #include<stdio.h>
2. #include<limits.h>
3. int n;
4. int adj[10][10],vi[10];
5. int dist[10];
6. void shortest(int v);
7. int min();
8. int main(){
9. int i,j,s;
10. printf("enter number of vertices\n");
11. scanf("%d",&n);
12. for(i=1;i<=n;i++){
13. dist[i]=INT_MAX;
14. printf("%d\t",dist[i]);
15. }
16. printf("enter adjacency matrix\n");
17. for(i=1;i<=n;i++)
18. for(j=1;j<=n;j++)
19. scanf("%d",&adj[i][j]);
20. printf("enter source vertex to start\n");
21. scanf("%d",&s);
22. shortest(s);
23. printf("shortest distances from vertex %d are\n",s);
24. for(i=1;i<=n;i++){
25. if(dist[i]<INT_MAX&&vi[i]==1)
26. printf("cost:%d\tedge:(%d,%d)\n",dist[i],s,i);
27. }
28. return 0;
29. }
30.  void shortest(int v){
31. int i,j,u;
32. for(i=1;i<=n;i++){
33. vi[i]=-1;
34. if(adj[v][i]!=0)
35. dist[i]=adj[v][i];
36. }
37. vi[v]=1;
38. for(j=2;j<=n;j++){
39. u=min();
40. printf("%d\n",u);
41. vi[u]=1;
42. for(i=1;i<=n;i++){
43. if((adj[u][i]!=0)&&(dist[i]>(dist[u]+adj[u][i]))&&(vi[i]==-1)){
44. dist[i]=(dist[u]+adj[u][i]);
45. }
46. }
47. }
48. return;
49. }
50. int min(){
51.  int i,t=dist[1],j;
52. for(i=1;i<=n;i++){
53. if((dist[i]<t)&&(vi[i]==-1))
54. {
55. t=dist[i];
56. }}
57. for(j=1;j<=n;j++){
58. if(t==dist[j]&&vi[j]==-1)
59. break;}
60. return j;
61. }

QUICK SORT -'C' PROGRAM

#include<stdio.h>
#include<limits.h>
#define max 25
int arr[max];
int partition(int arr[],int l,int h);
void quick(int l,int h);
int main(){
int n;
printf("enter num: \n");
scanf("%d",&n);
printf("enter array elements\n");
for(int i=0;i<n;i++){
scanf("%d",&arr[i]);
}
arr[n]=INT_MAX;
quick(0,n);
printf("elements after sorting are\n");
for(int i=0;i<n;i++)
printf("%d\t",arr[i]);
}
int partition(int arr[],int l,int h)
{
int v=arr[l],i=l,j=h,temp;
do{
do{
i=i+1;
}while(arr[i]<v);
do{
j=j-1;
}while(arr[j]>v);
if (i<j)
{
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}while(i<j);
arr[l]=arr[j];arr[j]=v;
return j;
}
void quick(int l,int h){
int j;
if(l<h)
{
j=partition(arr,l,h);
quick(l,j);
quick(j+1,h);
}
}

C PROGRAM DEMONSTRATING ALL TREE TRAVERSALS RECURSIVELY AND NON RECURSIVELY

#include<stdio.h>
#include<stdlib.h>
struct Tnode{
 struct Tnode*pleft;
 struct Tnode*pright;
int ch;
};
struct Tnode *stack[50];
struct Tnode *stack1[50];
int top,top1;
void push(struct Tnode* ch1);
struct Tnode* pop();
void push1(struct Tnode *ch1);
struct Tnode *pop1();
struct Tnode*root;
struct Tnode*create_node(int c);
void create();
void insert(int c);
void non_preorder();
void non_postorder();
void non_inorder();
void inorder(struct Tnode *rot);
void preorder(struct Tnode *rot);
void postorder(struct Tnode *rot);
//main function
int main(){
top=-1;root=NULL;top1=-1;
create();
printf("RECURSIVE INORDER TRAVERSAL IS:\n");
inorder(root);
printf("\n");
printf("RECURSIVE PREORDER TRAVERSAL IS:\n");
preorder(root);
printf("\n");
printf("RECURSIVE POSTORDER TRAVERSAL IS:\n");
postorder(root);
printf("\n");
non_preorder();
printf("\n");
non_postorder();
printf("\n");
non_inorder();
 return 0;}

struct Tnode*create_node(int c){
 struct Tnode*pnew=(struct Tnode*)malloc(sizeof(struct Tnode));
 if(pnew){
 pnew->ch=c;
 pnew->pleft=NULL;
  pnew->pright=NULL;}
 return pnew;}
 void insert(int c){
  struct Tnode *pnew,*ptrav,*pa;
  pnew=create_node(c);
  if(!pnew) printf("no memeory\n");
  else{
   if(!root)
   root=pnew;
   else{
    pa=root;ptrav=root;
    while(ptrav){
     pa=ptrav;
     if(c<(ptrav->ch)){
     ptrav=ptrav->pleft;}
     else{
     ptrav=ptrav->pright;}}
    if(c<(pa->ch)){
    pa->pleft=pnew;}
    else{
    pa->pright=pnew;}}return;}}
 void create(){
 int k;
  int i,n;
  printf("enter number of values\n");scanf("%d",&n);
  for(i=0;i<n;i++) {
  scanf("%d",&k);
  insert(k);
  }}
 void push(struct Tnode *ch1){
  top++;
  stack[top]=ch1;
  return;
 }
struct Tnode *pop(){
  struct Tnode* k;
  if(top<0){
  k=NULL;return k ;}
  else
  {

    k=stack[top];
   top--;
   return k;
  }
 }
   void push1(struct Tnode *ch1){//thi function is for stack1 operations
  top1++;
  stack1[top1]=ch1;
  return;
 }//push1 end

struct Tnode *pop1(){
  struct Tnode* k;
  if(top1<0){
  k=NULL;return k ;}
  else
  {
    k=stack1[top1];
   top1--;
   return k;
  }}
//RECURSIVE FUNCTIONS
 void inorder(struct Tnode *rot){
  if(rot){
 inorder(rot->pleft);
   printf("%d\t",rot->ch);
   inorder(rot->pright);}
  }

   void preorder(struct Tnode *rot){
  if(rot){
  printf("%d\t",rot->ch);
  preorder(rot->pleft);
  preorder(rot->pright);}
  }

   void postorder(struct Tnode *rot){
  if(rot){
  postorder(rot->pleft);
   postorder(rot->pright);
   printf("%d\t",rot->ch);}
  }
//NON RECURSIVE FUNCTIONS
void non_preorder(){
char l; 
int done=0;
struct Tnode *ptemp=NULL,*ptr=root;
push(ptr);
if(!root){printf("empty tree\n");
}else{
 printf("NON RECURSIVE PREORDER IS:\n");
 while(top>=0){
ptr=pop(); 
   printf("%d\t",ptr->ch);
 if((ptr->pright)!=NULL){
 ptemp=ptr->pright;
 push(ptemp);}
 if((ptr->pleft)!=NULL){
 ptemp=ptr->pleft;
 push(ptemp);
}
}
}}

void non_postorder(){
char l; 
int done=0;
struct Tnode *ptemp=NULL,*ptr=root;
push(ptr);
if(!root){printf("empty tree\n");
}else{
 printf("NON RECURSIVE POST ORDER:\n");
 while(top>=0){
          ptr=pop();
  push1(ptr);
 if((ptr->pleft)!=NULL){
 ptemp=ptr->pleft;
 push(ptemp);}
 if((ptr->pright)!=NULL){
 ptemp=ptr->pright;
 push(ptemp);}
}
}
while(top1>=0){
 ptemp=pop1();
 printf("%d\t",ptemp->ch);
}
}

void non_inorder(){
struct Tnode *ptemp=NULL,*ptr=root;
if(!root){printf("empty tree\n");
}else{
push(ptr);
 printf("NON RECURSIVE IN ORDER IS:\n");
 while(top>=0){
  if((ptr->pleft)!=NULL){
 ptr=ptr->pleft;
 push(ptr);
}
 else{
ptemp=pop();
  printf("%d\t",ptemp->ch);
  if(ptemp->pright!=NULL){
  ptr=ptemp->pright;
  push(ptr);
 }}
}
}
}

C PROGRAM FOR BINARY SEARCH USING RECURSION

#include<stdio.h>
void bin(int l,int h,int arr[],int s);
int main()
{
int s,i,k,arr[10]={0};
printf("enter array elements\n");
for(i=0;i<5;i++)
scanf("%d",&arr[i]);
printf("enter element to search\n");
scanf("%d",&s);
bin(0,4,arr,s);//CALL TO RECURSIVE FUN
return 0;
}
void bin(int l,int h,int arr[],int s){
int m;
if(l<=h){
m=(l+h)/2;
if(arr[m]==s){
printf("element found at %d",m+1);
}
else if(s<arr[m]){
 bin( l,m-1,arr,s);//RECURSIVE CALLS
}
else 
 bin( m+1,h,arr,s);}
else
printf("element not found\n");
return;
}

GAUSS SEIDEL METHOD USING C PROGRAM

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
int main()
{
int n,i,j,k,s=1;
printf("enter number of variales");
scanf("%d",&n);
float a[n][n];
float  b[n];
float x[n]={0},var,itr,temp,temp1;
printf("enter approx");
scanf("%f",&itr);
for(i=0;i<n;i++)
{
printf("enter element at b[%d]",i);
scanf("%f",&b[i]);

for(j=0;j<n;j++)
{
printf("enter element at a[%d][%d]",i,j);
scanf("%f",&a[i][j]);
}
}
do
{
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(i!=j)
{
var+=a[i][j]*x[j];
}
}
temp1=(1/a[i][i])*(b[i]-var);
var=0;
printf("initial %f\n",x[i]);
temp=fabs(temp1-x[i]);
x[i]=temp1;
temp1=0;
}
}while((temp>itr));

for(i=0;i<n;i++)
{
printf(" x%d=%f\t",i,x[i]);
}

return 0;
}

GAUSS JACOBI METHOD USING C PROGRAM

//gauss jacobi
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
int main()
{
int n,i,j,k,s=1;
printf("enter number of variales");
scanf("%d",&n);
float a[n][n];
float  b[n];
float x[n]={0},x1[n]={0},var,itr,temp,temp1;
printf("enter approx");
scanf("%f",&itr);
for(i=0;i<n;i++)
{
printf("enter element at b[%d]",i);
scanf("%f",&b[i]);

for(j=0;j<n;j++)
{
printf("enter element at a[%d][%d]",i,j);
scanf("%f",&a[i][j]);
}
}
do
{
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(i!=j)
{
var+=a[i][j]*x1[j];
}
}
x[i]=(1/a[i][i])*(b[i]-var);
var=0;
printf("initial %f\n",x[i]);
temp=fabs(x[i]-x1[i]);
}
for(i=0;i<n;i++)
{
x1[i]=x[i];
}
}while((temp>itr));
for(i=0;i<n;i++)
{
printf(" x%d=%f\t",i,x[i]);
}

return 0;
}

EULER MODIFIED METHOD USING C PROGRAM

#include<stdio.h>
#include<math.h>
float fun(float x,float y)
{
float f;
f=x*x+y;
return f;
}
int main()
{
float diff,y0,y,x0,x1,h,xn,y1,y2;
printf("enter x0,y0,h,xn\n");
scanf("%f%f%f%f",&x0,&y0,&h,&xn);
do
{
  y=y0+h*(fun(x0,y0));
  x1=x0+h;
  do
  {
  y2=y;
  y1=y0+(h/2)*(fun(x0,y0)+fun(x1,y));
  y=y1;
  diff=y1-y2;
  //printf("%f\n",y1-y2);
  }while(fabs(diff)>0.000001);
  y0=y1;
  x0=x0+h;
  printf("x=%f \t y=%f\n",x0,y1);
}while(x0<xn);
return 0;

}

RANGE KUTTA METHOD USING C PROGRAM

#include<stdio.h>
#include<math.h>
float fun(float x,float y)
{
float f;
f=x+(y*y);
return f;
}
int main()
{
float x0,y0,xn,h,y,k1,k2,k3,k4,k,x;
printf("enter x0,y0,h,xn\n");
scanf("%f%f%f%f",&x,&y,&h,&xn);
do
{
k1=h*fun(x,y);
k2=h*fun(x+h/2,y+(k1/2));
k3=h*fun(x+h/2,y+(k2/2));
k4=h*fun(x+h,y+k3);
k=(1/6)*(k1+2*(k2+k3)+k4);
y0=y+k;
printf("%f\n",y);
x=x+h;
y=y0;
}while(x<xn);

return 0;

}

C PROGRAM FOR NON RECURSIVE PREORDER TRAVERSAL

#include<stdio.h>
#include<stdlib.h>
struct Tnode{
struct Tnode*pleft;
struct Tnode*pright;char ch;
};
struct Tnode *stack[50];
int top;
void push(struct Tnode* ch1);
struct Tnode* pop();
struct Tnode*root;
struct Tnode*create_node(char c);
void create();
void insert(char c);
void print();
//main function
int main(){
top=-1;root=NULL;
create();
printf("\n");
print();
return 0;}

struct Tnode*create_node(char c){
struct Tnode*pnew=(struct Tnode*)malloc(sizeof(struct Tnode));
if(pnew){
pnew->ch=c;
pnew->pleft=NULL;
pnew->pright=NULL;}
return pnew;}
void insert(char c){
struct Tnode *pnew,*ptrav,*pa;
pnew=create_node(c);
if(!pnew) printf("no memeory\n");
else{
if(!root)
root=pnew;
else{
pa=root;ptrav=root;
while(ptrav){
pa=ptrav;
if(c<(ptrav->ch)){
ptrav=ptrav->pleft;}
else{
ptrav=ptrav->pright;}}
if(c<(pa->ch)){
pa->pleft=pnew;}
else{
pa->pright=pnew;}}return;}}
void create(){
char k,f;
int i,n;
printf("enter number of characters\n");scanf("%d",&n);
for(i=0;i<n;i++) {
scanf("%c",&f);
scanf("%c",&k);
insert(k);
}}
void push(struct Tnode *ch1){
top++;
stack[top]=ch1;
return;
}
struct Tnode *pop(){
struct Tnode* k;
if(top<0){
k=NULL;return k ;}
else
{

k=stack[top];
top--;
return k;
}
}
void print(){
char l;
int done=0;
struct Tnode *ptemp=NULL,*ptr=root;
push(ptr);
if(!root){printf("empty tree\n");
}else{
printf("NON Recursive:\n");
while(top>=0){
// ptemp=ptr;
          ptr=pop();
printf("%c",ptr->ch);
 if((ptr->pright)!=NULL){
ptemp=ptr->pright;
// printf("%c",ptr->ch);
push(ptemp);}
if((ptr->pleft)!=NULL){
ptemp=ptr->pleft;
// printf("%c",ptr->ch);
push(ptemp);
}
}
}}

POLYNOMIAL ADDITION USING LINKED LIST IN C

#include <stdio.h>
#include <stdlib.h>
struct Node{
int co,po;
struct Node*plink;
};
struct head{
struct Node*pfirst;
};
struct head *pl1,*pl2,*pl3;
void createlist(struct head*);
struct Node* create();
struct Node* mem(int,int);
void disp(struct head *);
void insert(struct head*,struct Node*);
void Add(struct head*,struct head*,struct head*);
int main() {
pl1=(struct head*)malloc(sizeof(struct head));
pl1->pfirst=NULL;
pl2=(struct head*)malloc(sizeof(struct head));
pl2->pfirst=NULL;
pl3=(struct head*)malloc(sizeof(struct head));
pl3->pfirst=NULL;
if(pl1&&pl2&&pl3){
printf("  enter poly exp1:\n");
createlist(pl1);
printf("  enter poly exp2:\n");
createlist(pl2);
printf("poly 1:\n");
disp(pl1);
printf("\n");
printf("poly 2:\n");
disp(pl2);
printf("\n");
Add(pl1,pl2,pl3);
printf("poly exp after adding is\n");
disp(pl3);

}
return 0;
}
struct Node* create(){
struct Node* ptemp=(struct Node*)malloc(sizeof(struct Node));
if(!ptemp) return NULL;
else{
printf("enter Coefficient,power\n");scanf("%d%d",&(ptemp->co),&(ptemp->po));ptemp->plink=NULL;return ptemp;
}
}
void createlist(struct head*ptr){struct Node* ptemp=NULL;
int i,n=0;
printf("enter highest power of expression\n");
scanf("%d",&n);for(i=0;i<=n;i++)
{
ptemp=create();
insert(ptr,ptemp);
}
return;}
void insert(struct head*ptr1,struct Node*p1)
{
if(!p1){
printf("no memory \n");
return;
}
else{
struct Node *ptemp1=NULL;
if(!(ptr1->pfirst)){
ptr1->pfirst=p1;
}
else
{
ptemp1=ptr1->pfirst;
while(ptemp1->plink)
ptemp1=ptemp1->plink;
ptemp1->plink=p1;
}
return;
}
}
struct Node* mem(int c,int p){
struct Node* ptr=(struct Node*)malloc(sizeof(struct Node));
if(!ptr)
return NULL;
else{
ptr->co=c;
ptr->po=p;ptr->plink=NULL;return ptr;
}}
void disp(struct head*ptr2){
struct Node*ptemp=NULL;
if(!ptr2->pfirst){
printf("empty polynomial\n");return;
}
else{
int i=0;
ptemp=ptr2->pfirst;
do{
if(((ptemp->co)>0)&&i!=0){
printf("+");
}
printf("%dx^%d",ptemp->co,ptemp->po);
ptemp=ptemp->plink;
i++;
}while(ptemp);
}
return;
}
void Add(struct head*pt1,struct head*pt2,struct head*pt3){
struct Node *ptl1=NULL,*ptl2=NULL,*ptl3=NULL;
ptl1=pt1->pfirst; ptl2=pt2->pfirst;
int a;
while((ptl1)&&(ptl2)){
if((ptl1->po)>(ptl2->po)){
ptl3=mem(ptl1->po,ptl1->co);
ptl1=ptl1->plink;
insert(pt3,ptl3);
}
else if((ptl2->po)>(ptl1->po)){
ptl3=mem(ptl2->po,ptl2->co);
ptl2=ptl2->plink;
insert(pt3,ptl3);
}
else{
a=(ptl1->co)+(ptl2->co);
ptl3=mem(a,ptl1->po);
ptl1=ptl1->plink; ptl2=ptl2->plink;insert(pt3,ptl3);
}
}
while(ptl1){
ptl3=mem(ptl1->po,ptl1->co);
ptl1=ptl1->plink;
insert(pt3,ptl3);
}
while(ptl2){
ptl3=mem(ptl2->po,ptl2->co);
ptl2=ptl2->plink;
insert(pt3,ptl3);
}
return;
} 🔜