Warshall and Warshall Floyd Algorithm C++ code

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;
int main()
{
    int n,i,j,k,m,p;
    cout<<"\nEnter the number of nodes:";
    cin>>n;
    fflush(stdin);
    char name[n][3],ch;
    int recon[n][n];
    int adj[n][n],path[n][n];
    for(i=0;i<n;i++)
   {
     cout<<"\n\a\aEnter the name on node:";
     cin>>name[i];
    for(j=0;j<n;j++)
    {
         fflush(stdin);
         cout<<"\n\nEnter element at position ("<<i+1<<","<<j+1<<") : ";
         cin>>adj[i][j];
         if(i!=j)
         {cout<<"\n\nIs this path direct?(Y/N):";
         cin>>ch;}
         else
         ch='n';
         if(ch=='y' || ch=='Y')
         recon[i][j]=i+1;
         else
         recon[i][j]=0;
         path[i][j]=adj[i][j];
    }
   }
    system("cls");
    cout<<"\nThe adjacency matrix::\n\n";
    cout<<" ";
    for(i=0;i<n;i++)
    {
        cout<<"  ";
        cout<<name[i];
    }
    cout<<endl;
    for(i=0;i<n;i++)
    {
        cout<<name[i]<<" ";
        for(j=0;j<n;j++)
        {
           cout<<adj[i][j];
           cout<<"   ";
        }
        cout<<endl;
    }
cout<<"\nEnter:\n1:Warshall's Law\n2:Warshall Floyd law\nYour choice:";
cin>>i;
system("cls");
if(i==1)
{
    for(k=0;k<n;k++)
    {
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                if(path[i][k]*path[k][j]==1)
                path[i][j]=1;
            }
        }
       if(k!=n-1)
       cout<<"\n\nAfter pass "<<k+1<<" for k="<<k<<" the intermediate path matrix::\n\n";
       else
       cout<<"\n\nFinal Path matrix::\n\n";
       cout<<" ";
    for(m=0;m<n;m++)
    {

        cout<<"  ";
        cout<<name[m];
    }
    cout<<endl;
    for(m=0;m<n;m++)
    {
        cout<<name[m]<<" ";
        for(p=0;p<n;p++)
        {
           cout<<path[m][p];
           cout<<"   ";
        }
        cout<<endl;
    }
    }
}
else if(i==2)
{
     for(k=0;k<n;k++)
    {
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                if((path[i][k]+path[k][j])<path[i][j])
               {
                path[i][j]=path[i][k]+path[k][j];
                recon[i][j]=recon[k][j];
               }
            }
        }
       if(k!=n-1)
       cout<<"\n\nAfter pass "<<k+1<<" for k="<<k<<" the intermediate path matrix::\n\n";
       else
       cout<<"\n\nFinal Path matrix::\n\n";
       cout<<" ";
    for(m=0;m<n;m++)
    {

        cout<<"  ";
        cout<<name[m];
    }
    cout<<endl;
    for(m=0;m<n;m++)
    {
        cout<<name[m]<<" ";
        for(p=0;p<n;p++)
        {
           cout<<path[m][p];
           cout<<"   ";
        }
        cout<<endl;
    }
    }
    //*******************************************************
       cout<<"\a\a\n\n\nReconstructed Path matrix::\n\n";
       cout<<" ";
    for(m=0;m<n;m++)
    {

        cout<<"  ";
        cout<<name[m];
    }
    cout<<endl;
    for(m=0;m<n;m++)
    {
        cout<<name[m]<<" ";
        for(p=0;p<n;p++)
        {
           cout<<recon[m][p];
           cout<<"   ";
        }
        cout<<endl;
    }
}
else
cout<<"\a\a\nWrong call!!";
return 0;
}

Selection sort Algorithm C++ code

#include<iostream>
#include<stdlib.h>
using namespace std;
#include<conio.h>

int main()
{                char c='y';
                 while(c=='y' || c=='Y')
                 {
                 int a[20],j,count,n,temp;
                 cout<<"\nEnter number of elements to enter:";
                 cin>>n;
                 cout<<"\nEnter the elements:";
                 for(int i=0;i<n;i++)
                 {
                 cout<<endl;
                 cin>>a[i];
                 }
                 for(int i=0;i<n-1;i++)
                 {cout<<endl<<"****"<<endl;
                         count=0;
                         for(j=1;j<n-i;j++)
                         if(a[j]>a[count])
                         count=j;

                        swap(a[count],a[j-1]);//default swap function working in code blocks IDE or just change the code for explicit swapping
                          cout<<"\nAfter pass "<<i+1<<": ";
                          for(int i=0;i<n;i++)
                          cout<<a[i]<<"  ";
                 }
                cout<<"\n\n******\n\nFinal Sorted array is:";
                 for(int i=0;i<n;i++)
                 cout<<"  "<<a[i];
                 cout<<"\n\nWant to continue?(Y/N): ";
                 cin>>c;
                 system("cls");
                 }

}

Quick Sort Algorithm C++ code

