数据结构之排序（未完，待续）

//数据结构知识点总结
//插入排序
//主代码
#include
void InsertSort(int * a, size_t n)//直接插入排序
{
    assert(a != NULL);
    int end = 0;
    for (int i = 0; i < n - 1; ++i)
    {
        end = i;
        while (end >= 0)
        {
            if (a[end]>a[end + 1])
            {
                Swap(&a[end], &a[end + 1]);
                    end--;
            }
            else
            {
                break;
            }
        }
    }
}
//希尔排序
void ShellSort(int *a, size_t n)//希尔排序
{
    assert(a != NULL);
    //预排序
    int gap = n / 3 + 1;//希尔排序所需要的跨度
    while (gap > 1)
    {
        for (int i = 0; i < n - gap; ++i)
        {
            int end = i;
            while (end >= 0)
            {
                if (a[end]>a[end + gap])
                {
                    Swap(&a[end], &a[end + gap]);
                    end -= gap;
                }
                else
                {
                    break;
                }
            }
        }
        gap = gap / 3 + 1;
    }
    //直接插入排序
    InsertSort(a, n);


}
//对比，直插排序：时间复杂度，最好情况O(n);最坏情况O(n^2),空间复杂度O(1)。
//希尔排序，时间复杂度大约在O（n^1.25)~O(1.6n^1.25) ，空间复杂度O(1)。
void SelectSort(int *a, size_t n)//选择排序
{
    assert(a != NULL);
    for (int i = 0; i < n; i++)
    {
        int min = i;
        for (int j = j + 1; j < n; j++)
        {
            if (a[min]>a[j])
            {
                min = j;
            }
        }
        Swap(&a[min], &a[i]);
    }
}
void SelectSort(int *a, size_t n)
{
    assert(a != NULL);
    int left = 0;
    int right = n - 1;
    while (left < right)
    {
        int min = left;
        int max = left;
        for (int i = left; i <= right; i++)
        {
            if (a[min]>a[i])
            {
                min = i;
            }
            if (a[max] < a[i])
            {
                max = i;
            }
        }
        Swap(&a[left], &a[min]);
        if (left != max)
        {
            Swap(&a[right], &a[max]);
        }
        left++;
        right--;
    }
}
//堆排序
//先将数组建堆，如果要排升序，就键大堆，排降序，就建小堆
//建堆完毕后，用替换法进行排序
void AdjustDown(DataType* a, size_t n, int root)//建大堆
{
    int parent = root;
    int child = parent * 2 + 1;
    while (child < n)
    {
        if ((child + 1) < n&&a[child] < a[child + 1])
        {
            child++;
        }
        if (a[parent] < a[child])
        {
            DataType tmp = a[parent];
            a[parent] = a[child];
            a[child] = tmp;
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }

}
void MakeHeap(DataType*a, size_t n)//建堆
{
    int i = (n - 1) >> 1;
    for (; i >= 0; --i)
    {
        AdjustDown(a, n, i);
    }
}
void HeapSort(DataType* a, size_t n)
{
    MakeHeap(a, n);
    int end = n - 1;
    while (end > 0)
    {
        DataType tmp = a[end];
        a[end] = a[0];
        a[0] = tmp;
        AdjustDown(a, end, 0);
        end--;
    }
}
//选择排序:时间复杂度O（n^2),空间复杂度O（1),堆排序：时间复杂度O（n*logn),空间复杂度O（1）
//快速排序
//快排的三种方法
int LeftRightPointer(int*a, int left, int right)//左右指针法
{
    int begin = left;
    int end = right;
    int mid = Mid(a, left, right);
    Swap(&a[mid], &a[right]);
    int key = a[right];
    while (begin < end)
    {
        while (begin < end&&a[begin] <= key)
        {
            begin++;
        }
        while (begin < end&&a[begin] <= key)
        {
            end--;
        }
        Swap(&a[begin], &a[end]);
    }
    Swap(&a[begin], &a[right]);
    return begin;
}
void QuickSort(int* a, int left, int right)
{
    assert(a != NULL);
    if (left >= right)
    {
        return;
    }
    int div = LeftRightPointer(a, left, right);
    QuickSort(a, left, div - 1);
    QuickSort(a, div + 1, right);
}
//快排的优化，以左右指针法为例
int Mid(int* a, int left, int right)//三数取中法
{
    int mid = left + ((right - left) >> 1);
    if (a[left] > a[right])
    {
        if (a[left] < a[mid])
        {
            return left;
        }
        else if (a[right] < a[mid])
        {
            return mid;
        }
        else
        {
            return right;
        }
    }
    else
    {
        if (a[right] < a[mid])
        {
            return right;
        }
        else if (a[left] < a[mid])
        {
            return mid;
        }
        else
        {
            return left;
        }


    }

}
int LeftRightPointer(int* a, int left, int right)//左右指针快排
{
    int begin = left;
    int end = right;
    //选key的优化
    int mid = Mid(a, left, right);
    Swap(&a[mid], &a[right]);
    int key = a[right];
    while (begin < end)
    {
        while (begin < end&&a[begin] <= key)
        {
            begin++;
        }
        while (begin < end&&a[end] >= key)
        {
            end--;
        }
        Swap(&a[begin], &a[end]);
    }
    Swap(&a[begin], &a[right]);
    return begin;
}
直接插入排序：时间复杂度：最好O（n）,最坏 O（n^2）,空间复杂度O（1），优缺点，越接近有序越快，稳定性：稳定。
选择排序：时间复杂度：O（n^2）,空间复杂度O（1），优缺点，效率最低，唯一的优点是直观，稳定性：不稳定。
堆排序：时间复杂度O(n*logn),空间复杂度O（n）,优缺点：所有排序方式中，整体而言最快。稳定性:不稳定。
冒泡排序：时间复杂度O（n^2）,空间复杂度O（1），优缺点：效率不是很快。稳定性：稳定
快速排序：时间复杂度： 优化后O(n*logn),空间复杂度：递归：O（1），非递归O（n）,
优缺点：效率快，难理解。
稳定性：不稳定。