习题算法（排序查找c++实现）

#include<iostream>
#include<vector>
#include<string>
#include<deque>
//插入排序算法时间复杂度是O(n^2)
template<typename T>
void insert_sort(std::vector<T>& array)
{
    if (array.size() != 1)
    {
        for (size_t j = 1; j < array.size(); j++)
        {
            auto temp = array[j];
            int i = j - 1;
            while (i >= 0 && array[i] < temp)
            {
                array[i + 1] = array[i];
                i--;
            }
            array[i + 1] = temp;
        }

    }
}
template<typename T>
void MERGE_insert(std::vector<T>& array, std::size_t p, std::size_t q, std::size_t r)
{
    auto n1 = q - p + 1;
    auto n2 = r - q;
    std::vector<T>temp;
    for (size_t i = 0; i < n1; i++) {
        temp.push_back(array[p + i]);
    }
    for (size_t j = 0; j < n2; j++) {
        temp.push_back(array[q + j + 1]);
    }

    insert_sort(temp);//更改为插入排序
    std::size_t j = 0;
    for (size_t k = p; k <= r; k++)
    {
        array[k] = temp[j];
        j = j + 1;
    }

}
template<typename T>
auto find_index(std::vector<T>arr, T value)
{
    for (size_t i = 0; i < arr.size(); i++)
    {
        if (arr[i] == value) { return i; }
    }
    //  return "There not exist this value";
}
template<typename T>
//二分的进行排序O(nlogn)
void MERGE(std::vector<T>& array, std::size_t p, std::size_t q, std::size_t r)
{
    auto n1 = q - p + 1;
    auto n2 = r - q;
    std::vector<T>left;
    std::vector<T>right;
    for (size_t i = 0; i < n1; i++) {
        left.push_back(array[p + i]);
    }
    for (size_t j = 0; j < n2; j++) {
        right.push_back(array[q + j + 1]);
    }
    T max = 1000;
    left.push_back(max);
    right.push_back(max);
    std::size_t i = 0;
    std::size_t j = 0;
    for (size_t k = p; k <= r; k++) {
        if (left[i] <= right[j])
        {
            array[k] = left[i];
            i = i + 1;
        }
        else
        {
            array[k] = right[j];
            j = j + 1;
        }
    }

}
template<typename T>
void MERGE_SORT(std::vector<T>& array, std::size_t p, std::size_t r)
{
    if (p < r)
    {
        auto q = ((p + r) / 2);
        MERGE_SORT(array, p, q);
        MERGE_SORT(array, q + 1, r);
        MERGE(array, p, q, r);

    }
}
//二分查找算法,时间复杂度是O(logn)
template<typename T>
void MERGE_FIND(std::vector<T>array, std::size_t p, std::size_t r,T num)
{
    //传递的是一个有序的数组
    auto q = (p + r) / 2;
    if (p<=r)
    {
        if (array[q] == num)
        {
            std::cout << "存在";
            
        }
        else if (array[q] < num)
        {
            MERGE_FIND(array,q + 1, r,num);
        }
        else if (array[q]>num)
        {
            MERGE_FIND(array,0, q - 1,num);
        }
    }
    
    
}
//时间复杂度O(n^2)
template<typename T>
void BUBBLESORT(std::vector<T>&array)
{
    for (size_t i = 0; i < array.size(); i++)
    {
        for (size_t j = array.size()-1; j>=i+1; j--)
        {
            if (array[j]<array[j-1])
            {
                std::swap(array[j], array[j - 1]);
            }
        }
    }
}
//多项式求值算法
//时间复杂度为O(n)
template<typename T,typename T1>
T POLYNOMIAL(std::vector<T>COEF,T1 x)
{
    int degree=COEF.size()-1;
    auto y = 0;
    while (degree >= 0) { y = COEF[degree] + x * y; degree--; }
    return y;
}