Computer Science Engineering (CSE)  >  Algorithms  >  Sorting Algorithms- 2

Sorting Algorithms- 2 Notes | Study Algorithms - Computer Science Engineering (CSE)

Document Description: Sorting Algorithms- 2 for Computer Science Engineering (CSE) 2022 is part of Algorithms preparation. The notes and questions for Sorting Algorithms- 2 have been prepared according to the Computer Science Engineering (CSE) exam syllabus. Information about Sorting Algorithms- 2 covers topics like Bubble Sort and Sorting Algorithms- 2 Example, for Computer Science Engineering (CSE) 2022 Exam. Find important definitions, questions, notes, meanings, examples, exercises and tests below for Sorting Algorithms- 2.

Introduction of Sorting Algorithms- 2 in English is available as part of our Algorithms for Computer Science Engineering (CSE) & Sorting Algorithms- 2 in Hindi for Algorithms course. Download more important topics related with notes, lectures and mock test series for Computer Science Engineering (CSE) Exam by signing up for free. Computer Science Engineering (CSE): Sorting Algorithms- 2 Notes | Study Algorithms - Computer Science Engineering (CSE)
Table of contents
Bubble Sort
1 Crore+ students have signed up on EduRev. Have you?

Bubble Sort

Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in wrong order.

Example: 
First Pass: 
( 5 1 4 2 8 ) –> ( 1 5 4 2 8 ), Here, algorithm compares the first two elements, and swaps since 5 > 1.
( 1 5 4 2 8 ) –>  ( 1 4 5 2 8 ), Swap since 5 > 4
( 1 4 5 2 8 ) –>  ( 1 4 2 5 8 ), Swap since 5 > 2
( 1 4 2 5 8 ) –> ( 1 4 2 5 8 ), Now, since these elements are already in order (8 > 5), algorithm does not swap them.
Second Pass: 
( 1 4 2 5 8 ) –> ( 1 4 2 5 8 )
( 1 4 2 5 8 ) –> ( 1 2 4 5 8 ), Swap since 4 > 2
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) –>  ( 1 2 4 5 8 )
Now, the array is already sorted, but our algorithm does not know if it is completed. The algorithm needs one whole pass without any swap to know it is sorted.
Third Pass: 
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )

