int main()
{
MergeSort sorter;
sorter.readList();
sorter.sort();
cout << "Output:\n";
sorter.printArray();
return 0;
}
void Interface::run() {
int option;
string filename, userInput;
while (_active) {
string filename;
vector<int> data;
cout << "\n Choose your data \n 1. Manual \n 2. Auto Random \n 3. Load CSV file \n 4. Exit" << endl;
getline(cin, userInput);
option = atoi(userInput.c_str());
switch (option) {
case 1:
_arrSize = requestArraySize();
data = manualEntries(_arrSize);
break;
case 2:
_arrSize = requestArraySize();
data = automaticEntries(_arrSize);
break;
case 3:
cout << "Please type file name " << endl;
getline(cin, filename);
data = CSVEntries(filename);
break;
case 4:
_active = false;
break;
default:
cout << "Invalid option. Please start again. \n" << endl;
break;
}
if(data.size() > 0) {
DataCollection store(_arrSize, data);
cout << "\n print Unsorted List:" << endl;
store.printElements();
MergeSort mergeSort;
mergeSort.sort(store.getDataArray());
InsertionSort insertionSort;
insertionSort.sort(store.getDataArray() );
cout << "\n Merge sort finished in: "<< mergeSort.getExecutionTime() <<" nanosecond " << endl;
mergeSort.printElements();
cout << "\n Insertion Sort finished in: " << insertionSort.getExecutionTime() <<" nanoseconds"<< endl;
insertionSort.printElements();
}
}
}
void sortData()
{
cout << "\n SORTING...\n" << endl;
MergeSort sortVector;
//cout << "Unsorted vector:" << endl;
sortVector.displayElements(); // print unsorted vector
//cout << endl << endl;
sortVector.sort(); // sort vector
//cout << "Sorted vector:" << endl;
sortVector.displayElements(); // print sorted vector
cout << endl;
if(verbose)
cout << "Done with sorting! " << endl;
}
int FsmAp::partitionRound( StateAp **statePtrs, MinPartition *parts, int numParts )
{
/* Need a mergesort object and a single partition compare. */
MergeSort<StateAp*, PartitionCompare> mergeSort;
PartitionCompare partCompare;
/* For each partition. */
for ( int p = 0; p < numParts; p++ ) {
/* Fill the pointer array with the states in the partition. */
StateList::Iter state = parts[p].list;
for ( int s = 0; state.lte(); state++, s++ )
statePtrs[s] = state;
/* Sort the states using the partitioning compare. */
int numStates = parts[p].list.length();
mergeSort.sort( statePtrs, numStates );
/* Assign the states into partitions based on the results of the sort. */
int destPart = p, firstNewPart = numParts;
for ( int s = 1; s < numStates; s++ ) {
/* If this state differs from the last then move to the next partition. */
if ( partCompare.compare( statePtrs[s-1], statePtrs[s] ) < 0 ) {
/* The new partition is the next avail spot. */
destPart = numParts;
numParts += 1;
}
/* If the state is not staying in the first partition, then
* transfer it to its destination partition. */
if ( destPart != p ) {
StateAp *state = parts[p].list.detach( statePtrs[s] );
parts[destPart].list.append( state );
}
}
/* Fix the partition pointer for all the states that got moved to a new
* partition. This must be done after the states are transfered so the
* result of the sort is not altered. */
for ( int newPart = firstNewPart; newPart < numParts; newPart++ ) {
StateList::Iter state = parts[newPart].list;
for ( ; state.lte(); state++ )
state->alg.partition = &parts[newPart];
}
}
return numParts;
}
void RedFsmAp::sortByStateId()
{
/* Make the array. */
int pos = 0;
RedStateAp **ptrList = new RedStateAp*[stateList.length()];
for ( RedStateList::Iter st = stateList; st.lte(); st++, pos++ )
ptrList[pos] = st;
MergeSort<RedStateAp*, CmpStateById> mergeSort;
mergeSort.sort( ptrList, stateList.length() );
stateList.abandon();
for ( int st = 0; st < pos; st++ )
stateList.append( ptrList[st] );
delete[] ptrList;
}
bool FsmAp::minimizeRound()
{
/* Nothing to do if there are no states. */
if ( stateList.length() == 0 )
return false;
/* Need a mergesort on approx compare and an approx compare. */
MergeSort<StateAp*, ApproxCompare> mergeSort;
ApproxCompare approxCompare;
/* Fill up an array of pointers to the states. */
StateAp **statePtrs = new StateAp*[stateList.length()];
StateList::Iter state = stateList;
for ( int s = 0; state.lte(); state++, s++ )
statePtrs[s] = state;
bool modified = false;
/* Sort The list. */
mergeSort.sort( statePtrs, stateList.length() );
/* Walk the list looking for duplicates next to each other,
* merge in any duplicates. */
StateAp **pLast = statePtrs;
StateAp **pState = statePtrs + 1;
for ( int i = 1; i < stateList.length(); i++, pState++ ) {
if ( approxCompare.compare( *pLast, *pState ) == 0 ) {
/* Last and pState are the same, so fuse together. Move forward
* with pState but not with pLast. If any more are identical, we
* must */
fuseEquivStates( *pLast, *pState );
modified = true;
}
else {
/* Last and this are different, do not set to merge them. Move
* pLast to the current (it may be way behind from merging many
* states) and pState forward one to consider the next pair. */
pLast = pState;
}
}
delete[] statePtrs;
return modified;
}
void estadistica(int n_pruebas, int tam_vec, double factor){
//Instanciacion del banco de pruebas
Vector<Dni>* bank_pruebas = new Vector<Dni>[n_pruebas];
srand(time(NULL));
//Instanciar algoritmos
InsertionSort<Dni> is;
BubbleSort<Dni> bs;
ShellSort<Dni> ss(factor);
QuickSort<Dni> qs;
MergeSort<Dni> ms;
//Aplicar algoritmos al banco de pruebas
for(int i = 0; i < n_pruebas; i++){
bank_pruebas[i] = bank_gen(tam_vec);
cout << "Vector " << i << " : "; bank_pruebas[i].mostrar();
cout << " ## InsertionSort: " << endl;
is.ordenar(bank_pruebas[i], bank_pruebas[i].getSize());
cout << "Vector : "; bank_pruebas[i].mostrar();
cout << " ## BubbleSort: " << endl;
bs.ordenar(bank_pruebas[i], bank_pruebas[i].getSize());
cout << "Vector: " ; bank_pruebas[i].mostrar();
cout << " ## ShellSort: " << endl;
ss.ordenar(bank_pruebas[i], bank_pruebas[i].getSize());
cout << "Vector: " ; bank_pruebas[i].mostrar();
cout << " ## QuickSort: " << endl;
qs.ordenar(bank_pruebas[i], bank_pruebas[i].getSize());
cout << "Vector: " ; bank_pruebas[i].mostrar();
cout << " ## MergeSort: " << endl;
ms.ordenar(bank_pruebas[i], bank_pruebas[i].getSize());
cout << "~~~~~~" << endl;
}
bs.setAvg( (double)bs.getTot() / n_pruebas);
is.setAvg( (double)is.getTot() / n_pruebas);
ss.setAvg( (double)ss.getTot() / n_pruebas);
qs.setAvg( (double)qs.getTot() / n_pruebas);
ms.setAvg( (double)ms.getTot() / n_pruebas);
cout << endl;
cout << "Estadisticas" << endl;
cout << "Algoritmo " << " min " << " avg " << " max " << " total" << endl;
cout << setprecision(5);
cout << "InsertionSort " << is.getMin() << " " << is.getAvg() << " " << is.getMax() << " " << is.getTot() << endl;
cout << "BubbleSort " << bs.getMin() << " " << bs.getAvg() << " " << bs.getMax() << " " << bs.getTot() << endl;
cout << "ShellSort " << ss.getMin() << " " << ss.getAvg() << " " << ss.getMax() << " " << ss.getTot() << endl;
cout << "QuickSort " << qs.getMin() << " " << qs.getAvg() << " " << qs.getMax() << " " << qs.getTot() << endl;
cout << "MergeSort " << ms.getMin() << " " << ms.getAvg() << " " << ms.getMax() << " " << ms.getTot() << endl;
}
int main()
{
vector<int> testint, testint2;
testint.push_back(1);
testint.push_back(5);
testint.push_back(0);
testint.push_back(2);
testint.push_back(2);
testint.push_back(8);
testint.push_back(6);
testint.push_back(9);
MergeSort <int> sort;
testint2 = sort.solve(testint);
for (int i = 0; i < testint2.size(); i++)
{
cout << testint2[i] << " " << endl;
}
vector<char> testch, testch2;
testch.push_back('f');
testch.push_back('h');
testch.push_back('a');
testch.push_back('b');
testch.push_back('u');
testch.push_back('p');
testch.push_back('e');
testch.push_back('z');
MergeSort <char> sort2;
testch2 = sort2.solve(testch);
for (int i = 0; i < testch2.size(); i++)
{
cout << testch2[i] << " " << endl;
}
return 0;
}
/**
* \brief Minimize by partitioning version 1.
*
* Repeatedly tries to split partitions until all partitions are unsplittable.
* Produces the most minimal FSM possible.
*/
void FsmAp::minimizePartition1()
{
/* Need one mergesort object and partition compares. */
MergeSort<StateAp*, InitPartitionCompare> mergeSort;
InitPartitionCompare initPartCompare;
/* Nothing to do if there are no states. */
if ( stateList.length() == 0 )
return;
/*
* First thing is to partition the states by final state status and
* transition functions. This gives us an initial partitioning to work
* with.
*/
/* Make a array of pointers to states. */
int numStates = stateList.length();
StateAp** statePtrs = new StateAp*[numStates];
/* Fill up an array of pointers to the states for easy sorting. */
StateList::Iter state = stateList;
for ( int s = 0; state.lte(); state++, s++ )
statePtrs[s] = state;
/* Sort the states using the array of states. */
mergeSort.sort( statePtrs, numStates );
/* An array of lists of states is used to partition the states. */
MinPartition *parts = new MinPartition[numStates];
/* Assign the states into partitions. */
int destPart = 0;
for ( int s = 0; s < numStates; s++ ) {
/* If this state differs from the last then move to the next partition. */
if ( s > 0 && initPartCompare.compare( statePtrs[s-1], statePtrs[s] ) < 0 ) {
/* Move to the next partition. */
destPart += 1;
}
/* Put the state into its partition. */
statePtrs[s]->alg.partition = &parts[destPart];
parts[destPart].list.append( statePtrs[s] );
}
/* We just moved all the states from the main list into partitions without
* taking them off the main list. So clean up the main list now. */
stateList.abandon();
/* Split partitions. */
int numParts = destPart + 1;
while ( true ) {
/* Test all partitions for splitting. */
int newNum = partitionRound( statePtrs, parts, numParts );
/* When no partitions can be split, stop. */
if ( newNum == numParts )
break;
numParts = newNum;
}
/* Fuse states in the same partition. The states will end up back on the
* main list. */
fusePartitions( parts, numParts );
/* Cleanup. */
delete[] statePtrs;
delete[] parts;
}
/* Split partitions that need splittting, decide which partitions might need
* to be split as a result, continue until there are no more that might need
* to be split. */
int FsmAp::splitCandidates( StateAp **statePtrs, MinPartition *parts, int numParts )
{
/* Need a mergesort and a partition compare. */
MergeSort<StateAp*, PartitionCompare> mergeSort;
PartitionCompare partCompare;
/* The lists of unsplitable (partList) and splitable partitions.
* Only partitions in the splitable list are check for needing splitting. */
PartitionList partList, splittable;
/* Initially, all partitions are born from a split (the initial
* partitioning) and can cause other partitions to be split. So any
* partition with a state with a transition out to another partition is a
* candidate for splitting. This will make every partition except possibly
* partitions of final states split candidates. */
for ( int p = 0; p < numParts; p++ ) {
/* Assume not active. */
parts[p].active = false;
/* Look for a trans out of any state in the partition. */
for ( StateList::Iter state = parts[p].list; state.lte(); state++ ) {
/* If there is at least one transition out to another state then
* the partition becomes splittable. */
if ( state->outList.length() > 0 ) {
parts[p].active = true;
break;
}
}
/* If it was found active then it goes on the splittable list. */
if ( parts[p].active )
splittable.append( &parts[p] );
else
partList.append( &parts[p] );
}
/* While there are partitions that are splittable, pull one off and try
* to split it. If it splits, determine which partitions may now be split
* as a result of the newly split partition. */
while ( splittable.length() > 0 ) {
MinPartition *partition = splittable.detachFirst();
/* Fill the pointer array with the states in the partition. */
StateList::Iter state = partition->list;
for ( int s = 0; state.lte(); state++, s++ )
statePtrs[s] = state;
/* Sort the states using the partitioning compare. */
int numStates = partition->list.length();
mergeSort.sort( statePtrs, numStates );
/* Assign the states into partitions based on the results of the sort. */
MinPartition *destPart = partition;
int firstNewPart = numParts;
for ( int s = 1; s < numStates; s++ ) {
/* If this state differs from the last then move to the next partition. */
if ( partCompare.compare( statePtrs[s-1], statePtrs[s] ) < 0 ) {
/* The new partition is the next avail spot. */
destPart = &parts[numParts];
numParts += 1;
}
/* If the state is not staying in the first partition, then
* transfer it to its destination partition. */
if ( destPart != partition ) {
StateAp *state = partition->list.detach( statePtrs[s] );
destPart->list.append( state );
}
}
/* Fix the partition pointer for all the states that got moved to a new
* partition. This must be done after the states are transfered so the
* result of the sort is not altered. */
int newPart;
for ( newPart = firstNewPart; newPart < numParts; newPart++ ) {
StateList::Iter state = parts[newPart].list;
for ( ; state.lte(); state++ )
state->alg.partition = &parts[newPart];
}
/* Put the partition we just split and any new partitions that came out
* of the split onto the inactive list. */
partition->active = false;
partList.append( partition );
for ( newPart = firstNewPart; newPart < numParts; newPart++ ) {
parts[newPart].active = false;
partList.append( &parts[newPart] );
}
if ( destPart == partition )
continue;
/* Now determine which partitions are splittable as a result of
* splitting partition by walking the in lists of the states in
* partitions that got split. Partition is the faked first item in the
* loop. */
MinPartition *causalPart = partition;
newPart = firstNewPart - 1;
while ( newPart < numParts ) {
/* Loop all states in the causal partition. */
StateList::Iter state = causalPart->list;
for ( ; state.lte(); state++ ) {
/* Walk all transition into the state and put the partition
* that the from state is in onto the splittable list. */
for ( TransInList::Iter trans = state->inList; trans.lte(); trans++ ) {
MinPartition *fromPart = trans->fromState->alg.partition;
if ( ! fromPart->active ) {
fromPart->active = true;
partList.detach( fromPart );
splittable.append( fromPart );
}
}
}
newPart += 1;
causalPart = &parts[newPart];
}
}
return numParts;
}
void TestSortingAlgos() {
try
{
BubbleSort testBObj;
int arrB[ARRAY_SIZE] = { 15,3,12,10,1,9,6,11,5,4 };
testBObj.LoadData(arrB, ARRAY_SIZE);
testBObj.Print();
testBObj.Sort();
cout << "Bubble Sort Output:";
testBObj.Print();
SelectionSort testSObj;
int arrS[ARRAY_SIZE] = { 15,3,12,10,1,9,6,11,5,4 };
testSObj.LoadData(arrS, ARRAY_SIZE);
testSObj.Print();
testSObj.Sort();
cout << "Selection Sort Output:";
testSObj.Print();
InsertionSort testIObj;
int arrI[ARRAY_SIZE] = { 15,3,12,10,1,9,6,11,5,4 };
testIObj.LoadData(arrI, ARRAY_SIZE);
testIObj.Print();
testIObj.Sort();
cout << "Insertion Sort Output:";
testIObj.Print();
MergeSort testMObj;
int arrM[ARRAY_SIZE] = { 15,3,12,10,1,9,6,11,5,4 };
testMObj.LoadData(arrM, ARRAY_SIZE);
testMObj.Print();
testMObj.Sort();
cout << "Insertion Sort Output:";
testMObj.Print();
QuickSort testQObj;
int arrQ[] = { 15,3,12,10,1,9,6,11,5,4, 12, 8,1, -23, 87,45, 12, 423 };
testQObj.LoadData(arrQ, sizeof(arrQ)/sizeof(int));
testQObj.Print();
testQObj.Sort();
cout << "Quick Sort Output:";
testQObj.Print();
HeapSort testHObj;
int arrH[] = { 15,3,12,10,1,9,6,11,5,4, 12, 8,1, -23, 87,45, 12, 423 };
testHObj.LoadData(arrH, sizeof(arrH) / sizeof(int));
testHObj.Print();
testHObj.Sort();
cout << "Heap Sort Output:";
testHObj.Print();
QuickSortRandomized testQRObj;
int arrQR[] = { 15,3,12,10,1,9,6,11,5,4, 12, 8,1, -23, 87,45, 12, 423 };
testQRObj.LoadData(arrQR, sizeof(arrQR) / sizeof(int));
testQRObj.Print();
testQRObj.Sort();
cout << "Heap Sort Output:";
testQRObj.Print();
HeapSortRevised testHSRObj;
int arrHSR[] = { 15,3,12,10,1,9,6,11,5,4, 12, 8,1, -23, 87,45, 12, 423 };
testHSRObj.LoadData(arrHSR, sizeof(arrHSR) / sizeof(int));
testHSRObj.Print();
testHSRObj.Sort();
cout << "Heap Sort Output:";
testHSRObj.Print();
}
catch (const std::exception& E)
{
cerr << "Caught exception \"" << E.what() << "\"\n";
}
catch (...)
{
cerr << "Caught unknown exception";
}
}
void testCase4() {
int numbers_[] = {-2000000000, 2000000000, 0, 0, 0, -2000000000, 2000000000, 0, 0, 0};
vector<int> numbers(numbers_, numbers_ + (sizeof(numbers_) / sizeof(numbers_[0])));
int expected_ = 19;
assertEquals(4, expected_, solution.howManyComparisons(numbers));
}
void testCase3() {
vector<int> numbers;
int expected_ = 0;
assertEquals(3, expected_, solution.howManyComparisons(numbers));
}
void testCase2() {
int numbers_[] = {-17};
vector<int> numbers(numbers_, numbers_ + (sizeof(numbers_) / sizeof(numbers_[0])));
int expected_ = 0;
assertEquals(2, expected_, solution.howManyComparisons(numbers));
}
void testCase0() {
int numbers_[] = {1, 2, 3, 4};
vector<int> numbers(numbers_, numbers_ + (sizeof(numbers_) / sizeof(numbers_[0])));
int expected_ = 4;
assertEquals(0, expected_, solution.howManyComparisons(numbers));
}
