排序算法C++

Mysort.h

#pragma once
#include "pch.h"

//全排列字典序算法
void Allsortdic(vector<char> &a);

//全排列 递归写法,只能处理不包含重复元素的序列
void AllsortRecursion(vector<char>& a);

//归并排序 递归写法
void MergeSort_Recursion(vector<string> &a);

//归并排序-迭代写法
void MergeSort_Iterative(vector<string> &a);

//插入排序
void InsertSort(vector<string> &a);

//快速排序 递归写法
void QuickSort_Recursion(vector<string> &a);

//选择排序
void SelectSort(vector<string>& a);

//希尔排序
void ShellSort(vector<string> &a);

//堆排序
void HeapSort(vector<string> &a);

Mysort.cpp

#include "pch.h"
#include "MySort.h"



template<typename T>
void swapitem(vector<T> &a, int i, int j)
{
    if (i == j)
    {
        return;
    }
    T temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

template<typename T>
void printitem(vector<T> &a)
{
    for (size_t i = 0; i < a.size(); i++)
    {
        cout << a[i];
    }
    cout << endl;
}


//选择排序
void SelectSort(vector<string>& a)
{
    size_t length = a.size();
    for (size_t i = 0; i < length; i++)
    {
        size_t min = i;
        for (size_t j = i + 1; j < length; j++)
        {
            if (a[j] < a[min])
            {
                min = j;
            }
        }
        swapitem(a, i, min);
    }
}

//插入排序
void InsertSort(vector<string> &a)
{
    size_t length = a.size();
    for (size_t i = 1; i < length; i++)
    {
        for (size_t j = i; j >= 1; j--)
        {
            if (a[j] < a[j - 1])
            {
                swapitem(a, j, j - 1);
            }
        }
    }
}

//希尔排序
void ShellSort(vector<string> &a)
{
    int length = a.size();
    int h = 1;
    while (h < length / 3)
    {
        h = 3 * h + 1;
    }

    while (h >= 1)
    {
        for (size_t i = h; i < length; i++)
        {
            for (size_t j = i; j >= h; j -= h)
            {
                if (a[j] < a[j - h])
                {
                    swapitem(a, j, j - h);
                }
            }
        }
        h = h / 3;
    }

}



//归并排序-递归写法
void merge(vector<string> &a, int lo, int mid, int hi, vector<string> &temp)
{
    int i = lo;
    int j = mid + 1;

    for (int k = lo; k <= hi; k++)
    {
        temp[k] = a[k];
    }

    for (int k = lo; k <= hi; k++)
    {
        if (i > mid)
        {
            a[k] = temp[j++];
        }
        else if (j > hi)
        {
            a[k] = temp[i++];
        }
        else if (temp[i] < temp[j])
        {
            a[k] = temp[i++];
        }
        else
        {
            a[k] = temp[j++];
        }
    }
}
void DoMergeSort(vector<string> &a, int lo, int hi, vector<string> &temp)
{
    if (lo >= hi)
    {
        return;
    }
    int mid = lo + (hi - lo) / 2;
    DoMergeSort(a, lo, mid, temp);
    DoMergeSort(a, mid + 1, hi, temp);
    merge(a, lo, mid, hi, temp);
}
//归并排序-递归写法
void MergeSort_Recursion(vector<string> &a)
{
    vector<string> temp(a);
    DoMergeSort(a, 0, a.size() - 1, temp);
}

//归并排序-迭代写法
void MergeSort_Iterative(vector<string> &a)
{
    int length = a.size();
    vector<string> temp(a);
    for (int sz = 1; sz < length; sz = sz + sz)
    {
        for (int lo = 0; lo < length - sz; lo += sz + sz)
        {
            merge(a, lo, lo + sz - 1, min(lo + sz + sz - 1, length - 1), temp);
        }
    }
}

//快速排序-递归写法
int partition(vector<string> &a, int lo, int hi)
{
    int i = lo + 1;
    int j = hi;
    while (true)
    {
        while (i <= hi && a[i] < a[lo])
        {
            i++;
        }
        while (j >= lo && a[j] > a[lo])
        {
            j--;
        }
        if (i < j)
        {
            swapitem(a, i, j);
            i++;
            j--;
        }
        else
        {
            break;
        }
    }
    swapitem(a, lo, j);
    return j;
}

void sortq(vector<string> &a, int lo, int hi)
{
    if (lo >= hi)
    {
        return;
    }
    int j = partition(a, lo, hi);
    sortq(a, lo, j - 1);
    sortq(a, j + 1, hi);
}


//快速排序 递归写法
void QuickSort_Recursion(vector<string> &a)
{
    sortq(a, 0, a.size() - 1);
}

//只能处理不包含重复元素的序列
void allsort_simple(vector<char>& a, int begin)
{
    int end = a.size() - 1;
    if (begin >= end)
    {
        for (size_t i = 0; i < a.size(); i++)
        {
            cout << a[i];
        }
        cout << endl;
        return;
    }
    for (size_t i = begin; i <= end; i++)
    {
        swapitem(a, begin, i);
        allsort_simple(a, begin + 1);
        swapitem(a, begin, i);
    }
}

//全排列-递归写法,只能处理不包含重复元素的序列
void AllsortRecursion(vector<char>& a)
{
    allsort_simple(a, 0);
}

//全排列字典序算法
void Allsortdic(vector<char> &a)
{
    sort(a.begin(), a.end());
    printitem(a);
    while (true)
    {
        //从右向左查询第一个左边<右边的位置
        int index = 0;
        int j = a.size() - 2;
        while (j >= 0)
        {
            if (a[j] < a[j + 1])
            {
                index = j;
                break;
            }
            else
            {
                j--;
            }
        }
        if (j < 0)
        {
            return;
        }

        //从右向左查询第一个比index位置大的元素
        j = a.size() - 1;
        while (j >= 0)
        {
            if (a[j] > a[index])
            {
                break;
            }
            else
            {
                j--;
            }
        }
        swapitem(a, index, j);
        reverse(a.begin() + index + 1, a.end());

        printitem(a);
    }

}


//上浮
void swim(vector<string> &a, int k)
{
    while (k > 1 && (a[k] > a[k / 2]))
    {
       swapitem(a, k, k / 2);
       k = k / 2;
    }
}

//下沉,N:数据个数
void sink(vector<string> &a, int k, int N)
{
    int len = N + 1;
    while (k < len)
    {
        int j = 2 * k;
        if ((2 * k >= len) || (2 * k + 1 >= len))
        {
            break;
        }
        
        if ((2 * k + 1 < len) && (a[2 * k] < a[2 * k + 1]))
        {
            j++;
        }

        if (a[k] < a[j])
        {
            swapitem(a, k, j);
        }

        k = j;
    }
}

//假设0索引不保存数据
void DoHeapSort(vector<string> &a)
{
    int len = a.size();

    for (size_t i = len-1/2; i >= 1; i--)
    {
        sink(a, i, len-1);
    }
    int j = len - 1;
    while (j > 1)
    {
        swapitem(a, 1, j);
        j--;
        sink(a, 1, j);
    }
}

//堆排序
void HeapSort(vector<string> &a)
{
    a.insert(a.begin(), "");
    DoHeapSort(a);
}