Following is the implementations of Bubble Sort.

  • C++
    // C++ program for implementation of Bubble sort
    #include <bits/stdc++.h>
    using namespace std;
    void swap(int *xp, int *yp)
    {
        int temp = *xp;
        *xp = *yp;
        *yp = temp;
    }
    // A function to implement bubble sort
    void bubbleSort(int arr[], int n)
    {
        int i, j;
        for (i = 0; i < n-1; i++)
        // Last i elements are already in place
        for (j = 0; j < n-i-1; j++)
            if (arr[j] > arr[j+1])
                swap(&arr[j], &arr[j+1]);
    }
    /* Function to print an array */
    void printArray(int arr[], int size)
    {
        int i;
        for (i = 0; i < size; i++)
            cout << arr[i] << " ";
        cout << endl;
    }
    // Driver code
    int main()
    {
        int arr[] = {64, 34, 25, 12, 22, 11, 90};
        int n = sizeof(arr)/sizeof(arr[0]);
        bubbleSort(arr, n);
        cout<<"Sorted array: \n";
        printArray(arr, n);
        return 0;
    }
    // This code is contributed by rathbhupendra
  • C
    // C program for implementation of Bubble sort
    #include <stdio.h>
    void swap(int *xp, int *yp)
    {
        int temp = *xp;
        *xp = *yp;
        *yp = temp;
    }
    // A function to implement bubble sort
    void bubbleSort(int arr[], int n)
    {
       int i, j;
       for (i = 0; i < n-1; i++)
           // Last i elements are already in place
           for (j = 0; j < n-i-1; j++)
               if (arr[j] > arr[j+1])
                  swap(&arr[j], &arr[j+1]);
    }
    /* Function to print an array */
    void printArray(int arr[], int size)
    {
        int i;
        for (i=0; i < size; i++)
            printf("%d ", arr[i]);
        printf("\n");
    }
    // Driver program to test above functions
    int main()
    {
        int arr[] = {64, 34, 25, 12, 22, 11, 90};
        int n = sizeof(arr)/sizeof(arr[0]);
        bubbleSort(arr, n);
        printf("Sorted array: \n");
        printArray(arr, n);
        return 0;
    }
  • Java
    // Java program for implementation of Bubble Sort
    class BubbleSort
    {
        void bubbleSort(int arr[])
        {
            int n = arr.length;
            for (int i = 0; i < n-1; i++)
                for (int j = 0; j < n-i-1; j++)
                    if (arr[j] > arr[j+1])
                    {
                        // swap arr[j+1] and arr[j]
                        int temp = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                    }
        }
        /* Prints the array */
        void printArray(int arr[])
        {
            int n = arr.length;
            for (int i=0; i<n; ++i)
                System.out.print(arr[i] + " ");
            System.out.println();
        }
        // Driver method to test above
    public static void main(String args[])
        {
            BubbleSort ob = new BubbleSort();
            int arr[] = {64, 34, 25, 12, 22, 11, 90};
            ob.bubbleSort(arr);
            System.out.println("Sorted array");
            ob.printArray(arr);
        }
    }
    /* This code is contributed by Rajat Mishra */
  • Python
    # Python program for implementation of Bubble Sort
    def bubbleSort(arr):
        n = len(arr)
        # Traverse through all array elements
        for i in range(n):
            # Last i elements are already in place
            for j in range(0, n-i-1):
                # traverse the array from 0 to n-i-1
                # Swap if the element found is greater
                # than the next element
                if arr[j] > arr[j+1] :
                    arr[j], arr[j+1] = arr[j+1], arr[j]
    # Driver code to test above
    arr = [64, 34, 25, 12, 22, 11, 90]
    bubbleSort(arr)
    print ("Sorted array is:")
    for i in range(len(arr)):
        print ("%d" %arr[i]),
  • C#
    // C# program for implementation
    // of Bubble Sort
    using System;
    class GFG
    {
        static void bubbleSort(int []arr)
        {
            int n = arr.Length;
            for (int i = 0; i < n - 1; i++)
                for (int j = 0; j < n - i - 1; j++)
                    if (arr[j] > arr[j + 1])
                    {
                        // swap temp and arr[i]
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
        }
        /* Prints the array */
        static void printArray(int []arr)
        {
            int n = arr.Length;
            for (int i = 0; i < n; ++i)
                Console.Write(arr[i] + " ");
            Console.WriteLine();
        }
        // Driver method
        public static void Main()
        {
            int []arr = {64, 34, 25, 12, 22, 11, 90};
            bubbleSort(arr);
            Console.WriteLine("Sorted array");
            printArray(arr);
        }
    }
    // This code is contributed by Sam007
  • PHP
    <?php
    // PHP program for implementation
    // of Bubble Sort
    function bubbleSort(&$arr)
    {
        $n = sizeof($arr);
        // Traverse through all array elements
        for($i = 0; $i < $n; $i++)
        {
            // Last i elements are already in place
            for ($j = 0; $j < $n - $i - 1; $j++)
            {
                // traverse the array from 0 to n-i-1
                // Swap if the element found is greater
                // than the next element
                if ($arr[$j] > $arr[$j+1])
                {
                    $t = $arr[$j];
                    $arr[$j] = $arr[$j+1];
                    $arr[$j+1] = $t;
                }
            }
        }
    }
    // Driver code to test above
    $arr = array(64, 34, 25, 12, 22, 11, 90);
    $len = sizeof($arr);
    bubbleSort($arr);
    echo "Sorted array : \n";
    for ($i = 0; $i < $len; $i++)
        echo $arr[$i]." ";
    // This code is contributed by ChitraNayal.
    ?>
  • Javascript
    <script>
    function swap(arr, xp, yp)
    {
        var temp = arr[xp];
        arr[xp] = arr[yp];
        arr[yp] = temp;
    }
    // An optimized version of Bubble Sort
    function bubbleSort( arr, n)
    {
    var i, j;
    for (i = 0; i < n-1; i++)
    {
        for (j = 0; j < n-i-1; j++)
        {
            if (arr[j] > arr[j+1])
            {
            swap(arr,j,j+1);
            }
        }
    }
    }
    /* Function to print an array */
    function printArray(arr, size)
    {
        var i;
        for (i=0; i < size; i++)
            document.write(arr[i]+ " ");
        document.write("\n");
    }
    // Driver program to test above functions
      var arr = [64, 34, 25, 12, 22, 11, 90];
        var n = 7;
        document.write("UnSorted array: \n");
        printArray(arr, n);
        bubbleSort(arr, n);
        document.write("Sorted array: \n");
        printArray(arr, n);
    </script>

Output:
Sorted array:
11 12 22 25 34 64 90
<!—-Illustration:
Sorting Algorithms- 2 Notes | Study Algorithms - Computer Science Engineering (CSE) —>
Optimized Implementation: 
The above function always runs O(n^2) time even if the array is sorted. It can be optimized by stopping the algorithm if inner loop didn’t cause any swap.

  • CPP
    // Optimized implementation of Bubble sort
    #include <stdio.h>
    void swap(int *xp, int *yp)
    {
        int temp = *xp;
        *xp = *yp;
        *yp = temp;
    }
    // An optimized version of Bubble Sort
    void bubbleSort(int arr[], int n)
    {
       int i, j;
       bool swapped;
       for (i = 0; i < n-1; i++)
       {
         swapped = false;
         for (j = 0; j < n-i-1; j++)
         {
            if (arr[j] > arr[j+1])
            {
               swap(&arr[j], &arr[j+1]);
               swapped = true;
            }
           }
         // IF no two elements were swapped by inner loop, then break
         if (swapped == false)
            break;
       }
    }
    /* Function to print an array */
    void printArray(int arr[], int size)
    {
        int i;
        for (i=0; i < size; i++)
            printf("%d ", arr[i]);
        printf("n");
    }
    // Driver program to test above functions
    int main()
    {
        int arr[] = {64, 34, 25, 12, 22, 11, 90};
        int n = sizeof(arr)/sizeof(arr[0]);
        bubbleSort(arr, n);
        printf("Sorted array: \n");
        printArray(arr, n);
        return 0;
    }
  • Java
    // Optimized java implementation
    // of Bubble sort
    import java.io.*;
    class GFG
    {
        // An optimized version of Bubble Sort
        static void bubbleSort(int arr[], int n)
        {
            int i, j, temp;
            boolean swapped;
            for (i = 0; i < n - 1; i++)
            {
                swapped = false;
                for (j = 0; j < n - i - 1; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        // swap arr[j] and arr[j+1]
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                        swapped = true;
                    }
                }
                // IF no two elements were
                // swapped by inner loop, then break
                if (swapped == false)
                    break;
            }
        }
        // Function to print an array
        static void printArray(int arr[], int size)
        {
            int i;
            for (i = 0; i < size; i++)
                System.out.print(arr[i] + " ");
            System.out.println();
        }
        // Driver program
        public static void main(String args[])
        {
            int arr[] = { 64, 34, 25, 12, 22, 11, 90 };
            int n = arr.length;
            bubbleSort(arr, n);
            System.out.println("Sorted array: ");
            printArray(arr, n);
        }
    }
    // This code is contributed
    // by Nikita Tiwari.
  • Python3
    # Python3 Optimized implementation
    # of Bubble sort
    # An optimized version of Bubble Sort
    def bubbleSort(arr):
        n = len(arr)
        # Traverse through all array elements
        for i in range(n):
            swapped = False
            # Last i elements are already
            #  in place
            for j in range(0, n-i-1):
                # traverse the array from 0 to
                # n-i-1. Swap if the element
                # found is greater than the
                # next element
                if arr[j] > arr[j+1] :
                    arr[j], arr[j+1] = arr[j+1], arr[j]
                    swapped = True
            # IF no two elements were swapped
            # by inner loop, then break
            if swapped == False:
                break
    # Driver code to test above
    arr = [64, 34, 25, 12, 22, 11, 90]
    bubbleSort(arr)
    print ("Sorted array :")
    for i in range(len(arr)):
        print ("%d" %arr[i],end=" ")
    # This code is contributed by Shreyanshi Arun
  • C#
    // Optimized C# implementation
    // of Bubble sort
    using System;
    class GFG
    {
        // An optimized version of Bubble Sort
        static void bubbleSort(int []arr, int n)
        {
            int i, j, temp;
            bool swapped;
            for (i = 0; i < n - 1; i++)
            {
                swapped = false;
                for (j = 0; j < n - i - 1; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        // swap arr[j] and arr[j+1]
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                        swapped = true;
                    }
                }
                // IF no two elements were
                // swapped by inner loop, then break
                if (swapped == false)
                    break;
            }
        }
        // Function to print an array
        static void printArray(int []arr, int size)
        {
            int i;
            for (i = 0; i < size; i++)
                Console.Write(arr[i] + " ");
            Console.WriteLine();
        }
        // Driver method
        public static void Main()
        {
            int []arr = {64, 34, 25, 12, 22, 11, 90};
            int n = arr.Length;
            bubbleSort(arr,n);
            Console.WriteLine("Sorted array");
            printArray(arr,n);
        }
    }
    // This code is contributed by Sam007
  • PHP
    <?php
    // PHP Optimized implementation
    // of Bubble sort
    // An optimized version of Bubble Sort
    function bubbleSort(&$arr)
    {
        $n = sizeof($arr);
        // Traverse through all array elements
        for($i = 0; $i < $n; $i++)
        {
            $swapped = False;
            // Last i elements are already
            // in place
            for ($j = 0; $j < $n - $i - 1; $j++)
            {
                // traverse the array from 0 to
                // n-i-1. Swap if the element
                // found is greater than the
                // next element
                if ($arr[$j] > $arr[$j+1])
                {
                    $t = $arr[$j];
                    $arr[$j] = $arr[$j+1];
                    $arr[$j+1] = $t;
                    $swapped = True;
                }
            }
            // IF no two elements were swapped
            // by inner loop, then break
            if ($swapped == False)
                break;
        }
    }
    // Driver code to test above
    $arr = array(64, 34, 25, 12, 22, 11, 90);
    $len = sizeof($arr);
    bubbleSort($arr);
    echo "Sorted array : \n";
    for($i = 0; $i < $len; $i++)
        echo $arr[$i]." ";
    // This code is contributed by ChitraNayal.
    ?>

