Scribd Logo
Upload

Welcome to Scribd!

  • 72 views

    CS1325 F16 HW6 1 PDF

    Uploaded by

    Nah Blah
    The document describes a homework assignment to write a program that prints student names ordered by decreasing GPA without modifying the original student data array. It involves using pointers to indirectly sort an array of student structures by GPA. The program is to: 1) Initialize an array of student structures with names and GPAs 2) Create an array of pointers pointing to the student structures 3) Sort the pointer array using a modified bubble sort to order by GPA 4) Print the student names in decreasing GPA order using the sorted pointer array

    Copyright:

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

    CS1325 F16 HW6 1 PDF

    Uploaded by

    Nah Blah
    72 views7 pages
    The document describes a homework assignment to write a program that prints student names ordered by decreasing GPA without modifying the original student data array. It involves using pointers to indirectly sort an array of student structures by GPA. The program is to: 1) Initialize an array of student structures with names and GPAs 2) Create an array of pointers pointing to the student structures 3) Sort the pointer array using a modified bubble sort to order by GPA 4) Print the student names in decreasing GPA order using the sorted pointer array

    Original Title

    CS1325-F16-HW6-1(1).pdf

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document describes a homework assignment to write a program that prints student names ordered by decreasing GPA without modifying the original student data array. It involves using pointers to indirectly sort an array of student structures by GPA. The program is to: 1) Initialize an array of student structures with names and GPAs 2) Create an array of pointers pointing to the student structures 3) Sort the pointer array using a modified bubble sort to order by GPA 4) Print the student names in decreasing GPA order using the sorted pointer array

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    72 views7 pages

    CS1325 F16 HW6 1 PDF

    Uploaded by

    Nah Blah
    The document describes a homework assignment to write a program that prints student names ordered by decreasing GPA without modifying the original student data array. It involves using pointers to indirectly sort an array of student structures by GPA. The program is to: 1) Initialize an array of student structures with names and GPAs 2) Create an array of pointers pointing to the student structures 3) Sort the pointer array using a modified bubble sort to order by GPA 4) Print the student names in decreasing GPA order using the sorted pointer array

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    You are on page 1of 7

    CS1325 F16

    Homework #6-1
    Assigned Nov 10, due Nov 17 at 11:59 PM
    This homework assignment gives you the opportunity to practice pointers, arrays, sorting algorithms,
    and structures.

    HW6-1 (Graded out of 100)


    Assume each students information (first name, last name, GPA) is stored in a structure variable, and all
    the structures related to the various students are elements of an original array called studentArray.
    Write a program that prints the names of the students by order of decreasing GPA, without modifying
    the studentArray.
    typedef struct
    {
    char * firstName;
    char * lastName;
    double GPA;
    } Student;
    In order to print the names of students by decreasing GPA, your program will have to do a sorting
    according to the GPA. Many algorithms to sort the values of an array exist, but normally when an array
    of values is sorted, the array is modified, so that the first element of the array is the highest value, the
    second element of the array is the second highest value, and so on. An example is the bubble sort
    algorithm, whose pseudocode is provided below. Note that in order to sort the array, elements in the
    array may be swapped.
    In this assignment, we want to leave the original array of structures unchanged. One solution might be
    to create a duplicate of the data set, perhaps make a copy of one array into another, and then to sort
    the second array. This would allow us to view the data both in the original order and in the sorted order.
    A more elegant solution is to sort the array indirectly, by using a second array which contains pointers
    pointing to the original array. With this technique we wouldnt change the positions of the data items in
    the original array; we would only change the values of the pointers in the second array. When this type
    of sorting is performed, we still will be able to access the data both in its original order, by using the
    original array, but also in sorted order, by using the array of pointers. This solution is also more efficient
    if the elements in the original array are complex, and swapping them would take more time than
    swapping the pointers. Here are some diagrams that illustrate the idea.
    Fig 1 is an example of studentArray to be sorted according to the GPA. We create an array of
    pointers Point that indicates the order in which we view the elements of studentArray. Thus we
    view *Point[0], then *Point[1], then *Point[2], etc. in that order, instead of viewing in
    the order studentArray[0], then studentArray [1], then studentArray[2], etc.

    Point is initialized as illustrated in Fig. 2. We then sort the elements of Point so we view the
    elements of studentArray in decreasing order of GPA. That is, after sorting, Point[0]->GPA >=
    Point[1]->GPA >= Point[2]->GPA, etc., while the elements of studentArray are
    untouched. The result is shown in Fig. 3.

    1. Sorting procedure
    There are many common sorting algorithms that could be used to sort these data. Most of these are
    comparison based sorting algorithms, since they make decisions by comparing each array element
    against others. Most often, comparison based sorting algorithms work by interchanging, or swapping,
    elements within the array. One common and simple comparison based sorting algorithm is called
    Bubble Sort. It works by making multiple passes through the data set and on each pass comparing two
    adjacent array elements and swapping them if the right hand element is greater than the left hand
    element. In this way, the largest element remaining is bubbled to the top of the array on each pass.
    After all the passes are completed, the array is in sorted order. Here is the pseudo-code for one version
    of the Bubble Sort. This is an algorithm that is based on two nested loops.
    Outer loop index i runs from (n-1) down to 1
    Inner loop index j runs from 0 to (i-1)
    Compare myArr[j] and myArr[j+1]
    if myArr[j] < myArr[j+1], swap the contents of myArr[j] and myArr[j+1]
    Here, n refers to the number of elements in the array to be sorted. As given, this algorithm would sort
    the original array myArr very well. However, it does modify the array itself, which is what we want to
    avoid. In this assignment, we have to adapt the bubble sort to sort the Point array instead of the

    original studentArray array. Although the sorting should be done according to the GPA values the
    Point array is pointing to, the only values actually changed are the pointers in the Point array.

    2. Additional requirements Make sure you meet all the requirements to avoid losing
    points
    1. Follow the requirements in the Homework Notes.
    2. You will need to implement the following. Point and studentArray are arrays of Student *
    and Student respectively.

    a) A sorting function.
    This function should implement a modified version of the above Bubble Sort. There are two arrays
    involved, studentArray and Point, instead of the single array myArr, like in the pseudocode. The
    pseudo code needs to be adapted as follows. In the comparison step, we compare Point[i]->GPA
    with Point[j+1]->GPA, but in the swap step, we swap the contents of Point[j] and
    Point[j+1]. The function modifies the Point array, but leaves studentArray unchanged.
    void modifiedSort(Student *[], size_t); // Arguments are the array of
    pointers and the size of the array

    b) A function to display an array.


    This function should display the elements of an array of Student.
    void display(Student [], size_t); // Arguments are the array to
    display and the size of the array

    c) A function to display the data pointed to by an array of pointers.


    This function should display the structures pointed to by the content of an array of pointers. Note that
    this function takes as arguments an array of pointers, and the size of the array. The function displays the
    structure pointed to by the first pointer in the array, then the structure pointed to by the second pointer
    in the array, and so on.
    void displayPointedTo(Student* [],size_t); // Arguments are the array
    of pointers, and the size of the array

    d) Pseudocode for the main() function


    create the studentArray array (size is 4 elements)
    Initialize the Val array (copy and paste the code below)
    print (Now displaying data in the original order)
    call the display function that displays the data in the original order
    create the Point array
    initialize the Point array
    print(Now displaying the pointers array)
    display the Point array
    call the sorting function to sort the Point array (modified version of bubble sort)
    print(Now displaying the pointers array after sorting)
    display the Point array
    print (Now displaying data in sorted order)

    call the display function that displays the data in sorted order.
    print (Now displaying data in the original order)
    call the display function that displays the data in the original order (to verify the original data has not
    been modified)

    e) Copy and paste this code to initialize the studentArray:


    // Initialize array
    studentArray[0].firstName = "Harry";
    studentArray[0].lastName = "Potter";
    studentArray[0].GPA = 3.5;
    studentArray[1].firstName = "Sponge";
    studentArray[1].lastName = "Bob";
    studentArray[1].GPA = 3.8;
    studentArray[2].firstName = "Mr.";
    studentArray[2].lastName = "Spock";
    studentArray[2].GPA = 4.0;
    studentArray[3].firstName = "Captain";
    studentArray[3].lastName = "Kirk";
    studentArray[3].GPA = 3.9;

    3. Suggestions for Implementation


    1) Implement the function that prints out the structures in the studentArray array. Use it to test that the
    structures were initialized properly. Dont do anything else until this function is written and debugged.
    2) Then set up the Point Array and initialize it as described above.
    3) Then implement the displayPointedTo function that prints out the data pointed to by the Point Array.
    Use it to test the initialization of the Point array. At this point, the data should display in the same order
    as in the original array. Dont do anything else until this function is written and debugged.
    4) Then implement the Bubble Sort algorithm using the modified sorting algorithm given above. As you
    work, use the displayPointedTo function from step 3 to check your work.

    4. Expected output of your program

    You might also like

    pFad - Phonifier reborn

    Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

    Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


    Alternative Proxies:

    Alternative Proxy

    pFad Proxy

    pFad v3 Proxy

    pFad v4 Proxy