Program to perform Multiplication of 2 Matrices.

Code:

import java.util.Scanner;
public class MatrixMultiplication
{
   public static void main(String args[])
   {
      int m, n, p, q, sum = 0, c, d, k;

      Scanner in = new Scanner(System.in);
      System.out.println("Enter the number of rows and columns of first matrix");
      m = in.nextInt();
      n = in.nextInt();

      int first[][] = new int[m][n];

      System.out.println("Enter the elements of first matrix");

      for ( c = 0 ; c < m ; c++ )
         for ( d = 0 ; d < n ; d++ )
            first[c][d] = in.nextInt();

      System.out.println("Enter the number of rows and columns of second matrix");
      p = in.nextInt();
      q = in.nextInt();

      if ( n != p )
         System.out.println("Matrices with entered orders can't be multiplied with each other.");
      else
      {
         int second[][] = new int[p][q];
         int multiply[][] = new int[m][q];

         System.out.println("Enter the elements of second matrix");

         for ( c = 0 ; c < p ; c++ )
            for ( d = 0 ; d < q ; d++ )
               second[c][d] = in.nextInt();

         for ( c = 0 ; c < m ; c++ )
         {
            for ( d = 0 ; d < q ; d++ )
            {  
               for ( k = 0 ; k < p ; k++ )
               {
                  sum = sum + first[c][k]*second[k][d];
               }

               multiply[c][d] = sum;
               sum = 0;
            }
         }

         System.out.println("Product of entered matrices:-");

         for ( c = 0 ; c < m ; c++ )
         {
            for ( d = 0 ; d < q ; d++ )
               System.out.print(multiply[c][d]+"\t");

            System.out.print("\n");
         }
      }
   }
}

Program to find the Transpose of a Matrix.

Code:

import java.util.Scanner;

public class Transpose

{ 

   public static void main(String args[])

   { 

          int m, n, c, d; 

          Scanner in = new Scanner(System.in); 

          System.out.println("Enter the number of rows and columns of matrix"); 

          m = in.nextInt(); n = in.nextInt(); int matrix[][] = new int[m][n]; 

         System.out.println("Enter the elements of matrix"); 

         for ( c = 0 ; c < m ; c++ ) 

             for ( d = 0 ; d < n ; d++ ) 

                matrix[c][d] = in.nextInt(); 

         int transpose[][] = new int[n][m]; 

         for ( c = 0 ; c < m ; c++ ) 

        {

            for ( d = 0 ; d < n ; d++ ) 

                transpose[d][c] = matrix[c][d]; 

         }

         System.out.println("Transpose of entered matrix:-"); 

        for ( c = 0 ; c < n ; c++ ) 

       { 

           for ( d = 0 ; d < m ; d++ ) 

               System.out.print(transpose[c][d]+"\t"); 

               System.out.print("\n");

        }

   } 

}

Program to Add or Subtract two Matrices.

Code:

import java.util.Scanner;

public class Add

{

     public static void main(String args[])

    { 

          int m, n, c, d; 

          Scanner in = new Scanner(System.in); 

          System.out.println("Enter the number of rows and columns of matrix"); 

          m = in.nextInt(); 

          n = in.nextInt(); 

         int first[][] = new int[m][n]; int second[][] = new int[m][n]; int sum[][] = new int[m][n]; 

         System.out.println("Enter the elements of first matrix"); 

         for ( c = 0 ; c < m ; c++ ) 

           for ( d = 0 ; d < n ; d++ ) 

              first[c][d] = in.nextInt(); 

        System.out.println("Enter the elements of second matrix"); 

        for ( c = 0 ; c < m ; c++ ) 

           for ( d = 0 ; d < n ; d++ ) 

              second[c][d] = in.nextInt(); 

       for ( c = 0 ; c < m ; c++ ) 

            for ( d = 0 ; d < n ; d++ ) 

               sum[c][d] = first[c][d] + second[c][d]; //replace '+' with '-' to subtract matrices     

      System.out.println("Sum of entered matrices:-"); 

      for ( c = 0 ; c < m ; c++ ) 

     {

          for ( d = 0 ; d < n ; d++ ) 

               System.out.print(sum[c][d]+"\t"); 

               System.out.println();

      }

  }

 }

Program to perform Selection Sort.

Code:

public class MySelectionSort
{
    public static int[] doSelectionSort(int[] arr)
    {    
        for (int i = 0; i < arr.length - 1; i++)
        {
            int index = i;
            for (int j = i + 1; j < arr.length; j++)
                if (arr[j] < arr[index])
                    index = j;
     
            int smallerNumber = arr[index]; 
            arr[index] = arr[i];
            arr[i] = smallerNumber;
        }
        return arr;
    }
    
    public static void main(String a[])
    {        
        int[] arr1 = {10,34,2,56,7,67,88,42};
        int[] arr2 = doSelectionSort(arr1);
        for(int i:arr2)
        {
            System.out.println(i);
           
        }
    }
}

Program to perform Insertion Sort.

Code:

public class MyInsertionSort
{
    public static void main(String a[])
    {
        int[] arr1 = {10,34,2,56,7,67,88,42};
        int[] arr2 = doInsertionSort(arr1);
        for(int i:arr2)
        {
            System.out.print(i);
            System.out.print(", ");
        }
    }
    
