Chapter 12 Exercise 4

coopere905 · October 22nd, 2012, 12:07 AM

Hi,

apologies for the double post, but I'm happy to have found this place. I've been looking a the above exercise and the solution suggested is:

Code:

    private void swap01<T>(T[] data, int pos1, int pos2)
    {
        T temp;

        temp = data[pos1];
        data[pos1] = data[pos2];
        data[pos2] = temp;
    }

Additionally, this upset the compiler and I had to change the calls to swap to

Code:

swap(data, start, end);

I do see that this passes the data directly to the method from getPivotPoint, but I'm not understanding why this would remove class scope and make the method less sloppy.

DrPurdum · October 23rd, 2012, 01:08 AM

As a rule, any method should do one task, and do it well. Additionally, it should perform that task "in the dark". That is, as a user of the routine, you don't need to know the gory details of how it works...only that it does work. This is the Black Box approach and is, in fact, one of the strengths of interfaces. By making the swap() method private, you make the sort routine a "pure" sort routine...the user cannot call swap() on their own. Also, swap() really is a helper method and has no need to be exposed to the outside world. To me, that's a good thing.

Dr. Purdum

DrPurdum · October 23rd, 2012, 07:52 AM

I forgot to comment on the code fragment you listed. I just checked the original code and it is the code you were able to compile. (I was also able to compile it with the new Visual Studio 2012 Express edition, which is the IDE used with the new book.) I'm not sure where the code you listed in the first section came from, but it is not the book's code. You may want to download the code for Chapter 12 again.

Dr. Purdum

coopere905 · October 24th, 2012, 11:31 PM

Quote:

Originally Posted by DrPurdum

I forgot to comment on the code fragment you listed. I just checked the original code and it is the code you were able to compile. (I was also able to compile it with the new Visual Studio 2012 Express edition, which is the IDE used with the new book.) I'm not sure where the code you listed in the first section came from, but it is not the book's code. You may want to download the code for Chapter 12 again.

Dr. Purdum

I'm not sure what you mean by 'the code you were able to compile'. I agree that the swap method in listing 12-4 works fine, but the solution you offer makes the compiler unhappy.

The solution to chapter 12, exercise 4 reads:
The solution means that you must pass the data to be swapped into the method. One solution is:

Code:

    private void swap01<T>(T[] data, int pos1, int pos2)
    {
        T temp;

        temp = data[pos1];
        data[pos1] = data[pos2];
        data[pos2] = temp;
    }

Now, as Swap01() gets called by:

Code:

    public void quickSort(int first, int last)
    {
        int start;      // Index for left partition
        int end;        // Index for right partition

        start = first;  // Keep copy of first element of array... 0
        end = last;     // ...and the last one- 99. (if 100 values)

        if (last - first >= 1)   // Make sure there's enough data to sort
        {
            int pivot = data[first];    // Set partitions- what if this is zero?

            while (end > start) // While indexes don't match...
            {   // Do left partition
                while (data[start] /*first value*/ <= pivot && start <= last && end > start)
                    start++;
                // Do right partition
                while (data[end] > pivot && end >= first && end >= start)
                    end--;
                if (end > start)    // If right partition index smaller...
                    swap01(start, end); // ...do a swap
            }
            swap01(first, end); // Swap last element with pivot
            quickSort(first, end - 1); // Sort around partitions
            quickSort(end + 1, last);
        }
        else
        {
            return;
        }

    }

, intellisense informs us, understandably, that there is no method swap01 that takes only two arguments.
Additionally, in the swap method, we get the complaint that you cannot implicitly convert type 'T' to type 'int'.

This is where my confusion was. I'm not sure what adjustments to make as quicksort only returns two values, while swap01 expects three.

DrPurdum · October 25th, 2012, 09:39 AM

I was referring to the code I wrote for the generic sort routine. The code you're showing is not the code I wrote. Take your code and single step through it and compare it to my code and you'll likely see where you're having problems.