1.main.cpp 主函數

#include <iostream>
#include<algorithm>
#include <string>
#include "SortTestHelper.h"
#include "SelectionSort.h"
#include "BubbleSort.h"
using namespace std;
//插入排序
template<typename T>
void insertSort(T arr[], int n){
    for (int i = 1; i < n; i++){    
        
        
 
for (int j = i; j >= 1; j--){            
            if (arr[j] < arr[j-1])
                swap(arr[j-1], arr[j]);
            else
                break;   //提前終止循環，減少不必要的運算。當執行到此步驟時，說明前者小於後者，而前面也已經排好序。
            
        }        
    }
}
//理論上插入排序要比選擇排序快，因為中間就break，但實際上耗時更長。因為頻繁的swap（）操作更耗時。
 
//改進後
template<typename T>
void insertSortImprove(T arr[], int n){
    for (int i = 1; i < n; i++){
        T tempValue = arr[i];
        int j;  //保存要存放的位置
        for (j = i; j >0 && arr[j - 1] > tempValue; j--){            
            arr[j] = arr[j - 1];            
        }
        arr[j] 
 
= tempValue;
    }
}


int main(){

    int n = 10000;
    int *arr = SortTestHelper::generateRandomArray(n, 0, n);    
    int *arr2 = SortTestHelper::copyIntArray(arr,n);
    int *arr3 = SortTestHelper::copyIntArray(arr, n);
    int *arr4 = SortTestHelper::copyIntArray(arr, n);
    SortTestHelper::testSort("Selection Sort", selectionSort, arr, n);
    SortTestHelper::testSort("Insert Sort", insertSort, arr2, n);
    SortTestHelper::testSort("Insert Sort Improve", insertSortImprove, arr3, n);
    SortTestHelper::testSort("Bubble Sort", bubbleSort, arr4, n);
    //四種算法耗時長短比較  優化的插入排序<選擇排序<冒泡排序<插入排序 
    //這四種算法都是O(n2)級別的運算量
    delete[] arr;
    delete[] arr2;
    delete[] arr3;
    delete[] arr4;
    system("pause");
    return 0;
}

2.SortTestHelper.h

#ifndef SELECTIONSORT_SORTTESTHELPER_H
#define SELECTIONSORT_SORTTESTHELPER_H

#include <iostream>
#include <ctime>
#include <cassert>

using namespace std;

namespace SortTestHelper{
	//generateRandomArray 產生n個範圍[rangeL,rangeR]的隨機數
	int* generateRandomArray(int n, int rangeL, int rangeR){
		assert(rangeL <= rangeR);
		int *arr = new int[n];
		srand(time(NULL));
		for (int i = 0; i < n; i++){
			arr[i] = rand() % (rangeL - rangeR + 1) + rangeL;
		}
		return arr;
	}
	template<typename T>
	void printArray(T arr[], int n){
		for (int i = 0; i < n; i++)
			cout << arr[i] << " ";
		cout << endl;

		return;
	}

	//isSorted 判斷是否排序成功
	template<typename T>	
	bool isSorted(T arr[], int n){
		for (int i = 0; i < n - 1; i++){
			if (arr[i]>arr[i + 1])
				return false;
			}
		return true;		
	}

	//testSort 測試排序時間
	template<typename T>
	void testSort(string sortName, void(*sort)(T[], int), T arr[], int n){
		clock_t startTime = clock();
		sort(arr, n);
		clock_t endTime = clock();
		assert(isSorted(arr, n));
		cout << sortName << ":" << double(endTime - startTime) / CLOCKS_PER_SEC << "s" << endl;
		return;
	}

	//copyIntArray 拷貝數組
	int* copyIntArray(int a[], int n){
		int* copyA = new int[n];
		copy(a, a + n, copyA);
		return copyA;
	}
}

#endif

3.SelectionSort.h 選擇排序

template<typename T>
void selectionSort(T arr[], int n){

    for (int i = 0; i < n; i++){
        int minIndex = i;
        for (int j = i + 1; j < n; j++){
            if (arr[j] < arr[minIndex]){
                minIndex = j;
            }

        }
        swap(arr[i], arr[minIndex]);
    }
}

4.BubbleSort.h 冒泡排序

template<typename T>
void bubbleSort(T arr[], int n){
    for (int i = 0; i < n - 1; i++){
        for (int j = i + 1; j < n; j++){
            if (arr[i]>arr[j]){
                swap(arr[i], arr[j]);
            }
        }
    }
}

各種排序算法的比較