#include<iostream>
using namespace std;
//#include<conio.h>
int quicksort (int[],int,int);
int pos;
int main()
{
    int ar[7],pivot,last;
    cout<<"\n Enter the 7 elts in array:"<<endl;
    for(int i=0;i<7;i++)
        cin>>ar[i];
        quicksort(ar,0,7);
        cout<<"\n*************************Sorted array*****************************\n\n";
        for(int i=0;i<7;i++)
        cout<<"\t"<<ar[i];
//        getch();
}

 int quicksort(int ar[],int pivot,int last)
{
    int pos=pivot;

    if(ar[pivot]==ar[last])
    return 0;

    else
    {
    for(int i=pivot+1;i<last;i++)
        if(ar[i]<ar[pivot])
        {
            int temp;
            temp=ar[i];
            int j=i;
            while(j--!=pos)
            {
                ar[j+1]=ar[j];
            }
             ar[j+1]=temp;
             pos++;
        }
        quicksort(ar,pivot,pos);
        quicksort(ar,pos+1,7);
    }
}

Minimum Spanning Tree Prim's Algorithm C++ code

#define INFINITY 0
#define MAXEDGE 15
#include<iostream>
#include<stdlib.h>
#include<stdio.h>
void node(int i);
using namespace std;
int n,y=-1,arr[10];
struct group
{
   char name;
   int use;
}ob[MAXEDGE];
int main()
{
    int i,j,d,c1,c2,minimum,x,cnt;
    cout<<"\nEnter the number of nodes:";
    cin>>n;
    fflush(stdin);
    int adj[n][n];
    for(i=0;i<n;i++)
   {
    cout<<"\n\a\aEnter the name on node:";
    cin>>ob[i].name;
    ob[i].use=0;
    for(j=0;j<n;j++)
    {
         fflush(stdin);
         cout<<"\n\nEnter cost at position ("<<i+1<<","<<j+1<<") : ";
         cin>>adj[i][j];
    }
   }
    system("cls");
    cout<<"\nThe adjacency matrix::\n\n";
    cout<<" ";
    for(i=0;i<n;i++)
    {
        cout<<"  ";
        cout<<ob[i].name;
    }
    cout<<endl;
    for(i=0;i<n;i++)
    {
        cout<<ob[i].name<<" ";
        for(j=0;j<n;j++)
        {
           cout<<adj[i][j];
           cout<<"   ";
        }
        cout<<endl;
    }
cout<<"\n\n";
system("pause");
system("cls");
//DISPLAYDISPLAYDISPLAYDISPLAYDISPLAYDISPLAYDISPLAYDISPLAYDISPLAYDISPLAYDISPLAYDISPLAYDISPLAYDISPLAY
cout<<"MST vertex set          partial MST set                 chosen edge\n\n";
node(0);
for(i=0;i<n-1;i++)
{
    d=0;
    cnt=0;
    for(int q=0;q<23-(2*(i+1));q++)
    cout<<" ";
    for(x=0;x<=y;x++)
    for(j=0;j<n;j++)
    {
        if(adj[arr[x]][j]!=INFINITY && (ob[arr[x]].use==0 || ob[j].use==0))
        {
            if(d++==0)
            {
            minimum=adj[arr[x]][j];
            c1=arr[x];
            c2=j;
            }
            cout<<"("<<ob[arr[x]].name<<","<<ob[j].name<<")"<<",";
            cnt++;
            if(adj[arr[x]][j]<minimum)
            {
                minimum=adj[arr[x]][j];
                c1=arr[x];
                c2=j;
            }
        }
    }
    for(int q=0;q<32-(6*cnt);q++)
    cout<<" ";
    cout<<"("<<ob[c1].name<<","<<ob[c2].name<<")";
    node(c2);
}
return 0;
}
void node(int i)
{
    arr[++y]=i;
    ob[i].use=1;
    cout<<"\n\n{";
    for(int j=0;j<=y;j++)
    {
        cout<<ob[arr[j]].name;
        if(j!=y)
        cout<<",";
    }
    cout<<"}";
}

Conversion to Postfix or Reverse-Polish notation of the given Infix expression (general expression) C++ code

#include<iostream>
using namespace std;
#include<conio.h>

