Insertion Sort and Selection Sort Implementation

Question

I wanted to practice using templates since I have no experience with them, so I implemented these sorting algorithms.

Selection Sort:

template<typename Container>
void selectionSort(Container& numbers)
{
    for (auto iter = std::begin(numbers), iterEnd = std::end(numbers); iter != iterEnd; ++iter)
    {
        auto minNum = minIndex(numbers, iter, iterEnd);

        std::swap(*iter, *minNum);
    }
}

template<typename Container, typename Iter>
Iter minIndex(const Container& numbers, Iter start, Iter end)
{
    Iter minIdx = start;
    auto minNum = *start;

    while (++start != end)
    {
        if (*start < minNum)
        {
            minNum = *start;
            minIdx = start;
        }
    }
    return minIdx;
}

Insertion Sort:

template<typename Container>
void insertionSort(Container& numbers)
{
    for (auto iter = std::begin(numbers) + 1, iterEnd = std::end(numbers); iter != iterEnd; ++iter)
    {
        if (*iter < *(iter-1))
        {
            resort(numbers, iter);
        }
    }
}
template<typename Container, typename Iter>
void resort(Container& numbers, Iter containerIter)
{
    auto temp = *containerIter;

    while (containerIter != std::begin(numbers) && temp < *(containerIter-1))
    {
        *containerIter = *(containerIter - 1);
        --containerIter;
    }

    *containerIter = temp;
}

Answer 1

First tip: use more aggressive warnings, this way you would be warned by the compiler about passing unused parameters into functions, that is you would automatically made:

template<typename Iter>
Iter minIndex(Iter start, Iter end)

Another thing would be, to write your algorithms in similar way as the standard ones. That is avoid passing the reference to the container, but rather pass iterators into it. So your sort functions should look similarly to:

<typename InputIt>
void someSort (InputIt first, InputIt last)

This will e.g. allow you to sort specific parts of your container with no extra effort.

Answer 2

There is no need for minIndex, this functionality is already available in the standard. So you could do e.g.,:

template<typename Container>
void selectionSort(Container& numbers)
{
    for (auto it = std::begin(numbers); it != std::end(numbers); ++it)
    {
        std::iter_swap(it, std::min_element(it, v.end()));
    }
}

A similar comment holds for insertion sort, see this question and one of its answers.