数据结构_排序

常见排序
1.插入排序：直接插入排序，希尔排序
2.选择排序：选择排序，堆排序
3.交换排序：冒泡排序，快速排序
4.归并排序：归并排序

插入排序
直接插入排序：元素越接近有序，时间效率越高
最优情况：O(N）
最差情况：O(N^2)
空间复杂度：O(1)
是一种稳定的排序算法

typedef int DataType;

void swap(DataType* a, DataType* b)
{
    DataType c = *a;
    *a = *b;
    *b = c;
}

void swapit(vector<DataType>::iterator it1, vector<DataType>::iterator it2)
{
    DataType x = *it1;
    *it1 = *it2;
    *it2 = x;
}
void InsertSort(vector<DataType>& v)
{
    int size = v.size();
    int index = 0;
    while(index < size-1)
    {
        while(index >=0 && v[index] > v[index+1])
        {
            swap(&v[index], &v[index+1]);
            index--;
        }
        index++;
    }
}
//插入排序

希尔排序
缩小增量排序，直接插入排序的优化，但是不稳定

void ShellSort(vector<DataType>& v)
{
    int size = v.size();
    int len = size / 3 + 1;
    while (len > 0)
    {
        int i = 0;
        while (i < size - len)
        {
            int j = i;
            while (j >= 0 && v[j] > v[j + len])
            {
                swap(&v[j], &v[j + len]);
                j--;
            }
            i++;
        }
        if (len == 1)
            break;
        len = len/3+1;
    }
}
//希尔排序

选择排序
直接选择排序
时间复杂度：O(N^2)
不稳定的排序算法

void SelectSort(vector<DataType>& v)
{
    vector<DataType>::iterator max = v.begin();
    vector<DataType>::iterator min = v.begin();
    vector<DataType>::iterator left = v.begin();
    vector<DataType>::iterator right = v.end()-1;

    while(left < right)
    {
        vector<DataType>::iterator it = left;
        max = left;
        min = left;
        while(it <= right)
        {
            if(*max < *it)
                max = it;
            if(*min > *it)
                min = it;
            it++;
        }
        swapit(left, min);
        if(min != right && max != left)
            swapit(right, max);
        left++;
        right--;
    }
}
//选择排序

堆排序
时间复杂度：O(N*log2 N)
不稳定的排序算法

static void AdjustDown(vector<DataType>& v, size_t size, size_t m)
{
    if(m >= size)
        return;
    size_t parent = m;
    size_t child = parent*2 + 1;
    while(child < size)
    {
        if(child+1 < size && v[child] < v[child+1])
            child++;
        if(v[parent] < v[child])
        {
            swap(&v[parent], &v[child]);
            parent = child;
            child = parent*2+1;
        }
        else
            break;
    }
}

static void MakeHeap(vector<DataType>& v)
{
    int i = (v.size()-2)>>1;
    while(i>=0)
    {
        AdjustDown(v, v.size(), i);
        i--;
    }
}

void HeapSort(vector<DataType>& v)
{
    MakeHeap(v);
    size_t size = v.size();
    while(size > 0)
    {
        swap(&v[0], &v[size-1]);
        size--;
        AdjustDown(v, size, 0);
    }
}
//堆排序

交换排序
冒泡排序
最好情况时间复杂度：O(N)
最坏情况时间复杂度：O(N^2)
空间复杂度：O(1)
是一种稳定的排序算法

void BubbleSort(vector<DataType>& v)
{
    vector<DataType>::iterator right = v.end();
    for(int i = 0 ; i < v.size(); i++)
    {
        vector<DataType>::iterator next = v.begin();
        while(next < right-1)
        {
            if(*next > *(next+1))
                swapit(next, next+1);
            next++;
        }
        right--;
    }
}
//冒泡排序

快速排序
最好时间复杂度：O(N*log2 N)
最坏时间复杂度：O(N^2)
空间复杂度：O(log2 N)
是一种不稳定的排序

static size_t middle(vector<DataType>& v, size_t left, size_t right)
{
    size_t mid = left + (right - left)/2;
    if(v[left] > v[right])
    {
        if(v[mid] > v[left])
            return left;
        else if(v[mid] < v[right])
            return right;
        else
            return mid;
    }
    else
    {
        if(v[mid] > v[right])
            return right;
        else if(v[mid] < v[left])
            return left;
        else
            return mid;
    }
}

void QuickSort(vector<DataType>& v, size_t left, size_t right)
{
    size_t i = left;
    size_t j = right;

    if(left >= right)
        return;
    DataType key = v[left];
    while(i < j)
    {
        while(i < j && v[j] >= key)
            j--;
        swap(&v[i], &v[j]);
        while(i < j && v[i] < key)
            i++;
        swap(&v[i], &v[j]);
    }
    if(left < i)
        QuickSort(v,left, i-1);
    if(right > i)
        QuickSort(v, i+1, right);
}
//快速排序

void QuickMidSort(vector<DataType>& v, size_t left, size_t right)
{
    size_t i = left;
    size_t j = right;
    if(left >= right)
        return;

    if(right - left < 5)
    {
        InsertSort(v);
        return;
    }
    size_t mid = middle(v, left, right);

    while(i < j)
    {
        while(i < j && v[i] < v[mid])
            i++;
        swap(&v[i], &v[mid]);
        mid = i;

        while(i < j && v[j] >= v[mid])
            j--;
        swap(&v[mid], &v[j]);
        mid = j;
    }

    while(right > j && v[j] == v[j+1])
        j++;

    if(left < i)
        QuickMidSort(v,left, i-1);
    if(right > j)
        QuickMidSort(v, j+1, right);
}
//快速排序

归并排序
时间复杂度：O(N*log2 N)
空间复杂度：O(N)
是一种稳定的排序算法

void MergerSort(vector<DataType>& v, size_t left, size_t right)
{
    if(left >= right)
        return;

    if(right - left < 5)
    {
        InsertSort(v);
        return;
    }
    else
    {
        size_t mid = left + (right - left)/2;
        if(left < mid)
            MergerSort(v,left, mid);
        if(right > mid+1)
            MergerSort(v,mid+1, right);

        vector<DataType> v1;
        vector<DataType> v2;
        size_t i, j, k = left;
        for(i = left; i <= mid; i++)
        {
            v1.push_back(v[i]);
        }
        for(j = mid+1; j <= right; j++)
        {
            v2.push_back(v[j]);
        }
        i = 0;
        j = 0;
        while(i <= mid-left && j <= right-mid-1)
        {
            if(v1[i] < v2[j])
            {
                v[k] = v1[i];
                i++;
                k++;
            }
            else
            {
                v[k] = v2[j];
                j++;
                k++;
            }
        }
        while(i <= mid - left)
        {
            v[k] = v1[i];
            i++;
            k++;
        }
        while(j <= right - mid - 1)
        {
            v[k] = v2[j];
            j++;
            k++;
        }

    }

}
//归并排序