char stack[30];
int main()
{
    char a[30],ch='y',ar[30];
    void pop(char d);
 
    while(ch=='y' || ch=='Y')
    {
    int j=-1,i=0,m=0,b=-1;
    cout<<"\n"<<"Enter the infix expression with brackets:";
    cin>>a;
//*****************************
while(a[++j]!='\0')
    {
    if(a[j]=='(' || a[j]==')')
    ar[i++]=a[j];
    }
    for(int m=0;m<i-1;m++)
    {
             if(ar[m]=='(')
             ++b;
             else if(ar[m]==')')
             --b;
    }
    j=0;i=0;m=0;
//******************************

 if(b==0)
 {
    cout<<"\n"<<"Postfix expression:";
        while(a[i]!='\0')
    {
                     if(a[i]=='(')
                     {
                     stack[j++]='(';
                     }
                   
                   
                     else if((a[i]>64 && a[i]<91) || (a[i]>96 && a[i]<123))
                     {
                          pop(a[i]);
                     }
                   
                   
                     else if(a[i]=='+' || a[i]=='-')
                     {
                     if(stack[j-1]==40)
                     stack[j++]=a[i];
                     else
                     {
                     while(stack[j-1]!=40)
                     {
                     pop(stack[--j]);
                    // j--;
                     }
                     stack[j++]=a[i];
                     }
                     }
                   
                   
                     else if(a[i]=='*')
                     {
                     if(stack[j-1]>45 || stack[j-1]==37)
                     {
                     while(stack[j-1]!=40)
                     {
                     pop(stack[--j]);
                     //j--;
                     }
                     stack[j++]=a[i];
                     }
                     else
                     stack[j++]=a[i];
                     }
                   
                   
                   
                     else if(a[i]=='^')
                     {
                     if(stack[j-1]<94 && stack[j-1]!=40)
                     {
                     while(stack[j-1]!=40)
                     {
                     pop(stack[--j]);
                     //j--;
                     }
                     stack[j++]=a[i];
                     }
                     else
                     stack[j++]=a[i];
                     }
                   
                   
                     else if(a[i]=='/')
                     {
                     if(stack[j-1]>47 || stack[j-1]==42 || stack[j-1]==37)
                     {
                     while(stack[j-1]!=40)
                     {
                     pop(stack[--j]);
                     //j--;
                     }
                     stack[j++]=a[i];
                     }
                     else
                     stack[j++]=a[i];
                     }
                   
                   
                     else if(a[i]=='%')
                     {
                     if(stack[j-1]>37 && stack[j-1]!=43 && stack[j-1]!=45)
                     {
                     while(stack[j-1]!=40)
                     {
                     pop(stack[--j]);
                     //j--;
                     }
                     stack[j++]=a[i];
                     }
                     else
                     stack[j++]=a[i];
                     }
                   
                   
                     else if(a[i]==41)
                     {
                     if(stack[j-1]!=40)
                     {
                     cout<<stack[--j];
                     if(stack[j-1]==40)
                     j--;
                     }
                     while(stack[j]!=40)
                     if(stack[--j]!=40)
                     cout<<stack[j];
                   
                     }
                     i++;
                   
    }
}
else
cout<<"\nBrackets are not properly open or closed...Please check!";
cout<<"\n\nWant to Re-enter the Infix expression (Y/N)?:";
cin>>ch;

system("cls");
}
}
void pop(char a)
{
     if(a!=40)
     cout<<a;
}
   

                   
                   

Operating Systems Page Replacement Algorithm FIFO, LRU and Optimal C code

#include<stdio.h>
int main()
{

    int data[15],page[6],n,s,c,hit=0,i,j,index=0,cnt,k,arr[5],entry,x;
    printf("\nEnter the frame size:");
    scanf("%d",&n);
    printf("\nEnter the string size:");
    scanf("%d",&s);
    printf("\nEnter the data bits:>");
    for(i=0;i<s;i++)
    {
        printf("\nEnter data %d:",i+1);
        scanf("%d",&data[i]);
    }
    for(i=0;i<n;i++)
    {
        page[i]=999;
    }
//FIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFO
     printf("\n**************FIFO******************");
    for(i=0;i<s;i++)
    {
        c=0;
        if(index==0)
        index=n;
        for(j=0;j<n;j++)
        {
            if(page[j]==data[i])
            {
                c++;
                break;
            }
        }
        if(c==1)
        hit++;
        else
        page[n-index--]=data[i];
    }
    printf("\nPage Fault=%d\n",s-hit);
    printf("\nHit ratio=%f\n",hit/(float)s);
////FIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFOFIFO
////LRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRU
hit=0;
printf("\n**************LRU******************");
    for(i=0;i<n;i++)
    {
        page[i]=999;
    }
    index=0;
    for(i=0;i<s;i++)
    {
        cnt=0;
        c=0;
        for(j=0;j<n;j++)
        {
            if(page[j]==data[i])
            {
                c++;
                break;
            }
        }
        if(c==1)
        hit++;
        else
        {
            if(index<n)
            page[index++]=data[i];
            else
            {
              for(j=i-n;j>0;j--)
              {
                  for(k=j+1;k<i;k++)
                  {
                      if(data[j]==data[k])
                      cnt++;
                  }
                  j=cnt==0?j:(j-cnt+1);
                      for(k=0;k<n;k++)
                      {
                          if(data[j]==page[k])
                          {page[k]=data[i];break;}
                      }
              }
            }
        }

    }
    printf("\nPage Fault=%d\n",s-hit);
    printf("\nHit ratio=%f\n",hit/(float)s);
//LRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRULRU
//OPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMAL
index=0;
hit=0;
printf("\n**************OPTIMAL******************");
 for(i=0;i<n;i++)
    {
        page[i]=999;
    }
for(i=0;i<s;i++)
{
    c=0;
    cnt=0;
   for(j=0;j<n;j++)
        {
            if(page[j]==data[i])
            {
                c++;
                break;
            }
        }
        if(c==1)
        hit++;
        else
        {
            if(index<n)
            page[index++]=data[i];
            else
            {
                entry=0;
                x=0;
                for(k=i+1;k<s;k++)
                {
                    if(cnt==n)
                    break;
                    for(j=0;j<n;j++)
                    {
                        if(data[k]==page[j])
                        {
                            if(cnt++==0)
                            arr[cnt-1]=k;
                            else
                            {
                                for(x=0;x<cnt;x++)
                                {
                                    if(data[arr[x]]==data[k])
                                    entry++;
                                }
                                if(entry==0)
                                {arr[cnt++]=k;}
                            }
                        break;
                        }
                    }
                }
                if(cnt==n)
                page[cnt]=data[i];
                else
                page[0]=data[i];
            }
        }
}
printf("\nPage Fault=%d\n",s-hit);
printf("\nHit ratio=%f\n",hit/(float)s);
//OPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMALOPTIMAL
return 0;
}

