void demo(int tam_vec, double factor){
Vector<Dni> v = bank_gen(tam_vec);
InsertionSort<Dni> is;
BubbleSort<Dni> bs;
ShellSort<Dni> ss(factor);
QuickSort<Dni> qs;
MergeSort<Dni> ms;
cout << "Vector: "; v.mostrar();
cout << " ## InsertionSort: " << endl;
is.ordenar(v, v.getSize());
cout << "Vector: "; v.mostrar();
cout << " ## BubbleSort: " << endl;
bs.ordenar(v, v.getSize());
cout << "Vector: "; v.mostrar();
cout << " ## ShellSort: " << endl;
ss.ordenar(v, v.getSize());
cout << "Vector: "; v.mostrar();
cout << " ## QuickSort: " << endl;
qs.ordenar(v, v.getSize());
cout << "Vector: "; v.mostrar();
cout << " ## MergeSort: " << endl;
ms.ordenar(v, v.getSize());
}
int
main (int argc, char *argv[])
{
if (argc != 3) {
cout << "Usage: " << argv[0] << " [list file] [list size]" << endl;
return -1;
}
char buffer[256];
ifstream myfile( argv[1] );
int length = atoi( argv[2] );
int *list = new int[length];
for (int i = 0; i < length; i++) {
myfile.getline( buffer, 100 );
list[i] = atoi( buffer );
}
QuickSort *ms = new QuickSort( list, length );
ms->quicksort();
cout << *ms << endl;
delete[] list;
delete ms;
return 0;
}
void TestClass::TestSearchAlgorithms()
{
cout << "TESTING SEARCH ALGORITHMS..." << endl;
//Testing all algorithms
for(auto s : m_vecSearchAlg)
{
cout << endl;
cout << "----- " << s->GetSearchName() << " -----" << endl;
std::vector<int> v = {1, 5, 9, 14, 54, 2, -2, 48, 72, 3};
size_t pos = 0;
size_t expectedResult = 0;
if(s->GetSearchName().compare("Binary Search") == 0)
{
QuickSort sort;
sort.Sort(v);
expectedResult = 6;
pos = s->Search(v, 14);
}
else
{
expectedResult = 3;
pos = s->Search(v, 14);
}
cout << "Search should return " << expectedResult
<< " and returned " << pos << "." << endl;
cout << "----- " << s->GetSearchName() << " Finished -----" << endl;
}
cout << "TESTING SEARCH ALGORITHMS FINISHED!!!" << endl;
}
int main()
{
//待排数据输入方式：
/*int N = 0;
cout << "排序数据个数：\n";
cin >> N;
int* A = new int[N];
cout << "请输入待排序的数据：\n";
for (int i = 0; i < N; i++)
{
cin >> A[i];
}*/
//数据直接给定
int B[N] = { 1, 6, 3, 5, 2, 4 };
int C[13] = { 54, 35, 48, 36, 27, 12, 44, 44, 8, 14, 26, 17, 2 };
int* A = C;
//从文件中读取，大量数据，计算时间复杂度
printResult("待排原始数据：", C, N);
BubbleSort bubble;
bubble.bubbleSort(A,N);
printResult("bubbleSort", A, N);
SelectionSort select;
select.selectionSort(A, N);
printResult("selectSort", A, N);
InsertionSort insert;
insert.insertionSort(A, N);
printResult("InsetSort", A, N);
MergeSort merge;
merge.mergeSort(A, N);
printResult("MergeSort", A, N);
QuickSort qucik;
qucik.quickSort(A, N);
printResult("QucikSort",A,N);
QuickSort2 qucik2;
qucik2.quickSort(A, N);
printResult("QucikSort2", A, N);
HeapSort heap;
heap.heapSort(A, N);
printResult("heapSort", A, N);
HeapSort2 heap2;
heap2.heapSort(A, N);
printResult("heapSort2", A, N);
ShellSort shell;
shell.shellSort(A,N);
printResult("shellSort", A, N);
return 0;
}
/**
* Calcula o tempo de ordenação com a função Clock.
*/
double ordenaVetorClock(int algorithm, int size) {
clock_t clock_init;
// Algoritmos de busca
QuickSort qs = QuickSort();
BubbleSort bs = BubbleSort();
MergeSort ms = MergeSort();
// Escolhe o algoritmo que deve ser testado
switch (algorithm) {
case QUICK_SORT:
clock_init = clock();
qs.start(vetorQuickSort, size);
return clock() - clock_init;
case BUBBLE_SORT:
clock_init = clock();
bs.start(vetorBubbleSort, size);
return clock() - clock_init;
case MERGE_SORT:
clock_init = clock();
ms.start(vetorMergeSort, size);
return clock() - clock_init;
}
return -1;
}
/**
* Calcula o tempo de ordenação com a função Clock.
*/
double ordenaVetorTime(int algorithm, int size){
time_t time_init;
// Algoritmos de busca
QuickSort qs = QuickSort();
BubbleSort bs = BubbleSort();
MergeSort ms = MergeSort();
// Escolhe o algoritmo que deve ser testado
switch (algorithm) {
case QUICK_SORT:
time(&time_init);
qs.start(vetorQuickSort, size);
return time(NULL) - time_init;
case BUBBLE_SORT:
time_init = time(NULL);
bs.start(vetorBubbleSort, size);
return time(NULL) - time_init;
case MERGE_SORT:
time_init = time(NULL);
ms.start(vetorMergeSort, size);
return time(NULL) - time_init;
default:
cout << "ERROR" << endl;
break;
}
return -1;
}
int main(){
vector<int> test1 {0};
vector<int> test2 {-1, 3, 2, 4,-10, 100};
QuickSort solver;
solver.qsort(test1);
solver.qsort(test2);
assert(solver.isSorted(0, test1.size()-1, test1));
assert(solver.isSorted(0, test2.size()-1, test2));
}
int TestQuickSort_IntArray()
{
int int_array [] = {0, 4, 3, 6, 2, 1, 5, 7, 9, 8 };
QuickSort<int> *qs = new QuickSort<int>();
qs->Sort(int_array, 10);
for (int i = 0; i < 10; i++) {
TEST_ASSERT(int_array[i] == i);
}
delete qs;
return 0;
}
void Tester<T>::STLQuickSortTest(double TimeTable[], int& timeCount) // [5]
{//STL 퀵소트 TEST
QuickSort<T> quick;
ioHandler io;
clock_t begin, end;
begin = clock();
quick.STLQuickSort(arr, size);
end = clock();
io.setTime(TimeTable,timeCount, ((double)(end - begin))/CLOCKS_PER_SEC);
}
void Tester<T>::median3_iterQuickSortTest(double TimeTable[], int& timeCount) // [4]
{//중간값(메디안) 반복 퀵소트 TEST
QuickSort<T> quick;
ioHandler io;
clock_t begin, end;
begin = clock();
quick.median3_iterQuickSort(arr, 0, size-1);
end = clock();
io.setTime(TimeTable,timeCount, ((double)(end - begin))/CLOCKS_PER_SEC);
}
int main()
{
std::vector<int> v1 { 1, -8, 4, 48, -10, 700, 5, -7, 54545, -777 };
QuickSort<decltype(v1)> qs;
qs.sort(v1);
for (auto const & element : v1)
{
std::cout << element << std::endl;
}
return 0;
}
int main(int argc, const char * argv[]) {
int array[] = {3,4,5,2,1,0,22,33,12,-20,45,333,87,8};
int len = sizeof(array) / sizeof(*array);
vector<int> dat(array, array+len);
QuickSort qs;
// qs.setData(array, len);
qs.setData(dat);
qs.sort();
return 0;
}
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;
}
double test1() {
int t0[] = {1,2,4,3,5,6};
vector <int> p0(t0, t0+sizeof(t0)/sizeof(int));
QuickSort * obj = new QuickSort();
clock_t start = clock();
double my_answer = obj->getEval(p0);
clock_t end = clock();
delete obj;
cout <<"Time: " <<(double)(end-start)/CLOCKS_PER_SEC <<" seconds" <<endl;
double p1 = 1.0;
cout <<"Desired answer: " <<endl;
cout <<"\t" << p1 <<endl;
cout <<"Your answer: " <<endl;
cout <<"\t" << my_answer <<endl;
if (p1 != my_answer) {
cout <<"DOESN'T MATCH!!!!" <<endl <<endl;
return -1;
}
else {
cout <<"Match :-)" <<endl <<endl;
return (double)(end-start)/CLOCKS_PER_SEC;
}
}
int main(int argc, char** argv)
#endif
{
HashTableST<std::string, int> myHahTableST;
myHahTableST.put("Skornyakov", 2);
myHahTableST.put("Skornyakov", 3);
myHahTableST.put("Abramov", 3);
myHahTableST.put("Losev", 4);
myHahTableST.put("Utin", 5);
int val = 0;
val = myHahTableST.get("Utin");
myHahTableST.remove("Skornyakov");
RBTreeST<std::string, int> phoneNumbers;
phoneNumbers.put("Skornyakov", 2);
phoneNumbers.put("Abramov", 3);
phoneNumbers.put("Losev", 4);
phoneNumbers.put("Utin", 5);
bool test = phoneNumbers.contains("Pukin");
test = phoneNumbers.contains("Utin");
while(1) {
MaxPQ<int> maxPQ;
srand((unsigned int)time(NULL));
int arr[1000];
for(int i = 0; i < 1000; i++) {
arr[i]=rand();
}
/*
heapsort<int>(arr, 1000);
for(int i = 0; i < 10000; i++){
maxPQ.insert(rand());
}
for(int i = 0; i < 10000; i++){
int k;
while(maxPQ.delMax(&k)){
cout << k << " ";
}
}
cout << endl;*/
BinTreeST<string, int> binTreeST;
binTreeST.put("Skornyakov", 14);
binTreeST.put("Abramov", 12);
binTreeST.put("Aaskold", 12);
binTreeST.put("Antonov", 12);
binTreeST.put("Ivanov", 12);
binTreeST.put("Sidorov", 13);
binTreeST.put("Nesterov", 11);
binTreeST.put("Nesterenko", 11);
binTreeST.put("Kolcov", 11);
int bstSize = binTreeST.size();
binTreeST.remove("Abramov");
bstSize = binTreeST.size();
binTreeST.remove("Skornyakov");
bstSize = binTreeST.size();
binTreeST.remove("Aaskold");
bstSize = binTreeST.size();
/*
for(int i = 0; i < 1000; i++){
string newStr;
newStr.insert(newStr.end(), (char)(rand()%93+33));
newStr.insert(newStr.end(), (char)(rand()%93+33));
newStr.insert(newStr.end(), (char)(rand()%93+33));
binTreeST.put(newStr, rand()%101);
}*/
int val = binTreeST.get("Skornyakov");
std::string searchitem("Azotov");
string floorVal = binTreeST.floor(searchitem);
string ceilingVal = binTreeST.ceiling(searchitem);
std::cout << "floor(" << searchitem <<") = " << floorVal << endl;
std::cout << "ceiling(" << searchitem <<") = " << ceilingVal << endl;
std::cout << "rank(" << searchitem <<") = " << binTreeST.rank(searchitem) << endl;
BinSearchST<string, int> binarySearchST;
binarySearchST.put("���������", 14);
binarySearchST.put("���������", 12);
binarySearchST.put("�������", 13);
binarySearchST.put("����a", 11);
binarySearchST.put("���������", 11);
binarySearchST.put("���������a", 11);
binarySearchST.remove("���������a");
for(int i = 0; i < 1000; i++) {
string newStr;
newStr.insert(newStr.end(), (char)(rand()%93+33));
newStr.insert(newStr.end(), (char)(rand()%93+33));
newStr.insert(newStr.end(), (char)(rand()%93+33));
binarySearchST.put(newStr, rand()%101);
}
val = binarySearchST.get("���������");
val = binarySearchST.get("���������");
val = binarySearchST.get("���������a");
val = binarySearchST.get("���������");
vector<int> intVec;
for(int i = 0; i < 1000000; i++) {
intVec.push_back(rand()) ;
}
// Quicksort
cout << "Quicksort:" << endl;
QuickSort<int> intQuicksort;
Mergesort<int> intMergeSort;
time_t before, after;
time(&before);
//qsort(&intVec[0], intVec.size(), sizeof(int), compare);
intQuicksort.sort(intVec);
//std::sort(intVec.begin(), intVec.end());
//intMergeSort.sort(intVec);
time(&after);
double sec = difftime(after, before);
if(intQuicksort.isSorted(intVec))
cout << "Sorted";
else
cout << "Not sorted";
cout << endl;
}
/*
// Mergesort
cout << "Mergesort" << endl;
Mergesort<int> intMergeSort;
//intMergeSort.sort(intVec);
intMergeSort.bottomUpSort(intVec);
for(std::vector<int>::iterator it = intVec.begin(); it != intVec.end(); ++it){
cout << *it << " ";
}
cout << endl;
*/
/*
// Shellsort
cout << "Shellsort" << endl;
Shell<int> intShellSort;
intShellSort.sort(intVec);
for(std::vector<int>::iterator it = intVec.begin(); it != intVec.end(); ++it){
cout << *it << " ";
}
cout << endl;
*/
/*
// Insertion sort
cout << "Insertion sort: " << endl;
Insertion<int> intInsertion;
intInsertion.sort(intVec, 0, 20);
for(std::vector<int>::iterator it = intVec.begin(); it != intVec.end(); ++it){
cout << *it << " ";
}
cout << endl;*/
/*
// Selection sort
cout << "Selection sort: " << endl;
Selection<int> intSelection;
intSelection.sort(intVec);
for(std::vector<int>::iterator it = intVec.begin(); it != intVec.end(); ++it){
cout << *it << " ";
}
cout << endl;
*/
// array Q implementation
array_impl_q::Queue<int> arrayQ;
int itemsCount = 100;
cout << "Enqueue " << itemsCount << " items" << endl;
for (int i = 0; i < itemsCount; i++) {
arrayQ.enqueue(i);
}
itemsCount = 90;
cout << "Dequeue " << itemsCount << " items" << endl;
try {
for (int i = 0; i < itemsCount; i++) {
cout << arrayQ.dequeue() << " ";
}
cout << endl;
}
catch(const char *str) {
cout << endl << str << endl;
}
catch(...) {
cout << endl << "Unknown exception" << endl;
}
/*
// linked list Q implementation
linklist_q::Queue<int> linkedListQ;
unsigned int itemsCount = 1500000;
cout << "Enqueue " << itemsCount << " items" << endl;
for (int i = 0; i < itemsCount; i++) {
linkedListQ.enqueue(i);
}
itemsCount = 1500000;
cout << "Dequeue " << itemsCount << " items" << endl;
try{
for (int i = 0; i < itemsCount; i++) {
cout << linkedListQ.dequeue() << " ";
}
cout << endl;
}
catch(const char *str){
cout << endl << str << endl;
}
catch(...){
cout << endl << "Unknown exception" << endl;
}
*/
/*
// linked list implementation stack
cout << "****Stack linked list implementation****" << endl;
cout << "stack push(1-100)" << endl;
linked_list_stack::Stack<int> integerStack;
for (int i = 0; i < 100000; i++) {
integerStack.push(i);
}
try {
cout << "stack pop(105)" << endl;
for (int i = 0; i < 105000; i++) {
cout << integerStack.pop() << " ";
}
} catch (const char *p) {
cout << endl << p << endl;
} catch (...) {
cout << "Unknown exception" << endl;
}
cout << endl;
cout << "stack push(1-100)" << endl;
for (int i = 0; i < 100; i++) {
integerStack.push(i);
}
cout << "stack pop all" << endl;
while (!integerStack.isEmpty()) {
cout << integerStack.pop() << " ";
}
cout << endl;
// array implementation stack
cout << "****Stack resizing array implementation****" << endl;
cout << "stack push(1-100)" << endl;
array_impl_stack::Stack<int> integerArrayBasedStack;
for (int i = 0; i < 100; i++) {
integerArrayBasedStack.push(i);
}
try {
cout << "stack pop(105)" << endl;
for (int i = 0; i < 105; i++) {
cout << integerArrayBasedStack.pop() << " ";
}
} catch (const char *p) {
cout << endl << p << endl;
} catch (...) {
cout << "Unknown exception" << endl;
}
cout << "stack push(1-100)" << endl;
for (int i = 0; i < 100; i++) {
integerArrayBasedStack.push(i);
}
cout << "stack pop all" << endl;
try {
while (!integerArrayBasedStack.isEmpty()) {
cout << integerArrayBasedStack.pop() << " ";
}
} catch (const char* p) {
cout << endl << p << endl;
} catch (...) {
cout << endl << "Unknown exception" << endl;
}
cout << endl;*/
return 0;
}
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";
}
}
