插入排序，选择排序，交换排序基本及优化

#include"Sort.h"
#include

//插入排序

    void  print(int *array, int  size)
    {
        int i = 0;
        for (i = 0; i < size-1; i++)
        {
            printf("%d", array[i]);
        }
        printf("\n");
        return ;
    }

    void _Swap(int *a, int *b)
{   
    int* tmp = 0;
    tmp = a;
    a = b;
    b = tmp;
}

void InsertSort(int * array, int size)
{
    int begin = 0;
    int end = 0;
    int key = 0;

    for (begin = 1; begin < size; begin++)
    {
        key = array[begin];   //取待插入的第一个元素
        end = begin - 1;        //有序区的最后的一个元素

        while (end >= 0 && key < array[end])   //判断满足j的条件，同时满足key小于有序区的最后一个元素就交换
    {
        array[end + 1] = array[end];   //若不是，则就交换位置
        end--;
    }
    array[end + 1] = key;            //找到合适的位子交换位置
}

}

//希尔排序

void ShellSort(int * array, int size)
{
    int begin = 0;
    int end = 0;
    int key = 0;
    int gap = 3;

    while (gap-- > 0)
    {
        for (begin = gap; begin < size; begin++) //gap后面一个一个元素之间交换排序
        {
            key = array[begin];   //取待插入的第一个元素
            end = begin - gap;        //与哈希间隔的元素之间比较

            while (end >= 0 && key < array[end])   //判断满足j的条件，同时满足key小于有序区的最后一个元素就交换
        {
            array[end + gap] = array[end];   //若不是，则就交换位置
            end -= gap;
        }
        array[end + gap] = key;            //找到位置交换位置
    }
}

}
//选择排序

    void SelectSort(int *array, int size)
    {
        int i = 0;
        int minpos = 0;
        int j = 0;

        for (i = 0; i < size - 1; i++)
    {
        minpos = i; //每次将无序区起始位置置位minpos

        for (j = i; j < size; j++)   //遍历无序数组，然后找到最小元素
        {
            if (array[j] < array[minpos])
            {
                minpos = j;
            }
        }
        if (minpos != i)  //如果最小元素不是无序数组起始位置，则与起始位置交换位置
        {
            int tmp = 0;
            tmp = array[minpos];
            array[minpos] = array[i];
            array[i] = tmp;
        }
    }
}

//选择排序的优化算法

void SelectSort_OP(int *array, int size)
{
    int i = 0;
    int minpos = 0;
    int maxpos = 0;
    int end = size - 1;
    int j = 0;

    for (i = 0; i < size - 1; i++)
    {
        minpos = i; //每次将无序区起始位置置位minpos
        maxpos = end;

        for (j = i; j < size; j++)   //遍历无序数组，然后找到最小元素
        {
            if (array[j] < array[minpos])
            {
                minpos = j;
            }
            if (array[j] > array[minpos])
            {
                maxpos = j;
            }
        }
        if (minpos != i)  //如果最小元素不是无序数组起始位置，则与起始位置交换位置
    {
        int tmp = 0;
        tmp = array[minpos];
        array[minpos] = array[i];
        array[i] = tmp;
    }
    if (maxpos != i)  //如果最小元素不是无序数组起始位置，则与起始位置交换位置
    {
        int tmp = 0;
        tmp = array[maxpos];
        array[maxpos] = array[end];
        array[end] = tmp;
    }
}

}

//交换排序
void BubbleSort(int *array, int size)  //升序
{
    int i = 0;
    int j = 0;
    for (i = 0; i < size-1; i++)
    {
        for (j = i+1; j < size- 1; j++)
        {
            if (array[i] > array[j])
            {
                //_Swap(&array[i], &array[j]);
                int tmp = 0;
                tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
            }
        }
    }

}