Operating Systems Memory allocation methods First Fit,Best Fit and Worst Fit C code

#include<stdio.h>
int main()
{

    int arr[10]={5,6,7,4,9,8,2,3,1,4};//input memory block size;change as per your requirement
int i,j,n,bs,cnt=0,m=0,temp;
    printf("\nEnter:\n1:First Fit\n2:Best Fit\n3:Worst Fit\n4:Exit\nYour Choice:");
    scanf("%d",&n);
    printf("\n*************************\n");
        for(i=0;i<10;i++)
        printf("|%d| ",arr[i]);
        printf("\n*************************\n");
    while(n!=4)
    {

    if(n==1)
    {
        printf("\nEnter the block size:");
        scanf("%d",&bs);
        cnt=0;
        while(++cnt!=10)
        {
            if(arr[cnt-1]!=999 && arr[cnt-1]>=bs)
            {
                break;
            }
        }
        if(cnt<10){
        if(arr[cnt-1]>bs){
        printf("\nSize of block allocated=%d",bs);
        arr[cnt-1]-=bs;}
        else{
        printf("\nSize of block allocated=%d",arr[cnt-1]);
        arr[cnt-1]=999;}
        }
        else
        printf("\nNo memory blocks available!!\n");
        printf("\n*************************\n");
        for(i=0;i<10;i++)
        printf("|%d| ",arr[i]);
        printf("\n*************************\n");

    }
    else if(n==2)
    {
        printf("\nEnter the block size:");
        scanf("%d",&bs);
        cnt=0;
        m=0;
        while(++cnt!=11)
        {
            if(arr[cnt-1]!=999 && arr[cnt-1]>=bs)
            {
                if(m++==0)
                temp=cnt-1;
                else if(arr[temp]>arr[cnt-1])
                temp=cnt-1;
            }
        }
        if(m!=0){
        if(arr[temp]>bs){
        printf("\nSize of block allocated=%d",bs);
        arr[temp]-=bs;}
        else{
        printf("\nSize of block allocated=%d",arr[temp]);
        arr[temp]=999;}
        }
        else
        printf("\nNo free block available!\n");
        printf("\n*************************\n");
        for(i=0;i<10;i++)
        printf("|%d| ",arr[i]);
        printf("\n*************************\n");

    }

    else if(n==3)
    {
        printf("\nEnter the block size:");
        scanf("%d",&bs);
        cnt=0;
        m=0;
        while(++cnt!=11)
        {
            if(arr[cnt-1]!=999 && arr[cnt-1]>=bs)
            {
                if(m++==0)
                temp=cnt-1;
                else if(arr[temp]<arr[cnt-1])
                temp=cnt-1;
            }
        }
        if(m!=0){
        if(arr[temp]>bs){
        printf("\nSize of block allocated=%d",bs);
        arr[temp]-=bs;}
        else{
        printf("\nSize of block allocated=%d",arr[temp]);
        arr[temp]=999;}
        }
        else
        printf("\nNo free block available!\n");
        printf("\n*************************\n");
        for(i=0;i<10;i++)
        printf("|%d| ",arr[i]);
        printf("\n*************************\n");

    }
    printf("\nEnter:\n1:First Fit\n2:Best Fit\n3:Worst Fit\n4:Exit\nYour Choice:");
    scanf("%d",&n);
    }


    return 0;
}

Single and Doubly Linked List Implementation with addition and removal of nodes, C++ code

#include<iostream>
using namespace std;
#include<conio.h>
#include<stdlib.h>
int display(void);
int single(int d,int count);
int doubly(int d,int cnt);
void out(int c);
void outy(int cn);



struct single_ll
{
       int data;
       struct single_ll *e;
}*f,*l,*t,*q,*n;

struct double_ll
{
       int entry;
       struct double_ll *nxt;
       struct double_ll *prev;
}*first,*last,*temp,*m,*r;