    public static int[] doInsertionSort(int[] input)
    {    
        int temp;
        for (int i = 1; i < input.length; i++)
        {
            for(int j = i ; j > 0 ; j--)
            {
                if(input[j] < input[j-1])
                {
                    temp = input[j];
                    input[j] = input[j-1];
                    input[j-1] = temp;
                }
            }
        }
        return input;
    }
}

Program to perform Quick Sort.

Code:

public class QuickSort
{    
    private int array[];
    private int length;
    public void sort(int[] inputArr)
    {        
        if (inputArr == null || inputArr.length == 0)
        {
            return;
        }
        this.array = inputArr;
        length = inputArr.length;
        quickSort(0, length - 1);
    }

    private void quickSort(int lowerIndex, int higherIndex)
    {    
        int i = lowerIndex;
        int j = higherIndex;
        // calculate pivot number, I am taking pivot as middle index number
        int pivot = array[lowerIndex+(higherIndex-lowerIndex)/2];
        // Divide into two arrays
        while (i <= j)
        {        
            while (array[i] < pivot)
            {
                i++;
            }
            while (array[j] > pivot)
            {
                j--;
            }
            if (i <= j)
            {
                exchangeNumbers(i, j);
                //move index to next position on both sides
                i++;
                j--;
            }
        }
        // call quickSort() method recursively
        if (lowerIndex < j)
            quickSort(lowerIndex, j);
        if (i < higherIndex)
            quickSort(i, higherIndex);
    }

    private void exchangeNumbers(int i, int j)
    {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    
    public static void main(String a[])
    {        
        QuickSort sorter = new QuickSort();
        int[] input = {24,2,45,20,56,75,2,56,99,53,12};
        sorter.sort(input);
        for(int i:input)
        {
            System.out.print(i);
            System.out.print(" ");
        }
    }
}

Program to perform Merge Sort.

Code:

public class MergeSort
{    
    private int[] array;
    private int[] tempMergArr;
    private int length;
    public static void main(String args[])
    {        
        int[] inputArr = {45,23,11,89,77,98,4,28,65,43};
        MergeSort mms = new MergeSort();
        mms.sort(inputArr);
        for(int i:inputArr)
        {
            System.out.print(i);
            System.out.print(" ");
        }
    }
    
    public void sort(int inputArr[])
    {
        this.array = inputArr;
        this.length = inputArr.length;
        this.tempMergArr = new int[length];
        doMergeSort(0, length - 1);
    }

    private void doMergeSort(int lowerIndex, int higherIndex)
    {        
        if (lowerIndex < higherIndex)
        {
            int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
            // Below step sorts the left side of the array
            doMergeSort(lowerIndex, middle);
            // Below step sorts the right side of the array
            doMergeSort(middle + 1, higherIndex);
            // Now merge both sides
            mergeParts(lowerIndex, middle, higherIndex);
        }
    }

    private void mergeParts(int lowerIndex, int middle, int higherIndex)
    {
        for (int i = lowerIndex; i <= higherIndex; i++)
        {
            tempMergArr[i] = array[i];
        }
        int i = lowerIndex;
        int j = middle + 1;
        int k = lowerIndex;
        while (i <= middle && j <= higherIndex)
        {
            if (tempMergArr[i] <= tempMergArr[j])
            {
                array[k] = tempMergArr[i];
                i++;
            }
            else
            {
                array[k] = tempMergArr[j];
                j++;
            }
            k++;
        }
        while (i <= middle)
        {
            array[k] = tempMergArr[i];
            k++;
            i++;
        }
     }
}

Program to perform Bubble Sort.

Code:

public class Bubble
{
   public static void main(String args[])
   {         
            int[] a = {4, 85, 7, 1, 0, 36, -5, 48};
           for (int i = 0; i < a.length - 1; i++)
           {
                   for (int j = 0; j < a.length - 1 - i; j++)
                  {
                        if (a[j + 1] < a[j])
                       {
                             int temp = a[j];
                             a[j] = a[j + 1];
                             a[j + 1] = temp;
                       }
                  }
             }
            for (int i = 0; i < a.length - 1; i++)
           {
               System.out.println(a[i]);
           }
     }
}

Program to perform Binary Search.

Code:

public class binary
{
   public static void main(String args[])
   {         int[] a = {3, 7, 10, 15, 91, 110, 150};
         int target = 91; // the element to be searched
         int left = 0;
         int middle;
         int right = a.length - 1;
         while (left < = right)
        {
              middle = (left + right) / 2;
              if (a[middle] == target)
            {
                 System.out.println("Element found at index " + middle);
                 break;
             }
             else if (a[middle] < target)
            {
                 left = middle + 1;
             }
             else if (a[middle] > target)
            {
                right = middle - 1;
             }
        }
  }
}

Program to perform Linear Search.

Code:

class linear
{
   public static void main(String args[])
   {
        int[] a = { 3, 34, 5,91, 100};
        int target = 91,flag=0;
        for( int i=0; i<a.length; i++)
       {
               if(a[i] == target)
              {
                   flag=1;
                   System.out.println ( "Element found at index "+i);
                   break;
              }
       }
       if(flag==0)  System.out.println ( "Element not found");
   }
}

Program to find the Sum of Elements in an Array.

Code:

public class SumOfArray
{
      public static void main(String args[])
     {
          int[] array = {10, 20, 30, 40, 50, 10};
          int sum = 0;
          for( int num : array)
         {
              sum = sum+num;
           }
          System.out.println("Sum of array elements is:"+sum);
     }
}