INNOVATION: 2015

Friday, 25 September 2015

MAX HEAP IN JAVA

There are two types of heap and one of that is Max heap.
In Max heap, we have to add element such that parent has maximum value than it’s child value.
Here we represent Max heap as binary tree and we are going to implement it with static array in which zero index has no value. We add value in array starting from index one as show in figure.
Here we have same concept of queue that FIFO(first in – first out)

Functionality :-

Enqueue – Add element at last.
Dequeue – Delete from first position.
Peek – Display First Element

Advantage of Max heap :- Sorting become more efficient.

Enqueue :-

Suppose if we want to add 25 in upper Max heap than we have to add 25 at index 11 (suppose index 11 is there.).But as we know Max heap means child has minimum value that it’s parent but here 7<25, which is not possible that we have to swap that two value for that what can do that Number[i/2]<->Number[i] means as we can here we have index 11 if take 11/2=5(in integer) than you can directly jump at it’s parent value and exchange that value.After exchanging that two value you will again find that 14<25 that again you can change that value with upper logic like this we have to move till we don’t find that Number[i/2]>Number[i].

Dequeue:-

As we know for for dequeue, we have remove element from root or from first position for that we have to move last element of array (here we have 1) at first position but still parent should have maximum value than child for that we have compare Number[i] with Number[2*i] and Number[2*i+1] because of you again go through upper image than you will that parent (Number[i]) has two child Number[2*i] and Number[2*i+1].So we have to compare that value and if you find and maximum value of child than parent that swap those two value.

Peek:-

In peek we have where first element of array or tree.

Algorithm Of Max heap

import java.util.Scanner;

class MaxPriorityQueue
{
 private int []Number;
 private int MAXI;
 private int size;
 
 public MaxPriorityQueue(){}
 
 public MaxPriorityQueue(int maxi)
 {
  size=0;
  MAXI=maxi;
  Number=new int[maxi+1];
 }
 
 public void Enqueue(int Item)
 {
  if(size<MAXI)
  {
   if(size==0)
   {
    size++;
    Number[size]=Item;
   }
   else
   {
    size++;
    if(Item<=Number[size/2])
    {
     Number[size]=Item;
    }
    else
    {
     int i=size;
     Number[i]=Item;
     while(true)
     {
      if(i==1){break;}
      if(Number[i]>Number[i/2])
      {
       int Temp=Number[i/2];
       Number[i/2]=Number[i];
       Number[i]=Temp;
       i=i/2;        
      }
      else
      {
       break;
      }
     }
    }     
   }   
  }
  else
  {
   System.out.println("\nMIN PRIORITY QUEUE IS FULL.\n");
  }
 }
 
 public int Dequeue()
 {
  if(size==0)
  {
   return -999;
  }
  else
  {
   int RemovedElement=Number[1];
   Number[1]=Number[size];
   size--;int i=1;
   
   while(true)
   {
    if(i>=size){break;}
    if(2*i+1<=size)
    {
     if(Number[2*i]>Number[i])
     {
      int Swapper=Number[i];
      Number[i]=Number[2*i];
      Number[2*i]=Swapper;
     }     
     if(Number[2*i+1]>Number[i])
     {
      int Swapper=Number[i];
      Number[i]=Number[2*i+1];
      Number[2*i+1]=Swapper;
     }
     i=i*2;
    }
    else if(2*i<=size)
    {
     if(Number[2*i]>Number[i])
     {
      int Swapper=Number[i];
      Number[i]=Number[2*i];
      Number[2*i]=Swapper;
      i=i*2;
     }
     else
     {
      break;
     }      
    }
    else
    {
     break;
    }
   }
   return RemovedElement;
  }
 }
 
 public void Display()
 {
  for(int i=1;i<=size;i++)
  {
   System.out.println(Number[i]);
  }
 }
 
 public int Peek()
 {
  if(size==0)
  {
   return -999;
  }
  else
  {
   return Number[1];   
  }
 }

}

class MaxPriority_Queue
{
 public static void main(String[] args)
 {
  MaxPriorityQueue m=new MaxPriorityQueue(10);
  m.Enqueue(40);
  m.Enqueue(5);
  m.Enqueue(10);
  m.Enqueue(30);
  m.Enqueue(1);
  m.Enqueue(15);
  m.Enqueue(25);
  m.Enqueue(50);
  m.Enqueue(27);
  m.Enqueue(45);
  
  m.Display();

System.out.println("\t\t\tSorted List");
  while(m.Peek()!=-999)
  {
   System.out.println("\t\t\t"+m.Dequeue());
   //m.Display();
  }     
 }
}

Download :- Max Heap

MIN HEAP USING JAVA

In Min heap, we have to add element such that parent has minimum value than it’s child value.

Here we represent Min heap as tree and we are going to implement it with static array in which zero index has no value. We add value in array starting from index one as show in figure.

Here we have same concept of queue that FIFO(first in – first out)

Functionality :-

Enqueue – Add element at last.

Dequeue – Delete from first position.

Peek – Display First Element

Advantage of Min heap:- Sorting become more efficient.

Enqueue :-

Suppose if we want to add 1 in upper Min heap than we have to add 1 at index 11 (suppose index 11 is there.).But as we know Min heap means child has maximum value that it’s parent but here 1<3, which is not possible that we have to swap that two value. For that what can do that Number[i/2]<->Number[i], means as we can here we have index 11 if take 11/2=5(in integer) than you can directly jump at it’s parent value and exchange that value. After exchanging that two value you will again find that 1<2 that again you can change that value with upper logic like this we have to move untill we don’t find that Number[i/2]>Number[i].