int ch,p=0,z;
int main()
{   f=NULL;
    first=NULL;
    int dec,count=0,cnt=0;
    char c='Y';
    while(c=='Y' || c=='y')
    {             system("cls");
                  cout<<"\n"<<"Choose:";
                  cout<<"\n"<<"1==Single Linked List";
                  cout<<"\n"<<"2==Doubly Linked List";
                  cout<<"\n"<<"Your choice (1 or 2) : ";
                  cin>>ch;
                  if(ch==1)
                  {

                  dec=display();
                  count=single(dec,count);

                  }
                  else if(ch==2)
                  {

                  dec=display();
                  cnt=doubly(dec,cnt);

                  }
                  else
                  cout<<"\n"<<"You entered a wrong choice!!";
                  cout<<"\n"<<"Want to continue by re-entering your choice?(Y/N): ";
                  cin>>c;
    }
    cout<<"\n"<<"ThankYou!! Have A Nice Day :) "<<"\n"<<"\n";
    getch();
}

int display(void)
{   int d;
    cout<<"\n"<<"Choose:";
    cout<<"\n"<<"1>Adding node"<<"\n"<<"2>Deleting node"<<"\n"<<"3>Displaying the contents"<<"\n";
    cout<<"\n"<<"Your choice : ";
    cin>>d;
    return d;
}

int single(int d,int count)
{
     switch(d)
     {
              case 1:{
                      int flag=0;
                      if(count<0)
                      count=0;
                      if(count==0)
                      {
                      cout<<"\n"<<"Link List is empty"<<"\n";
                      cout<<"You can only add first node"<<endl;
                      f=new single_ll;
                      cout<<"\n"<<"Enter the data in the node:";
                      cin>>f->data;
                      f->e=NULL;
                      l=f;
                      cout<<"\n"<<"Node added at position 1";
                      count++;
                      }

                      else
                      {
                      cout<<"\n"<<"The list has "<<count<<" nodes";
                      cout<<"\n"<<"Where you want to add the node?(Enter position.,eg.1 or 2...)";
                      cin>>p;
                      z=p;

                      if(p<0 || p>(count+1))
                      {
                      cout<<"\n"<<"Wrong Entry!!";
                      flag=1;

                      }

                      else if(p>1 && p<(count+1))
                      {

                      t=new single_ll;
                      n=f;

                      //Logic for inserting in b//

                      while((p--)!=1)
                      {
                      q=n;
                      n=n->e;
                      }
                      q->e=t;
                      t->e=n;
                      q=NULL;
                      n=NULL;
                      cout<<"\n"<<"Enter the data for the node:";
                      cin>>t->data;

                      }

                      else if(p==1)
                      {
                      t=new single_ll;
                      cout<<"\n"<<"Enter the data for the node:";
                      cin>>t->data;
                      t->e=f;
                      f=t;
                      t=NULL;
                      }

                      else if(p==(count+1))
                      {
                      t=new single_ll;
                      cout<<"\n"<<"Enter the data for the node:";
                      cin>>t->data;
                      l->e=t;
                      t->e=NULL;
                      l=t;
                      t=NULL;
                      }
                      count++;
                      if(flag==0)
                      cout<<"\n"<<"Node added at position "<<z;
                      }

                      return count;
                      }
                      break;
              case 2: {

                      if(count<0)
                      count=0;
                      int flag=0;
                      if(count==0)
                      {
                      cout<<"\n"<<"List is empty!";
                      flag=1;
                      }

                      else
                      {
                      if(count>0)
                      cout<<"\n"<<"The list has "<<count<<" node(s)";
                      cout<<"\n"<<"Which node to delete(Enter position.,eg.1 or 2...):";
                      cin>>p;
                      z=p;

                      //Logic for deletion
                      if(p<=count)
                      {

                      if(p>1 && p<(count+1))
                      {
                      t=f;
                      while(p--!=1)
                      {
                      q=t;
                      t=t->e;
                      }
                      q->e=t->e;
                      t=NULL;
                      }

                      else if(p==1)
                      {
                      t=f;
                      f=f->e;
                      t=NULL;
                      }

                      if(flag==0)
                      {
                      cout<<"\n"<<"Deleted node is node"<<z;
                      return --count;
                      }
                      }


                      else
                      {
                      cout<<"\n"<<"Wrong entry!!";
                      return count;
                      }
                      }
                      }
                      break;
              case 3: {
                      out(count);
                      return count;
                      }
              break;
              default:cout<<"\n"<<"Wrong Choice!";
              }
              }

void out(int c)
{
     if(c==0)
     cout<<"\n"<<"List is empty!";
     else
     {   cout<<"\n";
         t=f;
         do
         {
         cout<<t->data<<"-->>";
         t=t->e;
         }
         while(t!=NULL);
     }
}

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

