# Audio and video development journey (26) algorithm series – selection, insertion sorting and the implementation of sort in STL

Time：2022-1-7

## catalogue

1. Select sort
2. Insert sort
3. Implementation of sort in STL
4. data
5. harvest

In this article, we will learn and practice the selection sorting and insertion sorting, and then analyze the implementation of the sorting algorithm in the STL of CPP to end the phase of the sorting algorithm.

## 1、 Select sort

1. Suppose that the array content value corresponding to a subscript is the minimum value (generally the first undetermined value is used), and then use this value to compare the size with all subsequent values. If the latter value is less than this value, first record the position and value of the minimum value, and then compare the subsequent values. After a loop traversal, the minimum value changes greatly compared with the initial minimum value, Exchange if any.
2. Add 1 to the subscript and repeat the first step

The implementation is relatively simple. We don’t draw pictures and analyze them. Detailed comments are added to the code

``````#include <iostream>
#include<array>
#include<algorithm>

using namespace std;

void printSortArray(int myarray[],int size){

for(int k=0; k<size; k++)
{
cout<<myarray[k]<<" ";
}
cout<<endl;
}

void swap(int *a,int i,int j)
{
int tmp = a[i];
a[i] = a[j];
a[j]=tmp;
}

void selectSort(int *a,int length)
{
for(int i = 0;i<length;i++)
{
//First, assume that the first element is the minimum value and traverse the record externally
int min = a[i];
int minPos = i;

for(int j =i+1;j<length;j++)
{
//Conduct a round of comparison with the minimum value assumed above. If the subsequent value is smaller than the assumed minimum value, assign the value to the minimum value,
if(min>a[j])
{
min =a[j];
minPos = j;
}

}
//After a round of comparison, check whether the subscript of the minimum value changes. If so, exchange it
if(i !=minPos)
{
swap(a,i,minPos);
}
//After one round, the rightmost pit is used only by the minimum value of the current wheel, and then the value of subsequent pit is determined by recirculation
}
}

int main(void) {
//Using a one bit array to represent a complete binary tree, its parent node and its left and right child nodes can be obtained from any node

int myarray[] ={6,7,1,2,10,5,8,3,4};

int size = sizeof(myarray)/sizeof(myarray) ;

cout<<"size="<<size<<endl;

selectSort(myarray,size);

printSortArray(myarray,size);

return 0;
}``````

When you see the selection sort, it’s easy to think of the bubble sort we learned and practiced earlier. What’s the difference between them?

Bubble sorting is a comparison between two adjacent pairs. Each comparison may trigger interaction. Bubble sorting is to find the position by counting.
Selecting sorting is to assume that one is the minimum value, then compare the size with all the following contents one by one, and exchange once in each round. To select sorting, first determine the location and then find the value.

Their advantages are relatively simple, but their disadvantages are also obvious. The time complexity is O (n ^ 2). Selective sorting will also destroy the stability of the original order (that is, when there are the same values, the sequence before and after sorting the same values by selection will be destroyed).

## 2、 Insert sort

Insertion sorting is like when we play cards, the cards in our hands have been sorted. Start a new card and insert it into the appropriate position in the existing ordered cards. In order to make room for the elements to be inserted, we need to move the other elements larger than the value to be inserted to the right before insertion.
Insert a suitable application scenario: it is very efficient to insert non random (i.e. ordered) queues.

Let’s start the insertion sorting process step by step by drawing The implementation is as follows

``````#include <iostream>
#include<array>
#include<algorithm>

using namespace std;

void printSortArray(int myarray[],int size){

for(int k=0; k<size; k++)
{
cout<<myarray[k]<<" ";
}
cout<<endl;
}

void swap(int *a,int i,int j)
{
int tmp = a[i];
a[i] = a[j];
a[j]=tmp;
}

void insertSort(int *a,int length)
{
//The array subscript starts at 1 and is compared with the previous value
int i,j,tmp;
for(i=1;i<length;i++){

int tmp= a[i];

for (j = i-1; j>=0; j--)
{
//If the following is less than the value of a position in the previous sequence table, move the value of the current bit backward by one bit and cycle in turn
if(tmp< a[j]){
a[j+1] = a[j];

} else {
break;
}
}
//After jumping out of the loop, assign TMP to the place to be inserted
a[j+1] = tmp;
}

}

int main(void) {
//Using a one bit array to represent a complete binary tree, its parent node and its left and right child nodes can be obtained from any node

int myarray[] ={6,7,1,2,10,5,8,3,4};

int size = sizeof(myarray)/sizeof(myarray) ;

cout<<"size="<<size<<endl;

insertSort(myarray,size);

printSortArray(myarray,size);

return 0;
}``````

## 3、 Implementation of sorting algorithm in STL

