/// <summary>
/// Show header, initialize virtualMemory, bubble sort poems by incremented segments and log number of exchanges used by each sort
/// </summary>
public void BubbleSortAndLog()
{
// Shows a header in the console similar to the comment at the top of this file
Common_Code.ShowHeader();
// Initializes all virtualMemory locations to -99
Common_Code.VirtualMemoryInit();
// Reads all three of the poems (TCOTLB.txt, RC.txt, GEAH.txt) in textDir (C:\devel\TFiles\)
Week_2_Class.PoemReader();
// Search virtualMemory for the text of the poems and put it in an array
int[] allPoems = GetPoemsInVirtualMemory();
int totalPoemsLength = allPoems.Length;
// Variable to track the number of exchanges used in a sort
int exchanges;
// Sort a segment of allPoems of size 10
exchanges = BubbleSortSegment(allPoems, 10);
// Write the log from the size 10 sort
WriteEfficiencyLog(10, exchanges, Common_Code.bubbleSort);
// Sort and log segments of the array starting at 100 and incrementing by 100 every time (100, 200, 300, etc) up to 2000
for (int i = 100; i <= 2000; i += 100)
{
exchanges = BubbleSortSegment(allPoems, i);
WriteEfficiencyLog(i, exchanges, Common_Code.bubbleSort);
}
bool keepSorting = Common_Code.YesNo("Keep sorting segments from size 2000 to 5927 (may take a few minutes)");
if (keepSorting)
{
// Sort and log segments of the array starting at 2000 and incrementing by 100 every time (2000, 2100, 2200, etc) up to 5900
for (int i = 2000; i <= totalPoemsLength; i += 100)
{
exchanges = BubbleSortSegment(allPoems, i);
WriteEfficiencyLog(i, exchanges, Common_Code.bubbleSort);
}
// Sort the entire array
exchanges = BubbleSort(allPoems);
// Write the log for the full sort
WriteEfficiencyLog(totalPoemsLength, exchanges, Common_Code.bubbleSort);
}
// Write all locations in the sortable source array to log file for debugging
Common_Code.IntArrayLog(allPoems, "AllPoems");
// Write all locations in virtual memory to log file for debugging
Common_Code.VirtualMemoryLog(10, true);
}
/// <summary>
/// Perform sorts (bucket, frequency, bubble) on a page of randomized integers in virtual memory and log their efficiency.
/// </summary>
public static void SortComparisons()
{
Common_Code.ShowHeader();
Common_Code.VirtualMemoryInit();
int pageToTwoDBucketSort = 200;
int pageToFrequencySort = 205;
int pageToBubbleSort = 210;
// Use the default 0 and 1,500,000 as min and max to populate the pages with random numbers.
// Not counting this towards the logCounter value since it's not part of the sorts being performed.
PopulatePage(pageToTwoDBucketSort, minValue, maxValue);
PopulatePage(pageToFrequencySort, minValue, maxValue);
PopulatePage(pageToBubbleSort, minValue, maxValue);
// Increment this value by 1 every time a variable (other than the logCount variable itself) changes.
// Includes variable changes in iterators (e.g. for (int i = 0; i < 100; i++) should increase logCount by 1 for each iteration, for a total of 100).
// Does not include variable declaration/initialization.
int logCount = 0;
// FindMinAndMax() Reassigns minValue and maxValue to whatever the lowest and highest numbers that were generated are (respectively).
// Tracks how many iterations it takes (17 * 80 = 1360) to find the min and max values so it can be added to logCount.
// Also, not every sort uses minValue and maxValue - only Frequency Sort and Bucket Sort, so I'm only increasing logCount by this for those sorts.
int findMinAndMax = FindMinAndMax(pageToTwoDBucketSort);
#region Sorts
#region 2-Dimensional Bucket Sort
// Set logCount to findMinAndMax since BucketSort uses them
logCount += findMinAndMax;
// Get the number of times to log based on operations performed during the bucket sort (i.e. total variable assignments it took to sort).
logCount += TwoDBucketSortPage(pageToTwoDBucketSort);
Week_10_Class.WriteEfficiencyLog(pageSize, logCount, Common_Code.arrayBucketSort);
Console.WriteLine("After bucket sort on page {0}, is it sorted?: {1}", pageToTwoDBucketSort, IsPageSorted(pageToTwoDBucketSort));
Common_Code.DisplayFooter();
#endregion
#region Frequency Sort
// Reset logCount to findMinAndMax for frequency sort.
logCount = findMinAndMax;
logCount += FrequencySortPage(pageToFrequencySort);
Week_10_Class.WriteEfficiencyLog(pageSize, logCount, Common_Code.frequencySort);
Console.WriteLine("After frequency sort on page {0}, is it sorted?: {1}", pageToFrequencySort, IsPageSorted(pageToFrequencySort));
Common_Code.DisplayFooter();
#endregion
#region Bubble Sort
// Reset logCount to 0 for bubble sort.
logCount = 0;
// Get number of times to log based on bubble sort operations.
logCount += LazyBubbleSortPage(pageToBubbleSort);
Week_10_Class.WriteEfficiencyLog(pageSize, logCount, Common_Code.bubbleSort);
Console.WriteLine("After bubble sort on page {0}, is it sorted?: {1}", pageToBubbleSort, IsPageSorted(pageToBubbleSort));
Common_Code.DisplayFooter();
#endregion
#endregion
// Writes locations in virtual memory to a log, excluding -99 (virtualNull), so the sorts can be manually checked for correctness.
Common_Code.VirtualMemoryLog(12, false);
}