int doubly(int d,int cnt)
{

     switch(d)
     {
              case 1:{
                      int flag=0;
                      if(cnt<0)
                      cnt=0;
                      if(cnt==0)
                      {
                      cout<<"\n"<<"Link List is empty"<<"\n";
                      cout<<"You can only add first node"<<endl;
                      first=new double_ll;
                      cout<<"\n"<<"Enter the data in the node:";
                      cin>>first->entry;
                      first->nxt=NULL;
                      first->prev=NULL;
                      last=first;
                      cout<<"\n"<<"Node added at position 1";
                      cnt++;
                      }

                      else
                      {
                      cout<<"\n"<<"The list has "<<cnt<<" nodes";
                      cout<<"\n"<<"Where you want to add the node?(Enter position.,eg.1 or 2...)";
                      cin>>p;
                      z=p;

                      if(p<0 || p>(cnt+1))
                      {
                      cout<<"\n"<<"Wrong Entry!!";
                      flag=1;
                      return cnt;
                      }

                      else if(p>1 && p<(cnt+1))
                      {

                      temp=new double_ll;
                      m=first;

                      //Logic for inserting in b//

                      while((p--)!=1)
                      {
                      r=m;
                      m=m->nxt;
                      }
                      r->nxt=temp;
                      temp->nxt=m;
                      m->prev=temp;
                      temp->prev=r;
                      r=NULL;
                      m=NULL;
                      cout<<"\n"<<"Enter the data for the node:";
                      cin>>temp->entry;

                      }

                      else if(p==1)
                      {
                      temp=new double_ll;
                      cout<<"\n"<<"Enter the data for the node:";
                      cin>>temp->entry;
                      temp->nxt=first;
                      first->prev=temp;
                      first=temp;
                      temp=NULL;
                      }

                      else if(p==(cnt+1))
                      {
                      temp=new double_ll;
                      cout<<"\n"<<"Enter the data for the node:";
                      cin>>temp->entry;
                      last->nxt=temp;
                      temp->prev=last;
                      temp->nxt=NULL;
                      last=temp;
                      temp=NULL;
                      }
                      cnt++;
                      if(flag==0)
                      cout<<"\n"<<"Node added at position "<<z;
                      }

                      return cnt;
                      }
                      break;
              case 2: {

                      if(cnt<0)
                      cnt=0;
                      int flag=0;
                      if(cnt==0)
                      {
                      cout<<"\n"<<"List is empty!";
                      flag=1;
                      }

                      else
                      {
                      if(cnt>0)
                      cout<<"\n"<<"The list has "<<cnt<<" node(s)";
                      cout<<"\n"<<"Which node to delete(Enter position.,eg.1 or 2...):";
                      cin>>p;
                      z=p;

                      //Logic for deletion
                      if(p<=cnt)
                      {

                      if(p>1 && p<(cnt+1))
                      {
                      temp=first;
                      while(p--!=1)
                      {
                      r=temp;
                      temp=temp->nxt;
                      m=temp->nxt;
                      }
                      r->nxt=m;
                      m->prev=r;
                      temp=NULL;
                      }

                      else if(p==1)
                      {
                      temp=first;
                      first=first->nxt;
                      first->prev=NULL;
                      temp=NULL;
                      }

                      if(flag==0)
                      {
                      cout<<"\n"<<"Deleted node is node"<<z;
                      return --cnt;
                      }
                      }


                      else
                      {
                      cout<<"\n"<<"Wrong entry!!";
                      return cnt;
                      }
                      }
                      }
                      break;
              case 3: {
                      outy(cnt);
                      return cnt;
                      }
              break;
              default:cout<<"\n"<<"Wrong Choice!";
              }


}

void outy(int c)
{
     if(c==0)
     cout<<"\n"<<"List is empty!";
     else
     {   cout<<"\n";
         temp=first;
         do
         {
         cout<<temp->entry<<"-->>";
         temp=temp->nxt;
         }
         while(temp!=NULL);
     }
}

Implementing Kruskal's Algorithm Data Structure C++ code