Output:
Sorted array:
11 12 22 25 34 64 90
Worst and Average Case Time Complexity: O(n*n). Worst case occurs when array is reverse sorted.
Best Case Time Complexity: O(n). Best case occurs when array is already sorted.
Auxiliary Space: O(1)
Boundary Cases: Bubble sort takes minimum time (Order of n) when elements are already sorted.
Sorting In Place: Yes
Stable: Yes
Due to its simplicity, bubble sort is often used to introduce the concept of a sorting algorithm.
In computer graphics it is popular for its capability to detect a very small error (like swap of just two elements) in almost-sorted arrays and fix it with just linear complexity (2n). For example, it is used in a polygon filling algorithm, where bounding lines are sorted by their x coordinate at a specific scan line (a line parallel to x axis) and with incrementing y their order changes (two elements are swapped) only at intersections of two lines

The document Sorting Algorithms- 2 Notes | Study Algorithms - Computer Science Engineering (CSE) is a part of the Computer Science Engineering (CSE) Course Algorithms.
All you need of Computer Science Engineering (CSE) at this link: Computer Science Engineering (CSE)
60 docs|33 tests
Download as PDF

Download free EduRev App

Track your progress, build streaks, highlight & save important lessons and more!

Related Searches

pdf

,

Important questions

,

Semester Notes

,

study material

,

Free

,

Sample Paper

,

MCQs

,

past year papers

,

Objective type Questions

,

Exam

,

shortcuts and tricks

,

mock tests for examination

,

Previous Year Questions with Solutions

,

Sorting Algorithms- 2 Notes | Study Algorithms - Computer Science Engineering (CSE)

,

video lectures

,

Extra Questions

,

practice quizzes

,

Sorting Algorithms- 2 Notes | Study Algorithms - Computer Science Engineering (CSE)

,

Sorting Algorithms- 2 Notes | Study Algorithms - Computer Science Engineering (CSE)

,

Viva Questions

,

Summary

,

ppt

;