sort 排序算法实现

#ifndef SORT_H
#define SORT_H

//选择排序：直接选择排序、竞标赛排序

template <typename Type>
void selectSort(Type arr[], int size)
{
    int i, j;
    int index;
    for(i = 0; i < size; i++)
    {    
        index = i;
        for(j = i + 1; j < size; j++)
        {    
            if(arr[j] < arr[index])
            {
                index = j;
            }
        }

        swap(arr[i], arr[index]);
    }
    
}
//插入排序: 直接插入排序、shell排序
template <typename Type>
void simpleInsertSort(Type arr[], int size)
{
     int i, j;
     int pos;
     Type tmp;
     
     for(i = 1; i < size; i++)
     {//i为需要插入的元素的位置，也是无序区的第一个元素
         tmp = arr[i];
         pos = i;//记录需要插入的位置
         for(j = i - 1; j >= 0; j--)//找插入位置
         {
             if(arr[i] >= arr[j])
             {
                 pos = j + 1;
                 //cout << pos << " ";
                 break;
             }
             if( j == 0 && arr[i] < arr[0])
             {
                 pos = 0;
                 //cout << pos << " ";
             }
         }
         
         for(j = i; j > pos; j--)//移动块数据
             arr[j] = arr[j-1];
 
         arr[pos] = tmp;
     }
}

template <typename Type>
void shellSort(Type arr[], int size)
{
    int gap = size/2;
    int i, j, pos;
    Type tmp;
    while(gap >= 1)
    {
        for(i = gap; i < size; i++)
        {
            tmp = arr[i];
            pos = i;

            for(j = i - gap; j >= 0; j -= gap)//找插入位置
            {
                if(arr[i] >= arr[j])
                {
                    pos = j + gap;
                    break;
                }
                if( j == 0 && arr[i] < arr[0])
                {
                     pos = 0;
                    //cout << pos << " ";
                }
            }

            for(j = i; j > pos; j -= gap)//移动块数据
                arr[j] = arr[j-gap];


            arr[pos] = tmp;
        }

        gap = gap/2;
    }
}

//交换排序：冒泡排序、快速排序
template <typename Type>
void bubbleSort(Type arr[], int size)
{
    int i, j;
    for(i = 0; i < size - 1; i++)
    {
        for(j = 0; j < size - i - 1; j++)
        {
            if(arr[j] > arr[j+1])
                swap(arr[j], arr[j+1]);
        }

    }


}
//----快速排序------------------
template <typename Type>
void quickSort(Type arr[], int size, int low, int high)
{
    if(low < high)
    {
        int pivotpos = partion(arr, low, high);
        quickSort(arr, pivotpos, low, pivotpos - 1);
        quickSort(arr, size - pivotpos - 1, pivotpos + 1, high);
    }

}
template <typename Type>
int partion(Type arr[], int low, int high)
{

    Type pivot = arr[high];//这里枢轴为子序列最后一个元素
    int pivotpos = low;
    int j;
    for(j = low; j <= high - 1; j++)
    {
        if(arr[j] < pivot)
        {            
            swap(arr[j], arr[pivotpos]);
            pivotpos++;
        }
    }

    swap(arr[high], arr[pivotpos]);

    return pivotpos;
}

//----------------------------------------------------


template <typename Type>
void swap(Type &a, Type &b)
{
    Type tmp;

    tmp = a;
    a = b;
    b = tmp;
}

#endif

#include <iostream.h>
#include "sort.h"


int main()
{
    const int size = 10;
    int arr[size] = {27, 34, 83, 23, 35, 24, 39, 40, 30, 87};

    bubbleSort(arr, 10);
    //simpleInsertSort(arr, 10);

    //selectSort(arr, size);
    
    for(int i = 0; i < size; i++)
    {
        cout << arr[i] << " ";
    }

    cout << endl;

    return 0;
}