Quicksort C - 一个不同的版本

Question

The code does run. This is a little different version of quicksort I am working on. I am running into some major issues with it. First off It prints out the first element in the array as n: for example(if you set n = 3, even if you make the first element in the array 1 lets say, it will still print out 3 as the first element). Also when you print out the sorted version it doesn't actually change anything.

Example input with n = 3,

Set values = 8 , 7 , 6

Initial output will equal 3 , 7 , 6

Final output will equal 3 , 7 , 6

(The output SHOULD be 6 , 7 , 8)

I haven't been able to find any code online similar to my code, so this may be something new! Thanks.

//preprocessor directives and header files
#include <stdio.h>
#define MAX_ARRAY_SIZE 50

//function prototypes separated by data types
void print_array( int array[], int n );              // Print out the array values
void swap( int array[], int index1, int index2 );    // Swap two array elements. 
void quicksort( int array[], int low, int high );    // Sorting algorithm

int populate_array( int array[] );                  // Fill array with values from user.
int partition( int array[], int low, int high );    // Find the partition point (pivot)

//the main function 
int main(void)
{
    int array[MAX_ARRAY_SIZE];
    //set n = to size of user created size of array

    int n = populate_array(&array[MAX_ARRAY_SIZE]);
    //print the original array to the screen
    print_array(&array[MAX_ARRAY_SIZE], n );
    //perform the algorithm
    quicksort(array, 0, n-1);

    printf("The array is now sorted:\n");
    print_array(&array[MAX_ARRAY_SIZE], n);
    return 0;
}
// *array and array[] are the same...
int populate_array(int array[])
{
    int n = -1;
    printf("Enter the value of n > ");
    scanf("%d", &n);

    if(n > MAX_ARRAY_SIZE)
    {
        printf("%d exceeds the maximum array size. Please try again.\n\n", n);
        populate_array( &array[MAX_ARRAY_SIZE]);
    }
    else if(n < 0)
    {
        printf("%d is less than zero. Please try again.\n\n", n);
        populate_array( &array[MAX_ARRAY_SIZE]);
    }
    else if(n == 0)
    {
        printf("%d Array of size 0? Please don't try this, and... Please try again.\n\n", n);
        populate_array( &array[MAX_ARRAY_SIZE]);
    }
    else
    {
        for(int i = 0; i < n; i++)
            scanf("%d", &array[i]);
    }
    printf("The initial array contains: \n");
    return n;
}

void print_array(int array[], int n)
{

    for(int i = 0; i < n; i++)
        printf("%+5d\n", array[i]);


}

void quicksort(int array[], int low, int high)
{

    if (low < high)
    {
        /* pivot is partitioning index, array[p] is now
           at right place */
        int pivot = partition(array, low, high);

        // Separately sort elements before
        // partition and after partition
        quicksort(array, low, pivot - 1);
        quicksort(array, pivot + 1, high);
    }

}

int partition(int array[], int low, int high)
{
    int pivot = array[high];

    int i = low;
    for (int j = low; j <= high- 1; j++)
    {
        // If current element is smaller than or
        // equal to pivot
        if (array[j] <= pivot)
        {
            swap(array, i, j);
            i = i +1;
        }
    }
    swap(array, i, high);
    return i;
}

void swap(int array[], int index1, int index2)
{
    int temp = array[index1];
    array[index1] = array[index2];
    array[index2] = temp;

}

Answer 1

Here is a heavily commented answer. I changed the code quite a bit.

This is now a fully functional quicksort array for user input.

The problem I was having before was with the &array[MAX_ARRAY_SIZE]. This needed to be changed to just "array" instead. The &array[MAX_ARRAY_SIZE] was trying to access a memory location past the actual size of the array.

Changing it to just "array" means that it is accessing the first element in the array.(Correct if wrong)

I also changed the populate array function to be a robust do-while loop. And instead of trying to re-call the function inside itself. The do-while loop will only allow you to change the value of 'n'.

/*
Author: Zachary Alberda
*/
//preprocessor directives and header files
#include <stdio.h>
#define MAX_ARRAY_SIZE 50

//function prototypes separated by data types
void print_array( int array[], int n );              // Print out the array values
void swap( int array[], int index1, int index2 );    // Swap two array elements. 
void quicksort( int array[], int low, int high );    // Sorting algorithm

int populate_array( int array[] );                  // Fill array with values from user.
int partition( int array[], int low, int high );    // Find the partition point (pivot)

//the main function 
int main(void)
{
    int array[MAX_ARRAY_SIZE]; //set n = to size of user created size of array

    int n = populate_array(array); //print the original array to the screen

    print_array(array, n ); //print array of size n 

    quicksort(array, 0, n-1); //perform the algorithm low is 0, high is size of array -1.

    printf("The array is now sorted:\n");//Inform user that the array is sorted.

    print_array(array, n);//print the sorted array

    return 0; // exit without errors.
}
// *array and array[] are the same...
int populate_array(int array[])
{

    int n = -1;//initialize variable n(local variable to function populate_array)
    printf("Enter the value of n > ");//inform user of what to input
    scanf("%d", &n);

    /*
        CHECK IF N IS VALID 


        This is a robust do while loop!

        1) Performs the if-statements while 'n' is not valid in a do-while loop.
         -The reason I do this is because it will cause errors
            if the if-statements are individual without the do-while loop.
        2)The program will not crash if you try different combinations
            of inputs for 'n'. :) 
        3)Checks if user input is > MAX_ARRAY_SIZE
        4)Checks if user input is < 0
        5)Checks if user input is == 0
    */
    do
    {
        if(n > MAX_ARRAY_SIZE)
        {
            printf("%d exceeds the maximum array size. Please try again.\n\n", n);
            printf("Enter the value of n > ");
            scanf("%d", &n);
        }
        else if(n < 0)
        {
            printf("%d is less than zero. Please try again.\n\n", n);
            printf("Enter the value of n > ");
            scanf("%d", &n);
        }
        else if(n == 0)
        {
            printf("%d Array of size 0? Please don't try this, and... Please try again.\n\n", n);
            printf("Enter the value of n > ");
            scanf("%d", &n);
        }
    }while(n <= 0 || n > MAX_ARRAY_SIZE);

    //scan in array if user input is valid 
    for(int i = 0; i < n; i++)
        scanf("%d", &array[i]);

    printf("The initial array contains: \n");//Inform user of initial array

    return n;
}

void print_array(int array[], int n)
{
//print array in pre/post order before and after the algorithm.
    for(int i = 0; i < n; i++)
        printf("%+5d\n", array[i]);


}

void quicksort(int array[], int low, int high)
{

    if (low < high)
    {
        /* pivot is partitioning index, array[pivot] is now
           at right place */
        int pivot = partition(array, low, high);

        // Separately sort elements before
        // partition and after partition
        quicksort(array, low, pivot - 1);
        quicksort(array, pivot + 1, high);
    }

}

int partition(int array[], int low, int high)
{
    int pivot = array[high];

    int i = low;

    for (int j = low; j <= high- 1; j++)
    {
        // If current element is smaller than or
        // equal to pivot
        if (array[j] <= pivot)
        {
            swap(array, i, j);
            i = i +1;
        }
    }
    swap(array, i, high);
    return i;
}

void swap(int array[], int index1, int index2)
{
    //swap positions of array index 1 and 2 
    int temp = array[index1];
    array[index1] = array[index2];
    array[index2] = temp;

}