Dequeue:-

As we know for dequeue, we have to remove element from root or from first position for that we have to move last element of array (here we have 1) at first position but still parent should have minimum value than child for that we have compare Number[i] with Number[2i] and Number[2i+1] because of you again go through upper image than you will that parent (Number[i]) has two child Number[2i] and Number[2i+1].So we have to compare that value and if you find and minimum value of child than parent that swap those two value.

Peek:-

In peek we have where first element of array or tree.

Algorithm Of Min heap

import java.util.Scanner;

class MinPriorityQueue
{
 private int []Number;///Array to store data
 private int MAXI;//Maximum size of static array
 private int size;//number of element in list

public MinPriorityQueue(){}//construtor
 
 public MinPriorityQueue(int maxi)//parameterized construtor
 {
  size=0;
  MAXI=maxi;
  Number=new int[maxi+1];
 }
 
 public void Enqueue(int Item)//Add element in min priority queue
 {
  if(size<MAXI)
  {
   if(size==0)
   {
    size++;
    Number[size]=Item;
   }
   else
   {
    size++;
    if(Item>=Number[size/2])
    {
     Number[size]=Item;
    }
    else
    {
     int i=size;
     Number[i]=Item;
     while(true)
     {
      if(i==1){break;}
      if(Number[i]<Number[i/2])
      {
       int Temp=Number[i/2];
       Number[i/2]=Number[i];
       Number[i]=Temp;
       i=i/2;        
      }
      else
      {
       break;
      }
     }
    }     
   }   
  }
  else
  {
   System.out.println("\nMIN PRIORITY QUEUE IS FULL.\n");
  }
 }
 
 public int Dequeue()//delete root or first element
 {
  if(size==0)
  {
   return -999;
  }
  else
  {
   int RemovedElement=Number[1];
   Number[1]=Number[size];
   size--;int i=1;
   
   while(true)
   {
    if(i>=size){break;}
    if(2*i+1<=size)
    {
     if(Number[2*i]<Number[i])
     {
      int Swapper=Number[i];
      Number[i]=Number[2*i];
      Number[2*i]=Swapper;
     }     
     if(Number[2*i+1]<Number[i])
     {
      int Swapper=Number[i];
      Number[i]=Number[2*i+1];
      Number[2*i+1]=Swapper;           
     }
     i=i*2;
    }
    else if(2*i<=size)
    {
     if(Number[2*i]<Number[i])
     {
      int Swapper=Number[i];
      Number[i]=Number[2*i];
      Number[2*i]=Swapper;
      i=i*2;
     }
     else
     {
      break;
     }      
    }
    else
    {
     break;
    }
   }
   return RemovedElement;   
  }
 }
 
 public int Peek()//display first value of array
 {
  if(size==0)
  {
   return -999;
  }
  else
  {
   return Number[1];   
  }
 }
 
 public void Display()
 {
  for(int i=1;i<=size;i++)
  {
   System.out.println(Number[i]);
  }
 }
}

class MinPriority_Queue
{
 public static void main(String[] args)
 {
  MinPriorityQueue m=new MinPriorityQueue(10);
  m.Enqueue(6);
  m.Enqueue(2);
  m.Enqueue(10);
  m.Enqueue(3);
  m.Enqueue(9);
  m.Enqueue(15);
  m.Enqueue(74);
  m.Enqueue(4);
  m.Enqueue(65);
  m.Enqueue(45);
  m.Display(); 
  System.out.println("\nDeleted Element :- "+m.Dequeue());
  m.Display();

System.out.println("\t\t\tSorted List");
  while(m.Peek()!=-999)
  {
   System.out.println("\t\t\t"+m.Dequeue());
  }   
 }
}

Download :- Min Heap

Sunday, 20 September 2015

Algorithm For Findind LU Factorization of Given Matrix in Java

Algorithm For Finding LU Factorization of Given Matrix in Java

Here given matrix can be decompose into two part L and U.
Here I have Algorithm for solving LU Factorization for given matrix.
You have to keep in mind that L part of given m * n matrix has dimension of m * m where as U part has dimension of m * n.

import java.util.Scanner;

public class Matrix {
    
    private int Row; //NO OF ROWS
    private int Column; //NO OF COLUMNS
    private float [][]Elements;//FOR CARRING ELEMENTS
    private float [][]U; //FOR LU FACTORIZATION
    private float [][]L; //
    private float []T;
    private int count;//FOR CHECKING EXISTS OF LU FACTORIZATION.
    private boolean write;//FOR CHECKING METRIX EXISTANCES.
    public Matrix(int No_Row,int No_Column)//PARAMETERIZED CONSTRUCTOR
    {
        if(No_Row>0 && No_Column>0)
        {
            count=0;Determinat=0;
            write=true;
            Row=No_Row;
            Column=No_Column;
            Elements = new float[No_Row][No_Column];
                U=new float[No_Row][No_Column];
                L=new float[No_Row][No_Row];
           
            T=new float[No_Column];
            for(int i=0;i<No_Column;i++){T[i]=1;}

}
        else
        {
            write=false;
            System.out.println("\nYOU CAN NOT MAKE MATRIX WITH THIS DIMENTIONS.\n");
        }
    }

public void SET_ELEMENTS_OF_MATRIX()
    {
        //if(!write){return ;}
        Scanner x=new Scanner(System.in);

for(int i=0;i<Row;i++)
        {
            for(int j=0;j<Column;j++)
            {
                System.out.println("ENTER ["+i+"]["+j+"] ELEMENT OF MATRIX :- ");
                Elements[i][j]=x.nextFloat();
            }
        }

int Hold;
        for(int i=0;i<Row;i++)
        {
            for(int j=0;j<Row;j++)
            {
                if(i<j || i>j){L[i][j]=0;}
                else
                {
                    L[i][j]=1;
                }     
            }
        }
        Algorithms_of_EF();
    }
    