Through these four articles on sorting algorithms, we understand the principle and implementation of basic selection sorting, insertion sorting, bubble sorting, quick sorting and heap sorting. Next, let’s look at the specific implementation of STL sorting algorithm in CPP

``````template<typename _RandomAccessIterator>
05206     inline void
05207     sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
05208     {
05209       typedef typename iterator_traits<_RandomAccessIterator>::value_type
05210     _ValueType;
05211
05212       // concept requirements
05213       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
05214         _RandomAccessIterator>)
05215       __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
05216       __glibcxx_requires_valid_range(__first, __last);
05217
05218       if (__first != __last)
05219     {
05220       std::__introsort_loop(__first, __last,
05221                 std::__lg(__last - __first) * 2);
05222       std::__final_insertion_sort(__first, __last);
05223     }
05224     }
``````

__ LG function calculates the recursion depth to control the deterioration of segmentation. When the recursion depth reaches this value, heap sorting is used instead, because the time complexity of heap sorting is constant as nlogn

``````/// This is a helper function for the sort routines.  Precondition: __n > 0.
02308   template<typename _Size>
02309     inline _Size
02310     __lg(_Size __n)
02311     {
02312       _Size __k;
02313       for (__k = 0; __n != 0; __n >>= 1)
02314     ++__k;
02315       return __k - 1;
02316     }
``````

The implementation of quick sort is as follows:

``````02242   /// This is a helper function for the sort routine.
02243   template<typename _RandomAccessIterator, typename _Size>
02244     void
02245     __introsort_loop(_RandomAccessIterator __first,
02246              _RandomAccessIterator __last,
02247              _Size __depth_limit)
02248     {
02249       typedef typename iterator_traits<_RandomAccessIterator>::value_type
02250     _ValueType;
02251
//The number of intervals is greater than_ S_ Threshold uses quick sort
02252       while (__last - __first > int(_S_threshold))
02253     {
//If the specified recursion depth is reached, use heap sort instead
02254       if (__depth_limit == 0)
02255         {
02256           _GLIBCXX_STD_P::partial_sort(__first, __last, __last);
02257           return;
02258         }
02259       --__depth_limit;
02260       _RandomAccessIterator __cut =
02261         std::__unguarded_partition(__first, __last,
02262                        _ValueType(std::__median(*__first,
02263                                 *(__first
02264                                   + (__last
02265                                      - __first)
02266                                   / 2),
02267                                 *(__last
02268                                   - 1))));
02269       std::__introsort_loop(__cut, __last, __depth_limit);
02270       __last = __cut;
02271     }
02272     }``````

Implementation of insertion sorting part:

``````/// This is a helper function for the sort routine.
02171   template<typename _RandomAccessIterator>
02172     void
02173     __final_insertion_sort(_RandomAccessIterator __first,
02174                _RandomAccessIterator __last)
02175     {
02176       if (__last - __first > int(_S_threshold))
02177     {
02178       std::__insertion_sort(__first, __first + int(_S_threshold));
02179       std::__unguarded_insertion_sort(__first + int(_S_threshold), __last);
02180     }
02181       else
02182     std::__insertion_sort(__first, __last);
02183     }

02093   /// This is a helper function for the sort routine.
02094   template<typename _RandomAccessIterator>
02095     void
02096     __insertion_sort(_RandomAccessIterator __first,
02097              _RandomAccessIterator __last)
02098     {
02099       if (__first == __last)
02100     return;
02101
02102       for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
02103     {
02104       typename iterator_traits<_RandomAccessIterator>::value_type
02105         __val = *__i;
02106       if (__val < *__first)
02107         {
02108           std::copy_backward(__first, __i, __i + 1);
02109           *__first = __val;
02110         }
02111       else
02112         std::__unguarded_linear_insert(__i, __val);
02113     }
02114     }
`````` Image source: [C + + a deep pit interview question: what sort algorithm is used for the sort algorithm in STL?]:https://blog.csdn.net/qq_35440678/article/details/80147601

## 4、 Information

Algorithm
[difference between bubble sort and selection sort]:https://blog.csdn.net/weixin_41887155/article/details/85799820
[detailed explanation of sorting algorithm (I) direct insertion sorting]:https://www.bilibili.com/video/BV1Jv41167eL?from=search&seid=385501809024223768
[C + + a deep pit interview question: what sort algorithm is used for the sort algorithm in STL?]:https://blog.csdn.net/qq_35440678/article/details/80147601

## 5、 Harvest

1. Understand and implement selection sorting and insertion sorting
2. Understand the reason why sort uses quick sort, heap sort and insert sort in STL and the code implementation
There are many other types of sorting algorithms, such as Hill sorting, merge sorting, bucket sorting, etc. we don’t do learning and practice at this stage, and continue as needed.