• 【C++】vector的模拟实现

    目录

    前言：vector的简单介绍

     一、Member variables

    二、Iterators

    三、Capacity

    1、size

    2、capacity

    3、reserve

    4、resize

    四、Modifiers

    1、push_back

    2、pop_back()

    3、insert

    4、erase

    5、swap

    六、Element access

    1、[ ]操作符重载

    2、front

    3、back

    七、Member functions

    1、构造函数

    (1)无参构造

    (2)迭代器区

    (3)拷贝构造

    (4)用n个元素构造

    2、析构函数

    3、=操作符重载

    八、完整代码

    总结

    前言：vector的简单介绍

    vector是STL中特别常用的容器，它能够给我们提供类似于C语言的数组的用法，[ ]是它最常用的遍历方式

    它具有多个构造函数 

    在后面我们会一一实现

    vector是一个模板类，类中的元素可以是任意数据类型，最常用的就是二维数组vector> 最外层的vector的每个元素都是vector类型，内部的vector的每个元素的数据类型是int，这种结构使用起来就特别像C语言的二维数组

    vector的其它成员函数，与string中的类似，就不一一赘述了。

    文章目录参考：https://cplusplus.com

     一、Member variables

    vector的成员变量与string不一样，它的成员变量都是迭代器，因为vector的空间是连续的，所以它的迭代器是原生指针。

     

    它的基本构造是这样的，也就是说它有三个成员变量，_start ,_finish, _end_of_storage

    我们再看看stl源码是怎样写的

     

    与我们的猜想一致 

    二、Iterators

    迭代器，我们前面说过，它就是原生指针，那么就比较简单了，它的迭代器的写法与string的差不多

    1.  typedef T* iterator;
    2.  typedef const T* const_iterator;

    因为vector是模板类，所以它的迭代器就是T*的指针

    1.           iterator begin()
    2.           {
    3.               return _start;
    4.           }
    5.   
    6.           const_iterator begin()const 
    7.           {
    8.               return _start;
    9.           }
    10.   
    11.           iterator end()
    12.           {
    13.               return _finish;                                                                                                                                                              
    14.           }
    15.   
    16.           const_iterator end()const
    17.           {
    18.               return _finish;
    19.           }

    这些都是最基本的内容

    三、Capacity

    这里面一共实现了四个成员函数

    1、size

    size就是_finish减去_start就是vector的size

    1.           const size_t size()const
    2.           {
    3.               return _finish - _start;
    4.           }

    2、capacity

    capacity是_end_of_storage 减去_start

    1.           const size_t capacity()const 
    2.           {
    3.               return _end_of_storage - _start;
    4.           }

    3、reserve

    resize与string的类似，都是先开辟空间，拷贝数据，释放旧空间，调整_start,_finish,_end_of_storage

    不过这里有两个要点需要注意，这里是vector它的成员变量是指针，我们开辟空间之后只会把_start的值更改为新空间的起始地址，但是_finish和_end_of_storage需要我们手动的修改

    而如何求出_finish在新空间的位置呢？

    很简单，我们只需要记录_finish和_start之间的偏移量就可以了，开辟新空间后偏移量加上_start就是_finish的位置，而end_of_storage的位置也就好办了，因为我们开辟空间开辟的是n个元素的空间，偏移量就是n,end_of_storage就是_start加上n

    另外一个注意点就是拷贝数据，对于像string这样的类来说拷贝数据十分的简单，因为它的元素的类型是固定的就是char，我们直接strcpy就能够拷贝，但是vector的数据类型是不确定的，如果直接使用strcpy或者是memcpy很容易造成浅拷贝，如果是vector>这样的类型呢？

    因此我们不能这样做，我们需要手动赋值，而手动赋值就需要我们实现T这个vector的变量类型的赋值=操作符重载(如果不是内置类型)

    1.           //扩容，为了兼容T是自定义类型，为了实现深拷贝，不使用memcpy
    2.           void reserve(size_t n)
    3.           {
    4.               if(n > capacity())
    5.               {
    6.                   size_t len = _finish - _start;
    7.                   T* tmp = new T[n];
    8.                   if(_start)
    9.                   {
    10.                       //拷贝数据，为了实现深拷贝，不使用memcpy
    11.                       for(size_t i = 0; i < len; i++)
    12.                       {
    13.                           tmp[i] = _start[i];
    14.                       }
    15.                       
    16.                       delete[] _start;
    17.                   }
    18.                   _start = tmp;
    19.                   _finish = _start + len;
    20.                   _end_of_storage = _start + n;
    21.               }                                                                                                                                                                            
    22.           }

    4、resize

    resize与reserve类似，在reserve的基础上加入了初始化，缩容等

    resize分为三种情况：

    1、n > capacity  扩容+初始化

    2、n > size 初始化

    3、n < size 缩容

    缩容十分的简单，我们直接将_finish减小就可以了

    剩下的就没有什么要点了

    1.           //三种情况，比capacity()大，在size()和capacity之间,比size()小
    2.           void resize(size_t n, const T& val = T())
    3.           {
    4.               if(n > capacity())
    5.               {
    6.                   reserve(n);
    7.               }
    8.               
    9.               //初始化
    10.               if(n > size())
    11.               {
    12.                   while(_finish < _start + n)
    13.                   {
    14.                       *_finish = val;
    15.                       _finish++;
    16.                   }
    17.               }
    18.               else
    19.               {
    20.                   _finish = _start + n;
    21.               }
    22.           }

    四、Modifiers

    1、push_back

    尾插，与我们前面所学过的数据结构和string的大体相差不大

    检查容量，插入元素，size++

    1.           //使用cosnt &为了能够传临时对象
    2.           void push_back(const T& x)
    3.           {
    4.               if(_finish == _end_of_storage)
    5.               {                                                                                                                                                                            
    6.                   reserve(capacity() == 0 ? 4 : capacity() * 2);
    7.               }
    8.   
    9.               *_finish = x;
    10.               _finish++;
    11.           }

    2、pop_back()

    _finish直接向前挪动一位就可以了

    1.           void pop_back()
    2.           {
    3.               assert(size() > 0);
    4.   
    5.               _finish--;
    6.           }

    3、insert

    insert要注意的问题就比较多了，它会出现迭代器失效的问题，

    它的大体框架与string的insert没有什么差别

    不过vector的insert要传入的是插入位置的iterator，与string的不同，string传入的是下标

    因为C++并没有对标realloc的操作符，导致我们只能new一块新空间然后将数据拷贝，但是这就会导致pos位置失效，因为pos指向的是原空间，但是我们是先扩容再插入，所以我们就需要手动修正pos位置，修正的过程与前面的reserve类似，先记录偏移量，然后与空间起始位置相加

    1.           //返回值是iterator 返回的是最近一次插入的元素位置
    2.           iterator insert(iterator pos, const T& x)
    3.           {
    4.               assert(pos >= _start);
    5.               assert(pos <= _finish);
    6.   
    7.               if(_finish == _end_of_storage)
    8.               {
    9.                   //修正pos的位置
    10.                   size_t len = pos - _start;
    11.                   reserve(capacity() == 0 ? 4 : capacity() * 2);
    12.                   pos = _start + len;
    13.               }
    14.   
    15.               iterator end = _finish - 1;//是地址，怎末写都无所谓
    16.               while(end >= pos)
    17.               {
    18.                   *(end + 1) = *end;
    19.                   end--;
    20.               }
    21.   
    22.               *pos = x;
    23.               _finish++;
    24.   
    25.               return pos;
    26.           }

    4、erase

    erase会不会发生迭代器失效呢？

    答案是不确定的：因为STL只是一个规范，他没有要求具体的实现细节，如果会出现迭代器失效，那么可能它的底层实现了缩容，如果没有失效可能没有缩容。

    eraser实现与string类似都是将需要删除的数据位置，那后面的数据覆盖，这里面就不用担心浅拷贝的问题，因为只要T实现了深拷贝，我们直接调用它的=操作符重载就可以了

    1.           //返回值同理,删除元素的下一个位置
    2.           iterator erase(iterator pos)
    3.           {                                                                                                                                                                                
    4.               assert(pos >= _start);
    5.               assert(pos < _finish);
    6.   
    7.               iterator begin = pos + 1;
    8.               while(begin < _finish)
    9.               {
    10.                   *begin = *(begin - 1);
    11.                   begin++;
    12.               }
    13.   
    14.               return pos;
    15.           }

    5、swap

    这里实现的swap与std里面的swap功能相同，不过效率不同，std里面的swap使用了拷贝构造

    同时这里面的swap是为了拷贝构造和=操作符重载的现代写法打基础

    1.           void swap(vector& v)
    2.           {
    3.               std::swap(_start, v._start);
    4.               std::swap(_finish, v._finish);
    5.               std::swap(_end_of_storage, v._end_of_storage);
    6.           }

    六、Element access

    这里就十分的简单了

    1、[ ]操作符重载

    1.           T& operator[](size_t pos)
    2.           {
    3.               assert(pos < size());
    4.   
    5.               return _start[pos];
    6.           }
    7.   
    8.           const T& operator[](size_t pos)const 
    9.           {
    10.               assert(pos < size());
    11.   
    12.               return _start[pos];
    13.           }

    2、front

    1.           T& front()
    2.           {
    3.               assert(size() > 0);
    4.               return *_start;
    5.           }

    3、back

    1.           T& back()
    2.           {
    3.               assert(size() > 0);                                                                                                                                                          
    4.               return *(_finish - 1);
    5.           }

    七、Member functions

    终于来到了最后

    1、构造函数

    (1)无参构造

    无参构造直接将所有的成员变量置为nullptr

    1.           //无参构造
    2.           vector()
    3.               :_start(nullptr)
    4.               ,_finish(nullptr)
    5.               ,_end_of_storage(nullptr)
    6.           {}

    (2)迭代器区

    迭代器区间构造就需要我们再定义一套模板参数，因为vector可以拿别的容器的迭代器区间来构造

    1.           //构造函数，用其它容器的迭代器来构造
    2.           template<class InputIterator>
    3.           vector(InputIterator first, InputIterator last)
    4.               :_start(nullptr)
    5.               ,_finish(nullptr)
    6.               ,_end_of_storage(nullptr)
    7.           {
    8.               while(first != last)
    9.               {
    10.                   push_back(*first);
    11.                   first++;
    12.               }
    13.           }
    14.

    (3)拷贝构造

    我们直接使用现代写法，直接与形参交换数据

    1.           //拷贝构造，现代写法
    2.           vector(const vector& v)
    3.               :_start(nullptr)
    4.               ,_finish(nullptr)
    5.               ,_end_of_storage(nullptr)
    6.           {                                                                                                                                                                                
    7.               vector tmp(v.begin(), v.end());
    8.               swap(tmp);
    9.           }
    10.

    (4)用n个元素构造

    这里面比较复杂，我们需要重载多个这种函数来实现，因为如果直接只有一种参数是size_t，那么传入两个int类型的参数时就会被前面的迭代器区间的构造函数调用，造成非法的间接寻址的错误，因为前面的构造函数的参数比size_t这个函数的参数更加吻合，为了应对这种情况，所以使用了多个重载

    这是库中的实现也是多个构造函数重载

    1.           vector(int n, const T& value)
    2.               :_start(nullptr)
    3.               ,_finish(nullptr)
    4.               ,_end_of_storage(nullptr)
    5.           {
    6.               for(int i = 0; i < n; i++)
    7.               {
    8.                   push_back(value);
    9.               }
    10.           }
    11.                
    12.           vector(long n, const T& value)
    13.               :_start(nullptr)
    14.               ,_finish(nullptr)
    15.               ,_end_of_storage(nullptr)
    16.           { 
    17.                for(long i = 0; i < n; i++)
    18.                {
    19.                    push_back(value);
    20.                }
    21.           }
    22.   
    23.           vector(size_t n, const T& value = T())
    24.               :_start(nullptr)
    25.               ,_finish(nullptr)
    26.               ,_end_of_storage(nullptr)
    27.           { 
    28.                for(size_t i = 0; i < n; i++)
    29.                {
    30.                    push_back(value);
    31.                }
    32.           }                                                                                                                                                                                
    33.

     

    2、析构函数

    1.           ~vector()
    2.           {
    3.               delete[] _start;
    4.               _start = _finish = _end_of_storage = nullptr;
    5.           }

    3、=操作符重载

    1.           //赋值=重载
    2.           vector& operator=(vector v)
    3.           {
    4.               swap(v);
    5.               return *this;
    6.           }
    7.

    八、完整代码

    1. #pragma once 
    2. #include 
    3. #include 
    4. #include
    5.  
    6. using namespace std;
    7.  
    8. namespace ww
    9. {
    10.     template<class T>
    11.     class vector 
    12.     {
    13.         typedef T* iterator;
    14.         typedef const T* const_iterator;
    15.     public:
    16.         //无参构造
    17.         vector()
    18.             :_start(nullptr)
    19.             ,_finish(nullptr)
    20.             ,_end_of_storage(nullptr)
    21.         {}
    22.  
    23.         const size_t size()const
    24.         {
    25.             return _finish - _start;
    26.         }
    27.  
    28.         const size_t capacity()const 
    29.         {
    30.             return _end_of_storage - _start;
    31.         }
    32.  
    33.         iterator begin()
    34.         {
    35.             return _start;
    36.         }
    37.  
    38.         const_iterator begin()const 
    39.         {
    40.             return _start;
    41.         }
    42.  
    43.         iterator end()
    44.         {
    45.             return _finish;
    46.         }
    47.  
    48.         const_iterator end()const
    49.         {
    50.             return _finish;
    51.         }
    52.  
    53.         ~vector()
    54.         {
    55.             delete[] _start;
    56.             _start = _finish = _end_of_storage = nullptr;
    57.         }
    58.  
    59.         T& operator[](size_t pos)
    60.         {
    61.             assert(pos < size());
    62.  
    63.             return _start[pos];
    64.         }
    65.  
    66.         const T& operator[](size_t pos)const 
    67.         {
    68.             assert(pos < size());
    69.  
    70.             return _start[pos];
    71.         }
    72.  
    73.  
    74.  
    75.  
    76.  
    77.         //扩容，为了兼容T是自定义类型，为了实现深拷贝，不使用memcpy
    78.         void reserve(size_t n)
    79.         {
    80.             if(n > capacity())
    81.             {
    82.                 size_t len = _finish - _start;
    83.                 T* tmp = new T[n];
    84.                 if(_start)
    85.                 {
    86.                     //拷贝数据，为了实现深拷贝，不使用memcpy
    87.                     for(size_t i = 0; i < len; i++)
    88.                     {
    89.                         tmp[i] = _start[i];
    90.                     }
    91.                     
    92.                     delete[] _start;
    93.                 }
    94.                 _start = tmp;
    95.                 _finish = _start + len;
    96.                 _end_of_storage = _start + n;
    97.             }
    98.         }
    99.         
    100.         //使用cosnt &为了能够传临时对象
    101.         void push_back(const T& x)
    102.         {
    103.             if(_finish == _end_of_storage)
    104.             {
    105.                 reserve(capacity() == 0 ? 4 : capacity() * 2);
    106.             }
    107.  
    108.             *_finish = x;
    109.             _finish++;
    110.         }
    111.  
    112.         void pop_back()
    113.         {
    114.             assert(size() > 0);
    115.  
    116.             _finish--;
    117.         }
    118.  
    119.         //构造函数，用其它容器的迭代器来构造
    120.         template<class InputIterator>
    121.         vector(InputIterator first, InputIterator last)
    122.             :_start(nullptr)
    123.             ,_finish(nullptr)
    124.             ,_end_of_storage(nullptr)
    125.         {
    126.             while(first != last)
    127.             {
    128.                 push_back(*first);
    129.                 first++;
    130.             }
    131.         }
    132.  
    133.         void swap(vector& v)
    134.         {
    135.             std::swap(_start, v._start);
    136.             std::swap(_finish, v._finish);
    137.             std::swap(_end_of_storage, v._end_of_storage);
    138.         }
    139.         
    140.         //拷贝构造，现代写法
    141.         vector(const vector& v)
    142.             :_start(nullptr)
    143.             ,_finish(nullptr)
    144.             ,_end_of_storage(nullptr)
    145.         {
    146.             vector tmp(v.begin(), v.end());
    147.             swap(tmp);
    148.         }
    149.  
    150.  
    151.         //赋值=重载
    152.         vector& operator=(vector v)
    153.         {
    154.             swap(v);
    155.             return *this;
    156.         }
    157.  
    158.  
    159.         vector(int n, const T& value)
    160.             :_start(nullptr)
    161.             ,_finish(nullptr)
    162.             ,_end_of_storage(nullptr)
    163.         {
    164.             for(int i = 0; i < n; i++)
    165.             {
    166.                 push_back(value);
    167.             }
    168.         }
    169.              
    170.         vector(long n, const T& value)
    171.             :_start(nullptr)
    172.             ,_finish(nullptr)
    173.             ,_end_of_storage(nullptr)
    174.         { 
    175.              for(long i = 0; i < n; i++)
    176.              {
    177.                  push_back(value);
    178.              }
    179.         }
    180.  
    181.         vector(size_t n, const T& value = T())
    182.             :_start(nullptr)
    183.             ,_finish(nullptr)
    184.             ,_end_of_storage(nullptr)
    185.         { 
    186.              for(size_t i = 0; i < n; i++)
    187.              {
    188.                  push_back(value);
    189.              }
    190.         }
    191.  
    192.         //三种情况，比capacity()大，在size()和capacity之间,比size()小
    193.         void resize(size_t n, const T& val = T())
    194.         {
    195.             if(n > capacity())
    196.             {
    197.                 reserve(n);
    198.             }
    199.             
    200.             //初始化
    201.             if(n > size())
    202.             {
    203.                 while(_finish < _start + n)
    204.                 {
    205.                     *_finish = val;
    206.                     _finish++;
    207.                 }
    208.             }
    209.             else
    210.             {
    211.                 _finish = _start + n;
    212.             }
    213.         }
    214.  
    215.         //返回值是iterator 返回的是最近一次插入的元素位置
    216.         iterator insert(iterator pos, const T& x)
    217.         {
    218.             assert(pos >= _start);
    219.             assert(pos <= _finish);
    220.  
    221.             if(_finish == _end_of_storage)
    222.             {
    223.                 //修正pos的位置
    224.                 size_t len = pos - _start;
    225.                 reserve(capacity() == 0 ? 4 : capacity() * 2);
    226.                 pos = _start + len;
    227.             }
    228.  
    229.             iterator end = _finish - 1;//是地址，怎末写都无所谓
    230.             while(end >= pos)
    231.             {
    232.                 *(end + 1) = *end;
    233.                 end--;
    234.             }
    235.  
    236.             *pos = x;
    237.             _finish++;
    238.  
    239.             return pos;
    240.         }
    241.  
    242.         //返回值同理,删除元素的下一个位置
    243.         iterator erase(iterator pos)
    244.         {
    245.             assert(pos >= _start);
    246.             assert(pos < _finish);
    247.  
    248.             iterator begin = pos + 1;
    249.             while(begin < _finish)
    250.             {
    251.                 *begin = *(begin - 1);
    252.                 begin++;
    253.             }
    254.  
    255.             return pos;
    256.         }
    257.  
    258.         T& front()
    259.         {
    260.             assert(size() > 0);
    261.             return *_start;
    262.         }
    263.  
    264.         T& back()
    265.         {
    266.             assert(size() > 0);
    267.             return *(_finish - 1);
    268.         }
    269.  
    270.  
    271.     private:
    272.         iterator _start;
    273.         iterator _finish;
    274.         iterator _end_of_storage;
    275.     };
    276.  
    277.     void test_vector1()
    278.     {
    279.         vector<int> v;
    280.         v.push_back(1);
    281.         v.push_back(2);
    282.         v.push_back(3);
    283.         v.push_back(4);
    284.         v.push_back(5);
    285.         for(auto e : v)
    286.         {
    287.             cout << e << " ";
    288.         }
    289.         cout << endl;
    290.     }
    291.  
    292.     void test_vector2()
    293.     {
    294.         vector<int> v;
    295.         v.push_back(1);
    296.         v.push_back(2);
    297.         v.push_back(3);
    298.         v.push_back(4);
    299.         v.push_back(5);
    300.         v.push_back(6);
    301.         
    302.         for(auto e : v)
    303.         {
    304.             cout << e << " ";
    305.         }
    306.         cout << endl;
    307.  
    308.         v.pop_back();
    309.  
    310.         for(auto e : v)
    311.         {
    312.             cout << e << " ";
    313.         }
    314.         cout << endl;
    315.  
    316.         v.pop_back();
    317.         for(auto e : v)
    318.         {
    319.             cout << e << " ";
    320.         }
    321.         cout << endl;
    322.  
    323.         v.pop_back();
    324.         for(auto e : v)
    325.         {
    326.             cout << e << " ";
    327.         }
    328.         cout << endl;
    329.  
    330.         v.pop_back();
    331.         for(auto e : v)
    332.         {
    333.             cout << e << " ";
    334.         }
    335.         cout << endl;
    336.  
    337.         v.pop_back();
    338.         for(auto e : v)
    339.         {
    340.             cout << e << " ";
    341.         }
    342.         cout << endl;
    343.  
    344.         v.pop_back();
    345.         for(auto e : v)
    346.         {
    347.             cout << e << " ";
    348.         }
    349.         cout << endl;
    350.  
    351.         v.pop_back();
    352.         for(auto e : v)
    353.         {
    354.             cout << e << " ";
    355.         }
    356.         cout << endl;
    357.  
    358.  
    359.      }
    360.  
    361.     void test_vector3()
    362.     {
    363.         vector<int> v;
    364.         v.push_back(1);
    365.         v.push_back(2);
    366.         v.push_back(3);
    367.         v.push_back(4);
    368.         v.push_back(5);
    369.         v.push_back(6);
    370.  
    371.         for(size_t i = 0; i < v.size(); i++)
    372.         {
    373.             cout << v[i] << " ";
    374.         }
    375.         cout << endl;
    376.     }
    377.  
    378.     void test_vector4()
    379.     {
    380.         string str("Hello World");
    381.         vector<char> v(str.begin(), str.end());
    382.  
    383.         for(auto e : v)
    384.         {
    385.             cout << e;
    386.         }
    387.         cout << endl;
    388.     }
    389.  
    390. class Solution {
    391. public:
    392.     vectorint>> generate(int numRows) {
    393.         vectorint>> vv;
    394.         vv.resize(numRows);//只能使用resize要初始化
    395.         for (size_t i = 0; i < vv.size(); i++)
    396.         {
    397.             vv[i].resize(i + 1, 0);
    398.             vv[i].front() = vv[i].back() = 1;
    399.         }
    400.  
    401.         for (size_t i = 0; i < vv.size(); i++)
    402.         {
    403.             for (size_t j = 0; j < vv[i].size(); j++)
    404.             {
    405.                 if (vv[i][j] == 0)
    406.                 {
    407.                     vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
    408.                 }
    409.             }
    410.         }
    411.         return vv;
    412.     }
    413. };
    414.  
    415.     void test_vector5()
    416.     {
    417.         vectorint>> ans = Solution().generate(8);
    418.         for(auto e : ans)
    419.         {
    420.             for(auto m : e)
    421.             {
    422.                 cout << m << " ";
    423.             }
    424.         }
    425.  
    426.         cout << endl;
    427.     }
    428.     
    429.     void test_vector6()
    430.     {
    431.         vector<int> v1;
    432.         v1.push_back(1);
    433.         v1.push_back(2);
    434.         v1.push_back(3);
    435.         v1.push_back(4);
    436.         v1.push_back(5);
    437.         v1.push_back(6);
    438.         v1.push_back(7);
    439.  
    440.         for(auto e : v1)
    441.         {
    442.             cout << e << " ";
    443.         }
    444.         cout << endl;
    445.  
    446.         vector<int> v2(v1);
    447.  
    448.         for(auto e : v2)
    449.         {
    450.             cout << e << " ";
    451.         }
    452.         cout << endl;
    453.     }
    454.  
    455.     void test_vector7()
    456.     {
    457.         vector ans(10, "Hello World");
    458.  
    459.         for(auto e : ans)
    460.         {
    461.             cout << e << endl;
    462.         }
    463.         cout << endl;
    464.     }
    465.  
    466.     void test_vector8()
    467.     {
    468.         vectorint>> dp(10, vector<int>(10, 1));
    469.         for(auto e : dp)
    470.         {
    471.             for(auto m : e)
    472.             {
    473.                 cout << m << " ";
    474.             }
    475.             cout << endl;
    476.         }
    477.         cout << endl;
    478.     }
    479.  
    480. }

    总结


    以上就是今天要讲的内容，本文仅仅简单实现了vector

  • 相关阅读:
    【实战-05】 flinksql look up join
    springboot 简单配置mongodb多数据源
    【java面试】Redis篇
    《腾讯精选练习50题》专题
    数据分析案例-基于sklearn随机森林算法探究影响预期寿命的因素
    【华为OD机试真题 python】一种字符串压缩表示的解压 【2022 Q4 | 100分】
    知识图谱推理研究综述9.3
    C++DAY39
    Vue computed计算和watch监听
    如何计算质心
  • 原文地址：https://blog.csdn.net/m0_62179366/article/details/126917680