经典排序 之 几种排序比较

#include <iostream>
#include <vector>
#include <string>

using namespace std;

void printNumbers(vector<int> numbers, string type) {
cout << type << ":"<< endl;
for (int i = 0; i < numbers.size(); i++) {
cout << numbers[i] << " ";
}
cout << endl;
}

// qsort
void myQsort(vector<int>& numbers, int start, int end) {
if (start >= end)
return;
int i = start;
int j = end;
int key = numbers[start];
while (i < j) {
while (i < j && numbers[j] >= key)
j--;
if (i < j)
numbers[i++] = numbers[j];
while (i < j && numbers[i] <= key)
i++;
if (i < j)
numbers[j--] = numbers[i];
}
numbers[i] = key;
myQsort(numbers, start, i - 1);
myQsort(numbers, i + 1, end);
}

// select sort
void mySelectSort(vector<int>& numbers) {
for (int i = 0; i < numbers.size() - 1; i++) {
int min = numbers[i];
int idx = i;
for (int j = i + 1; j < numbers.size(); j++) {
if (numbers[j] < min) {
min = numbers[j];
idx = j;
}
}
swap(numbers[i], numbers[idx]);
}
}

// bubble sort
void myBubbleSort(vector<int>& numbers) {
for (int i = 0; i < numbers.size() - 1; i++) {
for (int j = 0; j < numbers.size() - i - 1; j++) {
if (numbers[j] > numbers[j + 1])
swap(numbers[j], numbers[j + 1]);
}
}
}

// insert sort
void myInsertSort(vector<int>& numbers) {
for (int i = 1; i < numbers.size(); i++) {
int temp = numbers[i];
int j = i;
while (j > 0 && numbers[j - 1] > temp) {
numbers[j] = numbers[j - 1];
j--;
}
numbers[j] = temp;
}
}

// shell sort
void myShellSort(vector<int>& numbers) {
for (int gap = numbers.size() / 2; gap > 0; gap /= 2) {
for (int i = gap; i < numbers.size(); i++) {
int temp = numbers[i];
int j = i;
while (j - gap >= 0 && numbers[j - gap] > temp) {
numbers[j] = numbers[j - gap];
j -= gap;
}
numbers[j] = temp;
}
}
}

// heap sort
void heapAdjust(vector<int>& numbers, int len, int idx) {
int left = idx * 2 + 1;
int right = left + 1;
if (left < len) {
int max_num = numbers[idx];
int max_idx = idx;
if (left < len && numbers[left] > max_num) {
max_num = numbers[left];
max_idx = left;
}
if (right < len && numbers[right] > max_num) {
max_num = numbers[right];
max_idx = right;
}
if (idx != max_idx) {
swap(numbers[idx], numbers[max_idx]);
heapAdjust(numbers, len, max_idx);
}
}
}

void myHeapSort(vector<int>& numbers) {
for (int i = numbers.size() - 1; i >= 0; i--) {
heapAdjust(numbers, numbers.size(), i);
}
for (int i = numbers.size() - 1; i >= 0; i--) {
swap(numbers[0], numbers[i]);
heapAdjust(numbers, i, 0);
}
}

// merge sort
void mergeArray(vector<int>& numbers, int start, int mid, int end, vector<int>& temp) {
int i = start;
int j = mid + 1;
int k = start;
while (i <= mid && j <= end) {
if (numbers[i] > numbers[j])
temp[k++] = numbers[j++];
else
temp[k++] = numbers[i++];
}
while (i <= mid)
temp[k++] = numbers[i++];
while (j <= end)
temp[k++] = numbers[j++];
for (int k = start; k <= end; k++)
numbers[k] = temp[k];
}

void myMergeSort(vector<int>& numbers, int start, int end, vector<int>& temp) {
if (start >= end)
return;
int mid = (end + start) / 2;
myMergeSort(numbers, start, mid, temp);
myMergeSort(numbers, mid + 1, end, temp);
mergeArray(numbers, start, mid, end, temp);
}

// test for our sort algorithm
int main() {
vector<int> numbers = { 1215, 7, 12, 1002, 5, 72, 530, 382, 633, 1, 1111 };
printNumbers(numbers, "Source");

vector<int> numbers1 = numbers;
myQsort(numbers1, 0, numbers.size() - 1);
printNumbers(numbers1, "Qsort");

vector<int> numbers2 = numbers;
mySelectSort(numbers2);
printNumbers(numbers2, "SelectSort");

vector<int> numbers3 = numbers;
myBubbleSort(numbers3);
printNumbers(numbers3, "BubbleSort");

vector<int> numbers4 = numbers;
myInsertSort(numbers4);
printNumbers(numbers4, "InsertSort");

vector<int> numbers5 = numbers;
myShellSort(numbers5);
printNumbers(numbers5, "ShellSort");

vector<int> numbers6 = numbers;
vector<int> temp = numbers;
myMergeSort(numbers6, 0, numbers.size() - 1, temp);
printNumbers(numbers6, "MergeSort");

vector<int> numbers7 = numbers;
myHeapSort(numbers7);
printNumbers(numbers7, "HeapSort");

getchar();
return 0;
}