    private void Algorithms_of_EF()
    {
        //if(!write){return;}
        int R=0;int CC=-1;int RC=-1;
        for(int i=0;i<Column;i++)
        {
            if(R<Row)
            {  
                if(Elements[R][i]!=0)
                {
                    CC++;
                    RC=CC;
                    if(RC<row && CC<Row)
                    {
                        L[RC][CC]=Elements[R][i];T[CC]=Elements[R][i];
                    }
                                      
                    for(int k=R+1;k<Row;k++)
                    {
                        float []Array=new float[Column];
                            RC++;
                            if(RC<Row && CC<Row){L[RC][CC]=Elements[k][i];}

for(int l=0;l<Column;l++)
                        {
                            Array[l]=Elements[k][l] - ((Elements[R][l]*Elements[k][i])/Elements[R][i]);
                        }
                        for(int l=0;l<Column;l++)
                        {
                            Elements[k][l]=Array[l];
                        }
                    }
                    R++; 
                }
                else
                {
                    int Temp=-1;
                    for(int j=(Row-1);j>R;j--)
                    {
                        if(Elements[j][i]!=0)
                        {
                                Temp=j;
                                break;
                        }
                    }

if(Temp!=-1)
                    {
                        count++;
                        for(int f=0;f<Column;f++)
                        {
                            float Temp1= Elements[Temp][f];
                            Elements[Temp][f]=Elements[R][f];
                            Elements[R][f]=Temp1;
                        }

CC++; 
                        RC=CC;
                        if(RC<row && CC<Row){L[RC][CC]=Elements[R][i];T[CC]=Elements[R][i];}

for(int k=R+1;k<Row;k++)
                        {
                            float []Array=new float[Column];

RC++;
                            if(RC<Row && CC<Row)
                            {
                               L[RC][CC]=Elements[k][i];
                            }

for(int i=0;i<Row;i++)
        {
            for(int j=0;j<Column;j++)
            {
                    U[i][j]=Elements[i][j];
            }
        }
    }

private void Set_L_Part()
    {
        //int Temp;
        for(int i=0;i<Row;i++)
        {
            for(int j=0;j<Row;j++)
            {
                L[j][i]=L[j][i]/T[i];
            }
        }  
    }

public void Get_LU_FACTORIZATION_Part()
    {
        
        if(count==0)
        {
            Set_L_Part();

System.out.println("\n------ L PART ------\n");
            int Temp;
            for(int i=0;i<Row;i++)
            {
                for(int j=0;j<Row;j++)
                {
                        if(L[i][j]==(-0.0)){L[i][j]=0;}
                        System.out.print(L[i][j]+"  ");
                }
                System.out.println();
            }

System.out.println("\n------ U PART ------\n");
                int Temp1;
                for(int i=0;i<Row;i++)
                {
                    for(int j=0;j<Column;j++)
                    {
                            System.out.print(U[i][j]+"      ");
                    }
                    System.out.println();
                }
        }
        else
        {
            System.out.println("\nLU FACTORIZATION IS NOT POSSIBLE THIS MATRIX.\n");
        }
    }
    
    public void Display()
    {
        
        System.out.println("\n\n");
        for(int i=0;i<Row;i++)
        {
            for(int j=0;j<Column;j++)
            {
                if(Elements[i][j]==(-0.0)){Elements[i][j]=0;}
                System.out.print(Elements[i][j]+"  ");
            }
            System.out.println();
        }
    }
}

Main Class

Saturday, 8 August 2015

Algorithm For Solving Determinant Using Echelon Form

Algorithm Of solving Determinant using Echelon Form

As we there is general method available for solving determinant of given matrix but that is not efficient. But if we solve that through Echelon form method that it is quite easier to get determinant.
Because if your able to get Echelon form of given matrix that just multiply diagonal element of that echelon form matrix and that is answer of given matrix determinant.

As we can see in graph that if you take general algorithm for solving determinant than it take too much time for higher dimension matrix at that time it is efficient to use EF algorithm for solving determinant computerized.

import java.util.Scanner;

class Matrix
{
 private int Row;
 private int Column;
 private float [][]Elements;
        private float Determinat;
 
 public Matrix(int No_Row,int No_Column)
 {
  Row=No_Row;
  Column=No_Column;
  Elements = new float[No_Row][No_Column];
                Determinat=0; 
 }
 
 public void SetElements()
 {
  Scanner x=new Scanner(System.in);
  
  for(int i=0;i<Row;i++)
  {
   for(int j=0;j<Column;j++)
   {
    System.out.print("\nENTER ["+i+"]["+j+"] ELEMENT OF MATRIX :- ");
    Elements[i][j]=x.nextFloat();
   }
  }
 }
 
 
 private void Algorithms_of_EF()
 {
   int R=0;
  for(int i=0;i<Column;i++)
  {
   if(R<Row)
   {  
    if(Elements[R][i]!=0)
    {
     
     for(int k=R+1;k<Row;k++)
     {
      float []Array=new float[Column];

int Temp=-1;
     for(int j=(Row-1);j>R;j--)
     {
      if(Elements[j][i]!=0)
      {
       Temp=j;
       break;
      }
     }

if(Temp!=-1)
     {
      for(int f=0;f<Column;f++)
      {
       float Temp1= Elements[Temp][f];
       Elements[Temp][f]=Elements[R][f];
       Elements[R][f]=Temp1;
      }
      
     
      for(int k=R+1;k<Row;k++)
      {
       float []Array=new float[Column];
      
      
       for(int l=0;l<Column;l++)
       {
        Array[l]=Elements[k][l] - ((Elements[R][l]*Elements[k][i])/Elements[R][i]);
       }
       for(int l=0;l<Column;l++)
       {
        Elements[k][l]=Array[l];
       }
      }
      R++;
     }
    }
   }
  }

}
 
    public float GET_DETERMINAT_OF_MATRIX()
    {
        if(Row==Column)
        {
            Algorithms_of_EF();
            if(Row==Column)
            {
                Determinat=1;
                for(int i=0;i<Row;i++)
                {
                    Determinat=Determinat*Elements[i][i];
                }
            }
            return Determinat;
        }
        else
        {
            System.out.println("\nDETERMINAT OF THIS MATRIX MIGHT NOT POSSIBLE.\n");
            return -1;
        }
    }
 
 
 public void Display()
 {
  System.out.println("\n\n");
  for(int i=0;i<Row;i++)
  {
   for(int j=0;j<Column;j++)
   {
    if(Elements[i][j]==(-0.0)){Elements[i][j]=0;}
    System.out.print(Elements[i][j]+"  ");
   }
   System.out.println();
  }
 }
}

Main Class

Algorithm Of Finding Inverse Of Matrix Using Row Reduced Echelon Method

Algorithm Of Finding Inverse Of Matrix Using Row Reduced Echelon Form Method

Here I have one nice algorithm for solving inverse of square matrix with help of echelon form algorithm which i have available on this blog which is quite efficient than any other method.

import java.util.Scanner;

class Matrix
{
 private int Row;
 private int Column;
 private float [][]Elements;
        private float [][]Inverse;
 
 public Matrix(int No_Row,int No_Column)
 {
  Row=No_Row;
  Column=No_Column;
  Elements = new float[No_Row][No_Column];
                if(No_Row==No_Column)
                {
                    Inverse = new float[No_Row][No_Column];

for(int i=0;i<No_Row;i++)
                    {
                        for(int j=0;j<No_Column;j++)
                        {
                             if(i==j){Inverse[i][j]=1;}else{Inverse[i][j]=0;}
                        }
                    }
                }
 }
 
 public void SetElements()
 {
  Scanner x=new Scanner(System.in);
  
  for(int i=0;i<Row;i++)
  {
   for(int j=0;j<Column;j++)
   {
    System.out.print("\nENTER ["+i+"]["+j+"] ELEMENT OF MATRIX :- ");
    Elements[i][j]=x.nextFloat();
   }
  }

}
 
    private void Algorithms_of_EF()
    {
        int R=0;
        for(int i=0;i<Column;i++)
        {
            if(R<Row)
            {  
                if(Elements[R][i]!=0)
                {
                                      
                    for(int k=R+1;k<Row;k++)
                    {
                        float []Array=new float[Column];
                        float []Array1=new float[Column];

if(Temp!=-1)
                    {
                        count++;
                        for(int f=0;f<Column;f++)
                        {
                            float Temp1= Elements[Temp][f];
                            Elements[Temp][f]=Elements[R][f];
                            Elements[R][f]=Temp1;
                            if(Row==Column)
                            {
                                float Temp2= Inverse[Temp][f];
                                Inverse[Temp][f]=Inverse[R][f];
                                Inverse[R][f]=Temp2;                                    
                            }
                        }

for(int k=R+1;k<Row;k++)
                        {
                            float []Array=new float[Column];
                            float []Array1=new float[Column];

for(int l=0;l<Column;l++)
                            {
                                Array[l]=Elements[k][l] - ((Elements[R][l]*Elements[k][i])/Elements[R][i]);
                                if(Row==Column)
                                {
                                    Array1[l]=Inverse[k][l]- ((Inverse[R][l]*Elements[k][i])/Elements[R][i]);
                                }
                            }
                            for(int l=0;l<Column;l++)
                            {
                                Elements[k][l]=Array[l];
                                if(Row==Column)
                                {
                                    Inverse[k][l]=Array1[l];
                                }
                            }
                        }
                        R++;
                    }
                }
            }
        }
    }
 
    public void GET_INVERSE_OF_MATRIX()
    {
        
        if(Row==Column)
        {
            for(int i=0;i<Row;i++)
            {
                for(int j=0;j<Column;j++)
                {
                    System.out.print(Inverse[i][j]+"        ");
                }
                System.out.println();
            }
        }
        else
        {
            System.out.println("\nSORRY BUT INVERSE OF THIS MATRIX MIGHT NOT POSSIBLE\n");
        }
    }
 
         
 public void Display()
 {
  System.out.println("\n\n");
  for(int i=0;i<Row;i++)
  {
   for(int j=0;j<Column;j++)
   {
    if(Elements[i][j]==(-0.0)){Elements[i][j]=0;}
    System.out.print(Elements[i][j]+"  ");
   }
   System.out.println();
  }
 }
}

Main Class

Doubly Link-List in Java

Doubly Link List

As we can see here two nodes are connected among themselves with two links between them.
For first Node node0, next Node is node1 and node1 is connected with previous link between node0 and node1.
Here first node is head and the last Node is tail. Both have value null and we same logic which we have in singly link list.

/*
**
Doubly Link List - Generic Class
Shreyas Patel
**
*/
class Node<T>
{
 public T Data;
 public Node Next;
 public Node Pre;
 
 public Node(){}
 
 public Node(T data)
 {
  Data = data;
  Next = Pre = null;
 } 
}

class Doubly_Link<T>
{
 private Node Head;
 private Node Tail;
 private int SIZE;
 
 public Doubly_Link()
 {
  Head = Tail = null;
  SIZE = 0;
 }
 
 public void Add_At_First(T data)
 {
  Node<T> n = new Node<T>(data);
  if(Head==null)
  {
   Head = n;
   Tail = Head;
  }
  else
  {
   Head.Pre = n;
   n.Next = Head;
   Head = n;
  }
  SIZE++;
 }
 
 public void Add_At_Last(T data)
 {
  Node<T> n=new Node<T>(data);
  if(Head==null)
  {
   Head=n;
   Tail=Head;
  }
  else
  {
   n.Pre=Tail;
   Tail.Next=n;
   Tail=n;
  }
  SIZE++;
 }
 
 public void Add_At_Position(T data,int Pos)
 {
  if(Pos==1)//Means first add
  {
   Add_At_First(data);
   return;
  }
  
  if(Pos==SIZE)//Means last add
  {
   Add_At_Last(data);
   return;
  }
  
  ////Else position add 
  Node<T> n=new Node<T>(data);
  Node Dummy=null;
  if(Pos<=SIZE/2)
  {
   int count = 0;
   Dummy = Head;
   while(Dummy.Next!=null)
   {
    count++;
    if(count==Pos)
    {break;}
    else{Dummy=Dummy.Next;}
   }
  }
  else
  {
   int count = SIZE;   
   Dummy = Tail;
   while(Dummy.Pre!=null)
   {
    if(count==Pos)
    {break;}
    else{Dummy=Dummy.Pre;}
    count--;
   }
  }
  Node Previous = Dummy.Pre;
  n.Pre = Previous;
  Previous.Next = n;
  Dummy.Pre = n;
  n.Next = Dummy; 
  SIZE++;
 }
 
 public void Delete_From_First()
 {
  if(Head.Next==null)
  {
   Head=null;Tail=null;
  }
  else
  {
   Head=Head.Next;
  }
  SIZE--;
 }
 
 public void Delete_From_Last()
 {
  if(Tail.Pre==null)
  {
   Head=null;Tail=null;
  }
  else
  {
   Node Previous = Tail.Pre;
   Previous.Next = null;
   Tail = Previous;
  }
  SIZE--;
 }
 
 public void Delete_From_Position(int Pos)
 {
  if(Pos==1){Delete_From_First();return;}
  if(Pos==SIZE){Delete_From_Last();return;}
  
  Node Dummy=null;
  if(Pos<=SIZE/2)
  {
   int count = 0;
   Dummy = Head;
   while(Dummy.Next!=null)
   {
    count++;
    if(count==Pos)
    {break;}
    else{Dummy=Dummy.Next;}
   }
  }
  else
  {
   int count = SIZE;   
   Dummy = Tail;
   while(Dummy.Pre!=null)
   {
    if(count==Pos)
    {break;}
    else{Dummy=Dummy.Pre;}
    count--;
   }
  }
  Node Previous = Dummy.Pre;
  Node UpNext = Dummy.Next;
  UpNext.Pre = Previous;
  Previous.Next = UpNext;
  SIZE--;  
 }
 
 public void Display()
 {
  Node Dummy = Head;
  if(Head==null){System.out.println("\nNo data available.\n");return;}
  while(Dummy!=null)
  {
   System.out.println(Dummy.Data);
   Dummy = Dummy.Next;
  }
 }
}

///Main Function
class Doubly_LinkList
{
 public static void main(String[] args)
 {
  System.out.println("\nNow for String.\n");
  Doubly_Link<String> d= new Doubly_Link<String>();
  
  d.Add_At_First("Shreyas");
  d.Add_At_First("Kaksh");
  d.Add_At_First("Mayuri");
  d.Add_At_Last("Girishbhai");
  d.Add_At_Position("Kiritbhai",3);
  d.Display();
  //d.Delete_From_First();
  //d.Delete_From_Last();
  //d.Delete_From_Last();
  //d.Delete_From_Last();
  //d.Delete_From_Last();
  //d.Delete_From_Last();
  System.out.println("\nAt delete from position 3.\n");
  d.Delete_From_Position(3);
  d.Display();
  System.out.println("\nAt delete from position 1.\n");
  d.Delete_From_Position(1);
  d.Display();
  System.out.println("\nAt delete from position 2.\n");
  d.Delete_From_Position(2);
  d.Display();
  System.out.println("\nAt delete from position 1.\n");
  d.Delete_From_Position(1);
  d.Display();
  System.out.println("\nAt delete from position 1.\n");
  d.Delete_From_Position(1);
  d.Display();
  
  System.out.println("\nNow for Integer.\n");
  
  Doubly_Link<Integer> i = new Doubly_Link<Integer>();
  
  i.Add_At_First(4);
  i.Add_At_First(1);
  i.Add_At_First(8);
  i.Add_At_Last(2);
  i.Add_At_Position(7,3);
  i.Display();
  
  
  System.out.println("\nAt delete from position 3.\n");
  i.Delete_From_Position(3);
  i.Display();
  System.out.println("\nAt delete from position 1.\n");
  i.Delete_From_Position(1);
  i.Display();
  System.out.println("\nAt delete from position 2.\n");
  i.Delete_From_Position(2);
  i.Display();
  System.out.println("\nAt delete from position 1.\n");
  i.Delete_From_Position(1);
  i.Display();
  System.out.println("\nAt delete from position 1.\n");
  i.Delete_From_Position(1);
  i.Display();
 }
}

ArrayList in java

ArrayList

Here we are going to implement List program with help of ArrayList Algorithms
Main function should be Add_At_Position,Delete_From_Position,Display,GetSize,Sorting,etc.

import java.util.*;
class ArrayList
{
 private int Item[];
 private int position;
 private int SIZE;
 
 public ArrayList(int no)//parametrized contractor
 {
  position=-1;
  SIZE=no;
  Item=new int[no];
 }
 
 public void FirstAdd(int text)//For add member at first
 {
   position++;
   Item[position]=0;
   int j;
   for(int i=position;i>=0;i--)
   {
    if(i!=0)
    {
     j=i;
     int temp=Item[j];
     Item[j]=Item[j-1];
     Item[j-1]=temp;
    }
    else
    {
     Item[i]=text;
     System.out.println("\nSuccessfully added.\n");
    }
   }
 } 
 
 public void LastAdd(int text)//For member at last
 {
  position++;
  Item[position]=text;
  System.out.println("\nSuccessfully added.\n");
 }
 
 public void PositionAdd(int text)//for add member at given position
 {
   Scanner x=new Scanner(System.in);
   System.out.println("\nThere are this many list in List :- "+(++position));
   System.out.print("\nAT which position you want to add :- ");
   int pos=x.nextInt();
   pos--;
   int j;
   for(int i=position;i>=pos;i--)
   {
    if(i!=pos)
    {
     j=i;
     int temp=Item[j];
     Item[j]=Item[j-1];
     Item[j-1]=temp;
    }
    else
    {
     Item[i]=text;
     System.out.println("\nSuccessfully added.\n");
    }
   }
 }
 
 public void Display()//display data function
 {
  System.out.println("\n\n\nLIST OF MEMBERS\n\n\n");
  for(int i=0;i<=position;i++)
  {
   int k=i;k++;
   System.out.println(k+" :- "+Item[i]);
  }
 }
 
 public int Search(int text)//search by value
 {
  for(int i=0;i<=position;i++)
  {
   if(text==Item[i])
   {
    return i+1;
   }
  }
  return -1;
 }
 
 public int Searchpos(int pos)//search by position
 {
  pos--;
  if(pos<=position)
  return Item[pos];
  else
  return -1; 
 }
 
 public void Delete(int number,int pos)//delete function
 {
  pos--;
  if(number==0)
  {
   position--;
   System.out.println("\nSuccessfully Deleted.\n");
   return;
  }
  else if(number==(SIZE-1))
  {
   position--;
   System.out.println("\nSuccessfully Deleted.\n");
   return;
  }
  else
  {
   for(int i=pos;i<position;i++)
   {
    int Temp=Item[i];
    Item[i]=Item[i+1];
    Item[i+1]=Temp;
   }   
  }
  position--;
  System.out.println("\nSuccessfully Deleted.\n");
 }
 
 public void Sorting()//bubble sorting
 {
  for(int i=0;i<position;i++)
  {
   for(int j=i+1;j<=position;j++)
   {
    if(Item[i]>Item[j])
    {
     int Temp=Item[i];
     Item[i]=Item[j];
     Item[j]=Temp;
    }
   }
  }
 }
 
 public int Getpos()
 {
  return position;
 }
}

Generic Class in Java

Generic Class

In this picture as we can see we have three different clots for driver, if you put slotted than you can fix that pin, if you put crossed on driver than you can fix that pin and so on.
Just like we have generic class which says that you build class one time and that class for all different object like String, Int, Float etc.
Suppose, we have one list program define for int object but now you are in need of same list for String Object or double Object than every time define same thing for different Object is difficult for us.So what we should do that create generic class.
Create generic class and use that for different datatypes or Object.How we can implement that is as below.

Generic class

Main class

Link-List in Java

LinkedList

Graph Of linking between Nodes

Here we are going to implement List program with help of LinkedList Algorithms
Main function should be Add_At_Position,Delete_From_Position,Display,GetSize,Sorting,etc.
Main advantage of using link list is that it is dynamic.
Here first we are going to make Node with help of Node class

import java.util.*;

///Node class for linking between to Data nodes
class Node
{
 public int Data;
 public Node Next;
 
 public Node(int data)
 {
  Data=data;
  Next=null;
 }
 
 public int GetData()
 {return Data;}
}

//Linked list class
class LinkedList
{
 private Node Head;
 private int SIZE;

//contractor
 public LinkedList()
 {
  Head=null;
  SIZE = 0;
 }
 
 //General function for add data at any position
 public void Add_Data(int Pos,int Data)
 {
  Node Previous_Address=null;
  Node Dummy=Head;
  int counter=0;
  
  while(true)
  {
   if(Dummy!=null)
   {
    counter++;
    if(counter==Pos-1)
    {
     Previous_Address=Dummy;
    }
    
    if(counter==Pos)
    {
     Node n=new Node(Data);
     if(Pos==1)
     {
      n.Next=Head;
      Head=n;       
     }
     else if(Pos==GetSize())
     {
      Dummy.Next=n;
     }
     else
     {
      n.Next=Dummy;
      Dummy=n;
      Previous_Address.Next=Dummy;
     }
     break;
    }
    else
    {
     Dummy=Dummy.Next;
    }
   }
   else
   {
    if(GetSize()==0)
    {
     Node n=new Node(Data);    
     n.Next=Head;
     Head=n;
     break;
    }
   }
  }
  
  System.out.println("\n\nSUCCESSFULLY ADDED IN LIST\n\n");
  SIZE++;
 }
 
 
 //General function for deleting data from any position
 public void Delete_Data(int Pos)
 {
  Node Dummy=Head;
  Node Previous_Address=null;
  int counter=0;
  
  while(true)
  {
   if(Dummy!=null)
   {
    counter++;
    if(counter==Pos-1)
    {
     Previous_Address=Dummy;
    }
    
    if(counter==Pos)
    {
     if(Pos==1)
     {
      Head=Head.Next;
     }
     else
     {
      Dummy=Dummy.Next;
      Previous_Address.Next=Dummy;
     }
     SIZE--;
     break;
    }
    else
    {
     Dummy=Dummy.Next;
    }
   }
   else
   {
    System.out.println("\nYOU ENTER WRONG POSITION.\n\nOR DATA IS NOT AVAILABLE AT THAT POSITION.");
    break;
   }
   
  }
 }

//Display function
 public void Display()
 {
  System.out.println("\n\t\t\t-----LIST-----\n\n");
  Node Dummy=Head;
  while(true)
  {
   if(Dummy!=null)
   {
    System.out.println("\t\t\t\t"+Dummy.GetData());
    Dummy=Dummy.Next;
   }
   else
   {
    break;
   }
  }
 }
 
 //Function for searching element's position by it's value.
 public int SearchElementByValue(int Value)
 {
  Node Dummy=Head;
  int counter=0;
  while(Dummy!=null)
  {
   counter++;
   if(Dummy.GetData()==Value)
   {
    return counter;
   }
   Dummy=Dummy.Next;
  }
  return -1;
 }
 
 //Function for searching position
 public int SearchByPosition(int Pos)
 {
  Node Dummy=Head;
  int counter=0;
  while(Dummy!=null)
  {
   counter++;
   if(counter==Pos)
   {
    break;
   }
   else
   {
    Dummy=Dummy.Next;
   } 
  }
  
  if(Dummy!=null)
  return Dummy.GetData();
  else
  return -1; 
 }
 
 //For getting number of elements in list
 public int GetSize()
 {
  return SIZE;   
 }
 
 //Function for sorting list
 public void Sorting()
 {
  System.out.println("\n\n\t\t\tSORTED LIST");
  for(int i=1;i<GetSize();i++)
  {
   Node Dummy=Head;
   Node Dummy1=null;
   
   while(Dummy.Next!=null)
   {
    Dummy1 = Dummy;
    Dummy=Dummy.Next;
    
    if(Dummy.Data<Dummy1.Data)
    {
     int Temp=Dummy.GetData();
     Dummy.Data=Dummy1.Data;
     Dummy1.Data=Temp;
    }
    
   }
   
  }
 }
 
 public void Reverce_List()
 {
  Node Dummy1=Head;
  for(int i=0;i<(SIZE/2);i++)
  {
   int counter=1;
   Node Dummy=Head;
   while(Dummy!=null)
   {
    if(counter==SIZE-i)
    {
     break;
    }
    else
    {
     counter++;
     Dummy=Dummy.Next;
    }
   }
   
   if(Dummy!=null)
   {
    int Temp=Dummy.Data;
    Dummy.Data=Dummy1.Data;
    Dummy1.Data=Temp;
   }
   Dummy1=Dummy1.Next;
  }
  System.out.println("Successfully Shifted All Elements."); 
 }
}

Algorithm Of Solving Echelon Form Of Matrix

Here I have one nice algorithm for solving matrix Echelon form which is very helpful finding determinant of matrix, for RREF, for LU factorization etc.

import java.util.Scanner;

public class Matrix {
    
    private int Row; //NO OF ROWS
    private int Column; //NO OF COLUMNS
    private float [][]Elements;//FOR CARRING ELEMENTS

public Matrix(int No_Row,int No_Column)//PARAMETERIZED CONSTRUCTOR
    {
        if(No_Row>0 && No_Column>0)
        {
            Row=No_Row;
            Column=No_Column;
            Elements = new float[No_Row][No_Column];

}
        else
        {
            write=false;
            System.out.println("\nYOU CAN NOT MAKE MATRIX WITH THIS DIMENTIONS.\n");
        }
    }

public void SET_ELEMENTS_OF_MATRIX()
    {
        Scanner x=new Scanner(System.in);

for(int i=0;i<Row;i++)
        {
            for(int j=0;j<Column;j++)
            {
                System.out.println("ENTER ["+i+"]["+j+"] ELEMENT OF MATRIX :- ");
                Elements[i][j]=x.nextFloat();
            }
        }
    }
    
    public void Algorithms_of_EF()
    {
        int R=0;
        for(int i=0;i<Column;i++)
        {
            if(R<Row)
            {  
                if(Elements[R][i]!=0)
                {
                                      
                    for(int k=R+1;k<Row;k++)
                    {
                        float []Array=new float[Column];
                        for(int l=0;l<Column;l++)
                        {
                            Array[l]=Elements[k][l] - ((Elements[R][l]*Elements[k][i])/Elements[R][i]);
                        }
                        for(int l=0;l<Column;l++)
                        {
                            Elements[k][l]=Array[l];
                        }
                    }
                    R++; 
                }
                else
                {
                    int Temp=-1; 
                    for(int j=(Row-1);j>R;j--)
                    {
                        if(Elements[j][i]!=0)
                        {
                                Temp=j;
                                break;
                        }
                    }

for(int k=R+1;k<Row;k++)
                        {
                            float []Array=new float[Column];
                            for(int l=0;l<Column;l++)
                            {
                                Array[l]=Elements[k][l] - ((Elements[R][l]*Elements[k][i])/Elements[R][i]);
                            }
                            for(int l=0;l<Column;l++)
                            {
                                Elements[k][l]=Array[l];
                            }
                        }
                        R++;
                    }
                }
            }
        }

}

public void Display()
    {
        System.out.println("\n\n");
        for(int i=0;i<Row;i++)
        {
            for(int j=0;j<Column;j++)
            {
                if(Elements[i][j]==(-0.0)){Elements[i][j]=0;}
                System.out.print(Elements[i][j]+"  ");
            }
            System.out.println();
        }
    }
}

Main Class

Algorithm Of Solving Row Reduced Echelon Form Of Matrix

As this guy say, no one have time for solving Row Reduce Echelon Form for Matrix.
Here I have Algorithm for solving RREF for your Matrix

import java.util.Scanner;

public class Matrix {
    
    private int Row; //NO OF ROWS
    private int Column; //NO OF COLUMNS
    private float [][]Elements;//FOR CARRING ELEMENTS

}
        else
        {
            write=false;
            System.out.println("\nYOU CAN NOT MAKE MATRIX WITH THIS DIMENTIONS.\n");
        }
    }

public void SET_ELEMENTS_OF_MATRIX()
    {
        Scanner x=new Scanner(System.in);

for(int i=0;i<Row;i++)
        {
            for(int j=0;j<Column;j++)
            {
                System.out.println("ENTER ["+i+"]["+j+"] ELEMENT OF MATRIX :- ");
                Elements[i][j]=x.nextFloat();
            }
        }
    }
    
    private void Algorithms_of_EF()
    {
        int R=0;
        for(int i=0;i<Column;i++)
        {
            if(R<Row)
            {  
                if(Elements[R][i]!=0)
                {
                                      
                    for(int k=R+1;k<Row;k++)
                    {
                        float []Array=new float[Column];
                        for(int l=0;l<Column;l++)
                        {
                            Array[l]=Elements[k][l] - ((Elements[R][l]*Elements[k][i])/Elements[R][i]);
                        }
                        for(int l=0;l<Column;l++)
                        {
                            Elements[k][l]=Array[l];
                        }
                    }
                    R++; 
                }
                else
                {
                    int Temp=-1;
                    for(int j=(Row-1);j>R;j--)
                    {
                        if(Elements[j][i]!=0)
                        {
                                Temp=j;
                                break;
                        }
                    }

}

private void Entry()
    {
        int Temp=-1;int R=0;
        for(int i=0;i<Column;i++)
        {
            if(R<Row)
            {  
                if(Elements[R][i]!=0)
                {
                    float []Array=new float[Column];
                    for(int d=0;d<Column;d++)
                    {
                            Array[d]=Elements[R][d]/Elements[R][i];
                    }
                    for(int d=0;d<Column;d++)
                    {
                            Elements[R][d]=Array[d];
                    }
                    R++; 
                }
            }
        }    
    }

public void GET_RREF_FORM()
    {
        Algorithms_of_EF();
        Entry(); 
        int Temp=-1;int R=0;
        for(int i=0;i<Column;i++)
        {
            if(R<Row)
            {  
                if(Elements[R][i]!=0)
                {
                    for(int k=R-1;k>=0;k--)
                    {
                        float []Array=new float[Column];
                        for(int l=0;l<Column;l++)
                        {
                            Array[l]=Elements[k][l] - ((Elements[R][l]*Elements[k][i])/Elements[R][i]);
                        }
                        for(int l=0;l<Column;l++)
                        {
                            Elements[k][l]=Array[l];
                        }
                    }
                    R++; 
                }
            }
        }
        Display();
    }

Main Class

Friday, 1 May 2015

VERILOG CODE FOR ALU

Here i put verilog code for ALU designing. Here I design ALU different part like Adder-subtractor block, Logic block, Shifter block and comparacter block with behavioural and stractural logic.

Here i provide one link from which you are able to download whole verilog code of ALU.
Download here

Open this file in your text editor and i also provide logic of block with commented part so you can understand.
If you find any query that please commented that I try to solve that.

Saturday, 28 March 2015

HOW TO CLEAN BOOTABLE USB

Open your command prompt and type code as under

1. From Command prompt type ‘diskpart‘

If window ask for administrator permission than click on YES.

2. type list disk

3. it should then look something like this:

DISKPART> list disk

Disk ### Status Size Free Dyn Gpt

——– ————- ——- ——- — —

Disk 0 Online 465 GB 3072 KB

Disk 1 Online 7728GB 0 B

4. Once we see which Disk is your USB drive, you will want to type ‘select disk‘ (change “disk 1″ to the number of your drive):

5. DISKPART> select disk 1

Disk 1 is now the selected disk.

6. DISKPART> clean

DiskPart succeeded in cleaning the disk.

7. DISKPART> create partition primary

DiskPart succeeded in creating the specified partition.

8. DISKPART> select partition 1

Partition 1 is now the selected partition.

9. DISKPART> active

DiskPart marked the current partition as active.

10. DISKPART> format fs=ntfs quick

100 percent completed

DiskPart successfully formatted the volume.

11. DISKPART> assign

DiskPart successfully assigned the drive letter or mount point.

COMPLETE!