Question

Develop a n contesting an election. There are five electorates (processes) and each electorate can cast their vote only once and for only one of the two candidates (A or B. The vote cast by an electorate is a character 'A' or B,sen as a multicast message to all the other electorates. The winner is the candidate who gets the maximum number of votes. After casting the vote and also receiving the vote messages from all the other electorates, each electorate should be able to independently determine the winner and display it. t-based election vote casting application as follows: There are two candidates A and B For each process: include a screenshot of the vote sent by it and the votes received from the other processes as well as display the winner of the election. Where to run the programs: You could run on your personal computer, using the localhost option.

Answer 1

//////This code contains both the required functions partition and quick sort
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <iostream.h>
#include <conio.h>

void quicksort(int*, int, int);
int partition(int*, int, int, int);
int median3(int*,int,int);
void swap(int &, int &);

int main()
{
int myarray[7] = {10,40,20,12,30,5,15};
quicksort(myarray, 0, 6);

for (int i = 0; i < 7; i++)
{
cout << myarray[i] << endl;
}
getche();
return 0;
}

// Quicksort controller function, it partitions the different pieces of our array.
void quicksort(int *arIntegers, int left, int right)
{
cout << "quicksort ([" << arIntegers[0] << ","
<< arIntegers[1] << ","
<< arIntegers[2] << ","
<< arIntegers[3] << ","
<< arIntegers[4] << ","
<< arIntegers[5] << ","
<< arIntegers[6] << "],"
<< left << ","
<< right << ")\n";
if (right > left)
{
int pivotIndex = median3(arIntegers,left,right);
int pivotNewIndex = partition(arIntegers, left, right, pivotIndex);

// Recursive call to quicksort to sort each half.
quicksort(arIntegers, left, pivotNewIndex-1);
quicksort(arIntegers, pivotNewIndex+1, right);
}
}

int median3(int *arIntegers,int left,int right)
{
int center = (left+right)/2;

if(arIntegers[center] < arIntegers[left])
swap(arIntegers[left],arIntegers[center]);
if(arIntegers[right] < arIntegers[left])
swap(arIntegers[left],arIntegers[right]);
if(arIntegers[right] < arIntegers[center])
swap(arIntegers[center],arIntegers[right]);

swap(arIntegers[center],arIntegers[right-1]);

return center;
}

// This function takes an array (or one half an array) and sorts it.
// It then returns a new pivot index number back to quicksort.

int partition(int *arIntegers, int left, int right, int pivot)
{
cout << "partition (" << arIntegers[0] << ","
<< arIntegers[1] << ","
<< arIntegers[2] << ","
<< arIntegers[3] << ","
<< arIntegers[4] << ","
<< arIntegers[5] << ","
<< arIntegers[6] << "],"
<< left << ","
<< right << ")\n";
int pivotValue = arIntegers[pivot];

// Swap it out all the way to the end of the array
// So we know where it always is.
swap(arIntegers[pivot], arIntegers[right]);
int storeIndex = left;

// Move through the array from start to finish comparing each to our
// pivot value (not index, the value that was located at the pivot index)
for (int i = left; i < right; i++)
{
if (arIntegers[i] <= pivotValue)
{
swap(arIntegers[i], arIntegers[storeIndex]);
storeIndex++;
}
}
swap(arIntegers[storeIndex], arIntegers[right]);
return storeIndex;
}

// Simple swap function for our in place swapping.
void swap(int &val1, int &val2)
{
int temp = val1;
val1 = val2;
val2 = temp;
}