# define INFINITY 0
#include<iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;
int n,y=-1,k,flag;
struct group
{
    int cost,e1,e2;
}ob[12];
int main()
{
    int i,j,m,b,c=0,sum=0;
    cout<<"\nEnter the number of nodes:";
    cin>>n;
    fflush(stdin);
    char name[n];
    int adj[n][n],test[n],path[n][n],path_copy[n][n];
    for(i=0;i<n;i++)
   {
     cout<<"\n\a\aEnter the name on node:";
     cin>>name[i];
    for(j=0;j<n;j++)
    {
         fflush(stdin);
         cout<<"\n\nEnter cost at position ("<<i+1<<","<<j+1<<") : ";
         cin>>adj[i][j];
         path[i][j]=0;
         path_copy[i][j]=0;
         if(j>i && adj[i][j]!=INFINITY)
         {
         ob[++y].cost=adj[i][j];
         ob[y].e1=i;
         ob[y].e2=j;
         }
    }
   }
    system("cls");
    cout<<"\nThe adjacency matrix::\n\n";
    cout<<" ";
    for(i=0;i<n;i++)
    {
        cout<<"  ";
        cout<<name[i];
    }
    cout<<endl;
    for(i=0;i<n;i++)
    {
        cout<<name[i]<<" ";
        for(j=0;j<n;j++)
        {
           cout<<adj[i][j];
           cout<<"   ";
        }
        cout<<endl;
    }
    system("pause");
    system("cls");
    //Sort(Selection)
    for(i=0;i<=y;i++)
    {
        k=0;
        for(j=1;j<=y-i;j++)
        {
            if((ob[j].cost)>(ob[k].cost))
            k=j;
        }
        swap(ob[k],ob[j-1]);
    }
    cout<<"\nCost             Edge\n\n";
    for(i=0;i<=y;i++)
    {
        m=0;b=0,flag=1;
        for(j=0;j<i;j++)
        {
            if(ob[i].e1==ob[j].e1 || ob[i].e1==ob[j].e2)
            {m++;}
            if(ob[i].e2==ob[j].e1 || ob[i].e2==ob[j].e2)
            {b++;}
        }
        if(m>0 && b>0 && c<n-1)
        {
            //Warshall
            int f,g,k;
            for(k=0;k<n;k++)
            {
                for(f=0;f<n;f++)
                {
                    for(g=0;g<n;g++)
                    {
                        if(path[f][k]*path[k][g]==1)
                        path[f][g]=1;
                    }
                }
            }
            if(path[ob[i].e1][ob[i].e2]==1)
            flag=0;

            else
            {
                path_copy[ob[i].e1][ob[i].e2]=1;
                path_copy[ob[i].e2][ob[i].e1]=1;
                //For restoring path matrix
                for(int u=0;u<n;u++)
                {
                    for(int v=0;v<n;v++)
                    path[u][v]=path_copy[u][v];
                }
            }
        }
        else
        {
            path[ob[i].e1][ob[i].e2]=1;
            path[ob[i].e2][ob[i].e1]=1;

            path_copy[ob[i].e1][ob[i].e2]=1;
            path_copy[ob[i].e2][ob[i].e1]=1;
        }
        if(flag==1 && c<n-1)
        {
            cout<<ob[i].cost<<"               "<<"("<<name[ob[i].e1]<<","<<name[ob[i].e2]<<")"<<endl<<endl;
            c++;
            sum+=ob[i].cost;
        }
    }
    cout<<"----\n"<<sum<<endl<<endl;
    return 0;
}

Construct Graph and adding nodes and edges and displaying adjacency list using C++

#include<iostream>
#include<stdlib.h>
using namespace std;
void make_node(int n);
void add_edges();
void display();
int n;
struct edge;
struct node
{
    int data;
    struct node *below;
    struct edge *adj;
}*start,*temp,*last,*ptrx;

struct edge
{
    struct node *parent;
    struct edge *link;
}*first,*stop,*ptr;

int main()
{
    cout<<"\nEnter the number of nodes:";
    cin>>n;
    make_node(n);
    add_edges();
    display();
    return 0;
}

void make_node(int n)
{
    for(int i=0;i<n;i++)
    {
        if(start==nullptr)
        {
            start=new node;
            cout<<"\nEnter data in node "<<i+1<<" : ";
            cin>>start->data;
            start->below=nullptr;
            start->adj=nullptr;
            last=start;
        }
        else
        {
            temp=new node;
            cout<<"\nEnter data in node "<<i+1<<" : ";
            cin>>temp->data;
            last->below=temp;
            last=temp;
            last->below=nullptr;
            last->adj=nullptr;
            temp=nullptr;
        }
    }
}

void add_edges()
{
    int x,t;
    last=start;
    for(int i=0;i<n;i++,last=last->below)
    {
        cout<<"\nEnter number of edges in node "<<i+1<<" : ";
        cin>>x;
        ptrx=last;
        first=nullptr;
        for(int j=0;j<x;j++)
    {
        temp=start;
        if(first==nullptr)
        {
            first=new edge;
            cout<<"\nEnter the adjacent node "<<j+1<<" : ";
            cin>>t;
            for(int k=1;k<t;k++)
            temp=temp->below;
            first->parent=temp;
            first->link=nullptr;
            ptrx->adj=first;
            stop=first;
        }
        else
        {
            first=new edge;
            cout<<"\nEnter the adjacent node "<<j+1<<" : ";
            cin>>t;
            for(int k=1;k<t;k++)
            temp=temp->below;
            first->parent=temp;
            first->link=nullptr;
            stop->link=first;
            stop=first;
        }
    }
    }
}

void display()
{
    system("cls");
    cout<<"\nNode\t\t\tAdjacent node list";
    temp=start;
    for(int i=0;i<n;i++,temp=temp->below)
    {
        cout<<"\n"<<temp->data<<"\t\t\t\t";
        ptr=temp->adj;
        if(ptr!=nullptr)
        {
        while(ptr->link!=nullptr)
        {
            ptrx=ptr->parent;
            cout<<ptrx->data<<";";
            ptr=ptr->link;
        }
            ptrx=ptr->parent;
            cout<<ptrx->data;
        }
    }
}

Network Encoding Techniques using NRZ, NRZI and Manchester C++ code

