插入排序与计数排序

一、插入排序

    我们什么时候可以认定一个数组是有序的不需要判定？  比如说数组当中只有一个值，只有一个元素（默认有序）。

    思想：将待排序数组分为有序表和无序表，每次重无序表中取出一个元素，插入到有序表的适当位置。一开始有序表是一个数，无序表是n-1个数。每遍历一次，有序表中元素增加一个，无序表中元素减少一个，重复n-1次完成排序。

    如何在无序区中找到合适的元素放在有序区呢？   找到无序区的第一个元素与有序区的最后一个元素进行比较（这里先假设升序排序）那么无序区第一个元素若为i那么有序区最后一个元素为i-1；

代码：：

#include <iostream>

#include <vector>

using namespace std;

void insertsort( vector< int>& v)

{

         int n = v.size();

         for ( int i = 1; i <= n-1 ; i++)  //分成了两个数组一个是有序数组一个是无序数组  有序数组初始为一 无序数组初始则为n-1而且 变量

        {

                int j = i - 1;               //有序区最后一个元素的下标

                int temp = v [i ];                       //储存无序区第一个元素的值，防止被覆盖

                for (j; j >= 0; j--)           //有序区元素的下标

               {

                        if (temp < v [j ])

                       {

                               v [j + 1 ] = v [j ];

                       }

                        else

                       {

                               break;

                       }

               }

                v [j + 1 ] = temp; //要把j多减的一次补回来；

        }

}

int main()

{

         vector< int>v = {1,5,4,7,6,3,1,3,4};

         int n = v.size();

        insertsort(v);

         for ( int i = 0; i < n; i++)

        {

               cout << v [i ] << " ";

        }

         return 0;

}

最优的情况下：如果数列本身就是升序的，总共就比了n-1次                         O（n）;

最差的情况下：如果数列本身就是降序的，总共就比了(n-1)*(n-2)……*1次     O（n^2）

稳定性：是稳定的

二、计数排序

    原理将数值作为桶号，遍历整个数组，将相应的桶进行计数。

        第一步：

        遍历原数组，找到最大值max并且申请max+1个桶，初始化都为0（下标从0到max）

        第二步：

        遍历原数组，找到每个数值对应的桶号，并对桶计数++，即bucket[a[i]]++;

        第三步：

        遍历桶数组，看对应的桶内计数为几就取出几个下标值，放到原数组，即while(bucket[i]--)a[index+++]=i;

        需要遍历几次呢？ 3次

          vector< int>bucket(max + 1);  //有参构建里面的元素默认为0，可以看第四期算法

#include <iostream>

#include <map>

#include <vector>

using namespace std;

int maxval( vector< int>& v)

{

         int n = v.size();

         int max = v [0 ];

         for ( int i = 1; i < n; i++)

        {

                if ( v [i ] > max)

               {

                       max = v [i ];

               }

        }

         return max;

}

void bubctketsort( vector< int>& v)

{

         int max = maxval( v);

         vector< int>bucket(max + 1); //有参构建里面的元素默认为0

         int n = v.size();

         for( int i = 0; i < n; i++)

        {

               bucket [ v [i ]]++;    //注意这步是存储值的次数

        }

         int index = 0;

         for ( int i = 0; i <= max; i++)

        {

                while (bucket [i ]--)  //这里总体的循环次数为n故此时间复杂度也为O(n)

               {

                       v [index++ ] = i; //将记录多少次元素的值放在数组当中

               }

        }

}

int main()

{

         vector< int> v{1,5,4,7,6,3,1,3,4};

         int n = v.size();

        bubctketsort(v);

         for ( int i = 0; i < n; i++)

        {

               cout << v [i ] << " ";

        }

         return 0;

}

时间复杂度为：O（n）

稳定性：是稳定的        

补充：

目前学习的四种排序方法

计数排序：时间复杂度是最低的 其余的都是O（n^2）(不包括最优）

冒泡排序与插入排序最优都为O(n);

除了选择排序以外其余的都是稳定的（四种排序内）

数组是不能有 负数 的但是思想可以在其他的地方体现如 map

一个算法的效率可以分为时间效率和空间效率