Scribd Logo
Upload

Welcome to Scribd!

  • 51 views

    Quick Sort Viva2

    Uploaded by

    Subathra Devi Mourougane
    Quick sort is a sorting algorithm that works by selecting a pivot element and partitioning the array around that element. It recursively sorts the subarrays on each side of the pivot until the entire array is sorted. The algorithm runs in O(n log n) time on average but can degrade to O(n^2) time in the worst case if the array is already sorted. The code sample shows the functions for partitioning the array around a pivot and recursively calling quicksort on the subarrays.

    Copyright:

    © All Rights Reserved
    Download as DOC, PDF, TXT or read online from Scribd

    Quick Sort Viva2

    Uploaded by

    Subathra Devi Mourougane
    51 views5 pages
    Quick sort is a sorting algorithm that works by selecting a pivot element and partitioning the array around that element. It recursively sorts the subarrays on each side of the pivot until the entire array is sorted. The algorithm runs in O(n log n) time on average but can degrade to O(n^2) time in the worst case if the array is already sorted. The code sample shows the functions for partitioning the array around a pivot and recursively calling quicksort on the subarrays.

    Original Description:

    Quick Sort Viva2

    Copyright

    © © All Rights Reserved

    Available Formats

    DOC, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    Quick sort is a sorting algorithm that works by selecting a pivot element and partitioning the array around that element. It recursively sorts the subarrays on each side of the pivot until the entire array is sorted. The algorithm runs in O(n log n) time on average but can degrade to O(n^2) time in the worst case if the array is already sorted. The code sample shows the functions for partitioning the array around a pivot and recursively calling quicksort on the subarrays.

    Copyright:

    © All Rights Reserved
    Download as DOC, PDF, TXT or read online from Scribd
    Download as doc, pdf, or txt
    51 views5 pages

    Quick Sort Viva2

    Uploaded by

    Subathra Devi Mourougane
    Quick sort is a sorting algorithm that works by selecting a pivot element and partitioning the array around that element. It recursively sorts the subarrays on each side of the pivot until the entire array is sorted. The algorithm runs in O(n log n) time on average but can degrade to O(n^2) time in the worst case if the array is already sorted. The code sample shows the functions for partitioning the array around a pivot and recursively calling quicksort on the subarrays.

    Copyright:

    © All Rights Reserved
    Download as DOC, PDF, TXT or read online from Scribd
    Download as doc, pdf, or txt
    of 5

    MAILAM ENGINEERING COLLEGE

    (Approved by AICTE, New Delhi, Affiliated to Anna University Chennai


    & Accredited by National Board of Accreditation (NBA) New Delhi)

    Mailam, Villupuram - 604 304

    DEPARTMENT OF COMPUTER APPLICATIONS


    ALGORITHMS LAB MC9229
    (VIVA QUESTIONS WITH ANSWERS)

    QUICK SORT
    1. What is meant by Quick sort?
    Quick sort is a well-known sorting algorithm developed by C. A. R. Hoare that,
    on average, makes (n log n) comparisons to sort n items. Quick sort is significantly
    faster in practice than other (n log n) algorithms, because its inner loop can be
    efficiently implemented on most architecture, and in most real-world data.
    2. How to choice of pivot element?
    In quick sort the leftmost element of the partition would often be chosen as
    the pivot element. Selecting a pivot element is also complicated by the existence of
    integer overflow.
    3. List out the types of Scan methods?
    If the boundary indices of the sub-array being sorted are sufficiently large,
    the nave expression for the middle index, (left + right)/2, will cause overflow and
    provide an invalid pivot index.
    This can be overcome by using, for example, left + (right-left)/2 to index the
    middle element, at the cost of more complex arithmetic. Similar issues arise in some
    other methods of selecting the pivot element.
    4. How quick sort works?
    The basic idea of Quick sort is to repeatedly divide the array into smaller
    pieces, and to recursively sort those partitions. Quick sort divides the current
    partition by choosing an element - the pivot - finding which of the other elements is
    smaller or larger, sorting them into two different sub-partitions.
    5. Write the operations of quick sort?

    Divide: Partition array A[l..r] into 2 subarrays, A[l..s-1] and A[s+1..r] such
    that each element of the first array is A[s] and each element of the second
    array is A[s].

    Implication: A[s] will be in its final position in the sorted array.

    Conquer: Sort the two subarrays A[l..s-1] and A[s+1..r] by recursive calls to
    quicksort

    Combine: No work is needed, because A[s] is already in its correct place after
    the partition is done, and the two subarrays have been sorted.

    6. What are the three situations may arise depending upon the scanning
    indices have crossed in quick sort?

    If scanning indices I and j have not corssed, i< j we simply exchange A[i] and
    A[j] and resumes the scan by incrementing I and decrementing j respectively:
    i
    j

    p
    all are p
    are p

    ...

    all

    If the scanning indices have crossed over , i> j we have partitioned the array
    after exchanging the pivot with A[j]:
    Finally if the scanning indices stop while pointing to the same element, i=j,
    the value they are pointing to must be equal to p. Thus we have partitioned
    the array

    7. Write the efficiency of quick sort?


    Efficiency of Quick sort Based on whether the partitioning is balanced.

    Best case: split in the middle ( n log n)


    o C(n) = 2C(n/2) + (n)
    //2 subproblems of size n/2 each
    Worst case: sorted array! ( n2)
    o C(n) = C(n-1) + n+1 //2 subproblems of size 0 and n-1 respectively
    Average case: random arrays ( n log n)

    SUBJECT IN-CHARGE

    HOD

    PRINCIPAL

    QUICK SORT

    #include<stdio.h>
    #include<conio.h>
    void main()
    {
    int a[10],i,n;
    void quicksort(int [],int,int);
    clrscr();
    printf("\n\t\t\t QUICK SORT");
    printf("\n\t\t\t ==========\n");
    printf("\n\t\t ENTER THE NUMBER OF TERMS:");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
    printf("\n\t\t ENTER %d VALUE:",i+1);
    scanf("%d",&a[i]);
    }
    quicksort(a,0,n-1);
    printf("\n\t\t THE SORTED ELEMENTS ARE AS FOLLOWS:");
    for(i=0;i<n;i++)
    {
    printf("\n\n\t\t\t\t\t%d",a[i]);
    }
    getch();
    }
    int partition(int a[],int l,int r)
    {
    int p,i,j,temp;
    p = a[l];
    i = l;
    j = r+1;
    while(i<j)
    {

    do
    {
    i++;
    }
    while(a[i]<p);
    {
    do
    {
    j--;
    }
    while(a[j]>p);
    {
    if(i<j)
    {
    temp = a[i];
    a[i] = a[j];
    a[j] = temp;
    }
    }
    }
    }
    a[l] = a[j];
    a[j] = p;
    return(j);
    }
    void quicksort(int a[],int l,int r)
    {
    int s;
    int partition(int [],int,int);
    if(l>=r)
    {
    return;
    }
    s = partition(a,l,r);

    quicksort(a,l,s-1);
    quicksort(a,s+1,r);
    }
    OUTPUT:
    QUICK SORT
    ========
    ENTER THE NUMBER OF TERMS:5
    ENTER 1 VALUE:56
    ENTER 2 VALUE:86
    ENTER 3 VALUE:12
    ENTER 4 VALUE:-1
    ENTER 5 VALUE:0
    THE SORTED ELEMENTS ARE AS FOLLOWS:
    -1
    0
    12
    56
    86

    You might also like