#include<iostream>
using namespace std;
int main(){
    bool bit[20];int i,n;
    char t='L';
    cout<<"\nEnter the  total bit size:";
    cin>>n;
    cout<<"\nEnter the bits with spaces:";
    for(i=0;i<n;i++){
        cin>>bit[i];
    }
    cout<<"\nNRZ          ";
    for(i=0;i<n;i++){
        if(bit[i]==0)
        cout<<"L ";
        else
        cout<<"H ";
        }
        cout<<"\n\nNRZI         ";
        cout<<"L ";
        for(i=1;i<n;i++){
            if(bit[i]==1)
            {
                if(t=='H')
                {
                    t='L';
                }
                else
                    t='H';
            }
            cout<<t<<" ";
        }

cout<<"\nMANCHASTER   ";
    for(i=0;i<n;i++){
        if(bit[i]==0)
        cout<<"LH";
        else
        cout<<"HL";
        }

     

    return 0;
}

Implementation of Doubly Link List with addition of nodes C++ code

#define DELAY 150000000
#include<iostream>
using namespace std;
#include<stdlib.h>
int count;
void swap();
void visual();
void delay();
class dll
{
    public:
    int data;
    class dll *next,*prev;
}*first,*last,*pf,*pl,*qf,*ql,*xf,*temp;

int main()
{
    visual();
    int c;
     char ch='y';
     while(ch=='y'|| ch=='Y')
    {
    system("cls");
    cout<<"\nOPERATIONS:\n1:ADD NODE\n2:DISPLAY DOUBLY LIST\n\nYour choice:";
    cin>>c;

    switch(c)
    {
        case 1:{

                    if(first==nullptr)
                    {
                        first=new dll;
                        cout<<"Enter data to node "<<++count<<" : ";
                        cin>>first->data;
                        first->prev=nullptr;
                        first->next=nullptr;
                        last=first;
                    }
                    else
                    {
                        temp=new dll;
                        cout<<"Enter data to node "<<++count<<" : ";
                        cin>>temp->data;
                        temp->prev=last;
                        last->next=temp;
                        temp->next=nullptr;
                        last=temp;
                        temp=nullptr;
                    }
                }
              break;

        case 2:{
                    if(count==0)
                    {
                        cout<<"\n\a\aEmpty List!!";
                        break;
                    }
                    system("cls");
                    cout<<"\nList Details before swapping:->>\n\n";
                    temp=first;
                    cout<<"\nElement   Current Address   Next Address   Previous Address\n\n";
                    for(int i=0;i<count;i++,temp=temp->next)
                    {
                    cout<<"  "<<temp->data<<"         "<<temp<<"          "<<temp->next<<"               "<<temp->prev;
                    cout<<endl<<endl;
                    }

                    cout<<"swapswapswapswapswapswapswapswapswapswapswapswapswapswapswapswapswapswapswapswap";
                    swap();
                    cout<<"\n\nList Details after swapping:->>\n\n";
                    temp=first;
                    cout<<"\nElement   Current Address   Next Address   Previous Address\n\n";
                    for(int i=0;i<count;i++,temp=temp->next)
                    {
                    cout<<"  "<<temp->data<<"         "<<temp<<"          "<<temp->next<<"               "<<temp->prev;
                    cout<<endl<<endl;
                    }
               }
               break;

        default:cout<<"\nWrong entry!!";

    }
     cout<<"\a\nWANT TO CONTINUE?(Y/N):";
     cin>>ch;
    }
    return 0;
}

void swap()
{
                    pl=first;
                    ql=last;
                    pf=pl;
                    qf=ql;
                    if(count==2 || count==3)
                    {
                        pf->prev=pf->next;
                        pf->next=nullptr;
                        qf->next=qf->prev;
                        qf->prev=nullptr;
                        first=qf;
                        last=pf;
                        return;

                    }
                    while((pf->next)!=(qf->prev) && (pf->next)!=qf)
                    {
                        pl=pl->next;
                        ql=ql->prev;

                        if(pf==first)
                        {
                            pl->prev=qf;
                            qf->next=pl;
                            qf->prev=nullptr;
                            first=qf;

                            ql->next=pf;
                            pf->prev=ql;
                            pf->next=nullptr;
                            last=pf;
                        }
                        else
                        {
                            pl->prev=qf;
                            (pf->prev)->next=qf;

                            ql->next=pf;
                            (qf->next)->prev=pf;

                            qf->prev=pf->prev;
                            pf->next=qf->next;

                            pf->prev=ql;
                            qf->next=pl;

                        }
                        pf=pl;
                        qf=ql;
                    }

                    if(count%2==0)
                    {
                    pf=pl->prev;
                    qf=ql->next;

                    pl->next=qf;
                    pl->prev=ql;

                    ql->next=pl;
                    ql->prev=pf;

                    pf->next=ql;
                    qf->prev=pl;
                    }

                    else
                    {
                    xf=pl->next;
                    pf=pl->prev;
                    qf=ql->next;

                    pl->next=qf;
                    pl->prev=xf;

                    ql->next=xf;
                    ql->prev=pf;

                    pf->next=ql;
                    qf->prev=pl;

                    xf->prev=ql;
                    xf->next=pl;
                    }
}

void visual()
{
    system("cls");
    cout<<"LOADING,PLEASE WAIT";
    for(int j=0;j<8;j++)
    {
    cout<<".\a";
    delay();
    }
}
void delay()
{
    for(int i=0;i<DELAY;i++)
    continue;
}