Array percentage algorithm implementation

Question

So I just stared programming in C a few days ago and I have this program which takes an unsorted file full of integers, sorts it using quicksort 1st algorithm

Any suggestions on what I have done wrong in this?

Answer 1

From what you have described, it sounds like you are almost there. You are attempting to get the first element of a collection that has a value equal to (or just greather than) 90% of all the other members of the collection. You have already done the sort. The rest should be simply following these steps (if I have understood your question):

1) sort collection into an into array (you've already done this I think)
2) count numbers in collection, store in float n; //number of elements in collection
3) index through sorted array to the 0.9*n th element, (pick first one beyond that point not a duplicate of previous)
4) display results

Here is an implementation (sort of, I did not store n) of what I have described: (ignore the random number generator, et al., it is just a fast way to get an array)

#include <ansi_c.h>
#include <windows.h>
int randomGenerator(int min, int max);
int NotUsedRecently (int number);
int cmpfunc (const void * a, const void * b);

int main(void)
{
    int array[1000];
    int i;

    for(i=0;i<1000;i++)
    {
        array[i]=randomGenerator(1, 1000);
        Sleep(1);
    }

    //sort array
    qsort(array, 1000, sizeof(int), cmpfunc);

    //pick the first non repeat 90th percent and print
    for(i=900;i<999;i++)
    {
        if(array[i+1] != array[i])
        {
            printf("this is the first number meeting criteria: %d", array[i+1]);
            break;
        }
    }
    getchar();  

    return 0;
}






int cmpfunc (const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}


int randomGenerator(int min, int max)
{
    int random=0, trying=0;

    trying = 1;         
    srand(clock());
    while(trying)
    {

        random = (rand()/32767.0)*(max+1);
        (random >= min) ? (trying = 0) : (trying = 1);
    }

    return random;
}

And here is the output for my first randomly generated array (centering around the 90th percentile), compared against what the algorithm selected: Column on left is the element number, on the right is the sorted list of randomly generated integers. (notice it skips the repeats to ensure smallest value past 90%)

In summary: As I said, I think you are already, almost there. Notice how similar this section of my code is to yours:

You have something already, very similar. Just modify it to start looking at 90% index of the array (whatever that is), then just pick the first value that is not equal to the previous.

Answer 2

According this part:

int output = array[(int)(floor(0.9*count)) + 1];
int x = (floor(0.9*count) + 1);

while (array[x] == array[x + 1])
{
    x = x + 1;
}
printf(" %d ", output);  

In while you do not check if x has exceeded count... (What if all the top 10% numbers are equal?) You set output in first line and print it in last, but do not do antything with it in meantime. (So all those lines in between do nothing).

You definitely are on the right track.

Answer 3

One issue in your code is that you need a break case for your second algorithm, once you find the output. Also, you cannot declare variables in your for loop, except under certain conditions. I'm not sure how you got it to compile.