find a time consumed[taken] for sorting a given array-"quick sort"

Hi,

I am sorry to tell you, but the segmentation fault probably comes from the many, many errors in your code. I got a stack overflow when I tried the code, but let's go through it.

Your main procedure is okay, but should look more like this:

void main()
{
    int a[MAX], n, i;    // remove start and end here and
    clock_t end, start;  // uncomment this again
    // double CLK_TCK;  .. this you should not need, it's already defined

    // [..]

    for(i=0;i<n;++i)    // Use < here instead of <= or you ask for n+1 elements
        scanf("%d",&a[i]);

    // [..]

    for(i=0;i<n;++i)    // Same as above..
        printf("%d\t",a[i]);

    // [..]
}

The quick_sort procedure is okay and seriously, I don't want to sound cocky or something, but the partition function is kinda messed up. Let's see:

int partition(int a[],int low,int high)
{
    int i,j,temp,key;

    /* key=a[low];  .. this does not make sense. Basically, you want the pivot element of the list here, the value of the element in the middle of your array, so.. */
    key=a[(low+high)/2];  // use this instead.. btw. there are other methods to get the median, but this one works for most cases

    i=low;
    // j=high+1;  .. not sure why you add one to this, I would not do it as it complicates things
    j=high;

    /*
    The rest of the function is problematic..

    while(i <= j && key <= a[i])  .. the check i <= j and the use of a[i] in the second part would not have worked with j=high+1 .. what you want to do here is find the first element on the left side of the list that is BIGGER then your pivot element and go to the next index, if a[i] is less than your key value (a[i] < key)..
    {
        i++;
    }

    while(key > a[j])  .. j is used to iterate through the list from the right side of the pivot element until you find an element that is SMALLER than you key value, so you decrease j as long as a[j] > key... actually, I think, your checks work, too, if you intend to sort the list to have the largest element first and the smallest at the end of the final list
    {
        j--;
    }

    if(i<j)
    {
        temp=a[i],a[i]=a[j],a[j]=temp;
    }
    else      // .. I do not understand what you intended to do with this part.. if (i < j) than there is an element on the left side of the pivot element that is bigger than the one on the right side, so you swap the two elements to sort the list, like you do above. If the left element is smaller then the one on the right they are sorted. With the first part you move the larger element from the left side to the end and here you move the larger element to the beginning of the list and the smaller to the end..
    {
        temp=a[low],a[low]=a[j],a[j]=a[low];
        return j ;  // also, this is your only return.. if you get the case (i<j) then there is no defined result for this function.
    }
    */

    /* So, this would be my suggestion on how the algorithm should look, if you want a list sorted from smallest to largest element that is */

    while (i < j)
    {
        while (a[i] < key) ++i;
        while (key < a[j]) --j;

        if (i < j) temp = a[i], a[i] = a[j], a[j] = temp;
    }

    return i;
}

I suggest to analyze every state change when you develop an algorithm like this. I used a piece of paper for that and wrote down the variables used in loops for every iteration. This helps to find inconsistencies in your algorithms pretty quickly and often, you also get an idea on how to solve them that way, too.

I hope, I could help you with this.

Cheers!