对数器验证排序算法的正确性

sort.h 

#ifndef SORT_H
#define SORT_H

class Sort {
private:
	int TestTime;
	int MaxSize;
	int MaxValue;
	int ArrayLength;
public:
	void Test();
	void SetValue(int,int,int);
	void PrintArray(int[]);
	int* CopyArray(int[]);
	void BubbleSort(int [], int );
	void InsertionSort(int[], int);
	void SelectionSort(int[], int);
	void QuickSort(int[], int,int);
	void MergeSort(int[], int,int);
	void HeapSort(int[], int);
	void RadixSort(int[],int);
	void BuildHeap(int[], int);
	void Swap(int[], int,int);
	void Comparator(int[],int);
	bool IsEqual(int[], int[]);
	int* GeneratorRandomArray();

};

#endif

main.cpp

#include"Sort.h"
#include<stdlib.h>
#include<time.h>
#include<algorithm>
#include<iostream>
using namespace std;
int main() {
	Sort test;
	test.SetValue(500000, 10, 50);
	test.Test();
}
void Sort::Test() {
	bool succeed = true;
	srand((unsigned)time(NULL));
	for (int i = 0; i < TestTime; ++i) {
		int*TestArr=GeneratorRandomArray();
		int*res=CopyArray(TestArr);
		Comparator(TestArr, ArrayLength);
		//InsertionSort(res, ArrayLength);
		//SelectionSort(res, ArrayLength);
		//QuickSort(res, 0, ArrayLength);
		//MergeSort(res, 0, ArrayLength-1);
		//HeapSort(res, ArrayLength);
		RadixSort(res, ArrayLength);
		//BubbleSort(res, ArrayLength);
		if (!IsEqual(res, TestArr)) {
			succeed = false;
			PrintArray(res);
			PrintArray(TestArr);
			break;
		}
	}
	succeed ? cout << "Nice!" << endl : cout << "Shit!" << endl;

}
void Sort::SetValue(int testtime,int maxsize,int maxvalue) {
	  TestTime = testtime;
	  MaxSize = maxsize;
	  MaxValue = maxvalue;
}
void Sort::BubbleSort(int arr[],int size) {
	for (int i = 1; i < size; ++i) {
		for (int j = 0; j < size - i; ++j) {
			if (arr[j] > arr[j + 1]) {
				Swap(arr, j,j+1);
			}
		}
	}
}
void Sort::InsertionSort(int arr[],int size) {
	for (int i = 1; i < size; ++i) {
		while (arr[i] < arr[i - 1]) {
			Swap(arr, i, i - 1);
			--i;
		}
	}
}
void Sort :: SelectionSort(int arr[], int size) {
	int min = 0;
	for (int i = 0; i < size; ++i) {
		 min = i;
		for (int j = i+1; j < size; ++j) {
			if (arr[min] > arr[j]) {
				min = j;
			}
			
		}
		Swap(arr, min, i);
	}
}
void Sort::QuickSort(int arr[], int l,int r) {
	if (arr == nullptr || r - l < 2) {
		return;
	}
	Swap(arr, (rand() % (r - l) + l), l);
	int index = l;
	int less = l;
	int more = r - 2;
	int key = arr[r-1];
	while (index <= more ) {
		 if(arr[index] > key) {
			Swap(arr, more, index);
			more--;
		 }
		 else if(arr[index] < key) {
			Swap(arr, index, less);
			index++;
			less++;
		 }
		 else {
			 index++;
		 }
	}
	Swap(arr, r-1, index);
	QuickSort(arr, l, less);
	QuickSort(arr, index+1, r);
}
void Sort::MergeSort(int arr[], int l,int r) {
	int mid = (r + l) / 2;
	if (l >= r) {
		return;
	}
	MergeSort(arr, l, mid);
	MergeSort(arr, mid + 1, r);
	int *help = new int[r - l + 1];
	int lIndex = l;
	int rIndex = mid + 1;
	int i = 0;
	while (lIndex <= mid && rIndex <= r) {
		help[i++] = arr[lIndex] < arr[rIndex] ? arr[lIndex++] : arr[rIndex++];
	}
	while (lIndex <= mid) {
		help[i++] = arr[lIndex++];
	}
	while (rIndex <= r) {
		help[i++] = arr[rIndex++];
	}
	for (i = 0; i < r - l + 1; i++) {
		arr[l + i] = help[i];
	}
	delete[]help;
}
void Sort::HeapSort(int arr[],int size) {
	BuildHeap(arr, size);
	while (size-- > 1) {
		Swap(arr, 0, size);
		BuildHeap(arr, size);
	}
}
void Sort::BuildHeap(int arr[],int size) {
	int index = size-1;
	while (index-->0) {
		if (arr[(int)(index) / 2] < arr[index+1]) {
			Swap(arr, index+1, (int)(index) / 2);
		}
	}
}
void Sort::RadixSort(int arr[],int size) {
	if (size == 1||size==0) {
		return;
	}
	int max = 0;
	for (int i = 0; i < size; ++i) {
		if (arr[i] >arr[max]) {
			max = i;
		}
	}
	int arrmax = arr[max];
	int *bucket = new int[arrmax + 1]{0};
	for (int i = 0; i < size; ++i) {
		bucket[arr[i]]++;
	}
	int p = 0;
	for (int j = 0; j < arrmax + 1; ++j) {
		while (bucket[j]-- > 0) {
		arr[p++] = j;
	}
	}
	delete[]bucket;
}
void Sort::Swap(int arr[], int n, int m) {
	int tmp = arr[n];
	arr[n] = arr[m];
	arr[m] = tmp;
}
int* Sort::GeneratorRandomArray() {
	int size = MaxSize;
	int value = MaxValue;
	ArrayLength = rand() % size;
	int *RandomArray = new int[ArrayLength];
	for (int i = 0; i < ArrayLength; ++i) {
		RandomArray[i] = rand() % value;
	}
	return RandomArray;
	//delete[]RandomArray;
}
void Sort::Comparator(int arr[],int size) {
	sort(arr, arr + size);
}
bool Sort::IsEqual(int arr1[], int arr2[]) {
	if ((arr1 == nullptr && arr2 != nullptr) || (arr1 != nullptr && arr2 == nullptr)) {
		return false;
		
	}
	if (arr1 == nullptr && arr2 == nullptr) {
		return true;
	}
	for (int i = 0; i < ArrayLength; i++) {
		if (arr1[i] != arr2[i]) {
			return false;
			
		}
	}
	return true;
}
int* Sort::CopyArray(int arr[]) {
	if (arr == nullptr) {
		return nullptr;
	}
	int *res = new int[ArrayLength];
	for (int i = 0; i < ArrayLength; i++) {
		res[i] = arr[i];
	}
	return res;
}
void Sort::PrintArray(int arr[]) {
	for (int i = 0; i < ArrayLength; ++i) {
		cout << arr[i] << " ";
	}
	cout << endl;
}

欢迎指正！