20120918-向量实现《数据结构与算法分析》

简介:
<br>#include <iostream>
#include <list>
#include <string>
#include <vector>
#include <bitset>
using  namespace  std;
 
template  < typename  Container, typename  Object>
void  change(Container & c, const  Object & newValue) //改变新值
{
     typename  Container::ierator itr = c.begin();
     while ( itr != c.end())
     {
         *itr++ = newValue;
     }
}
 
template  < typename  Container, typename  Object>
void  print( const  list< int > & lst,ostream & out = cout) //打印值,并且归0
{
     typename  Container::iterator itr = lst.begin();
     while ( itr != lst.end())
     {
         cout<<*itr<<endl;
         *itr=0;
         itr++;
     }
}
 
template  < typename  Container>
void  printCollection( const  Container & c) //打印任何容器
{
     if  (c.empty())
         cout<< "(empty)" ;
     else
     {
         typename  Container::const_iterator itr = c.begin();
         cout << "["  << *itr++;
 
         while (itr != c.end())
         {
             cout << "," <<*itr++;
         }
 
         cout<< "]" <<endl;
     }
}
template  < typename  Object> //Vector类向量实现
class  Vector
{
     public :
         explicit  Vector( int  initSize = 0):theSize(initSize),theCapacity(initSize+SPARE_CAPACITY)
         {
             objects = new  Object[theCapacity];
         }
         Vector( const  Vector & rhs) : objects(NULL)
         {
             operator=(rhs);
         }
         ~Vector()
         {
             delet [] objects;
         }
         
         const  Vector & operator = ( const  Vector & rhs)
         {
             if ( this  != &rhs)
             {
                 delete  [] objects;
                 theSize = rhs.size();
                 theCapacity = rhs.theCapacity();
 
                 objects = new  Object[ capacity() ];
                 for ( int  k=0; k<size() ; k++)
                     objects[k] = rhs.objects[k];
             }
         return  * this ;
         }
 
         void  resize( int  newSize)
         {
             if (newSize > theCapacity)
                 reserve( newSize*2+1);
             theSize = newSize;
         }
 
         void  reserve( int  newCapacity)
         {
             if (newCapacity < theSize)
                 return ;
 
             Object *oldArray = objects;
 
             objects = new  Object[ newCapacity];
             for ( int  k=0; k<theSize ; k++)
                 objects[k] = oldArray[k];
 
             theCapacity = newCapacity;
 
             delete  [] oldArray;
         }
 
         Object & operator[]( int  index)
         {
             return  objects[index];
         }
         const  Object & operator[]( int  index) const
         {
             return  objects[index];
         }
 
         bool  empty() const
         {
             return  size() == 0;
         }
         int  size() const
         {
             return  theSize;
         }
         int  capacity() const
         {
             return  theCapacity;
         }
 
         void  push_back( const  Object & x)
         {
             if (theSize == theCapacity)
                 reserve( 2 * theCapacity + 1 );
             objects[theSize++] =x;
         }
 
         void  pop_back()
         {
             theSize--;
         }
 
         const  Object & back() const
         {
             return  objects[theSize - 1];
         }
 
         typedef  Object * iterator;
         typedef  const  Object * const_iterator;
 
         iterator begin()
         {
             return  &objects[0];
         }
         const_iterator begin() const
         {
             return  &objects[0];
         }
         iterator end()
         {
             return  &objects[size()];
         }
         const_iterator end() const
         {
             return  &objects[size()];
         }
 
         enum  {SPARE_CAPACITY=16};
 
         private :
             int  theSize;
             int  theCaacity;
             Object *objects;
}
int  main()
{
     list<string> a;
     list< int > b;
     list< int > c;
     c.push_back(123);
     a.push_back( "123" );
     a.push_back( "ooo" );
     a.push_back( "456" );
     a.push_back( "ooo" );
     a.push_back( "789" );
     printCollection(a);
     printCollection(b);
     printCollection(c);
     return  0;
}

  前两部分是list的应用

  后一部分是vector的实现方法:可惜我不会直接测试...不知道怎么直接用.....

  今天不知道怎么的,莫名的很生气.....fuck

本文转自博客园xingoo的博客,原文链接:20120918-向量实现《数据结构与算法分析》,如需转载请自行联系原博主。
相关文章
|
5月前
|
算法 测试技术 C++
【动态规划】【矩阵快速幂】【滚动向量】C++算法552. 学生出勤记录 II
【动态规划】【矩阵快速幂】【滚动向量】C++算法552. 学生出勤记录 II
|
5月前
|
算法 测试技术 C#
【动态规划】【矩阵快速幂】【滚动向量】C++算法552. 学生出勤记录 II
【动态规划】【矩阵快速幂】【滚动向量】C++算法552. 学生出勤记录 II
|
3月前
|
人工智能 算法 大数据
算法金 | 推导式、生成器、向量化、map、filter、reduce、itertools,再见 for 循环
这篇内容介绍了编程中避免使用 for 循环的一些方法,特别是针对 Python 语言。它强调了 for 循环在处理大数据或复杂逻辑时可能导致的性能、可读性和复杂度问题。
41 6
算法金 | 推导式、生成器、向量化、map、filter、reduce、itertools,再见 for 循环
|
3月前
|
机器学习/深度学习 数据采集 算法
Python实现RVM相关向量机回归模型(RVR算法)项目实战
Python实现RVM相关向量机回归模型(RVR算法)项目实战
|
3月前
|
算法 搜索推荐
推荐系统,推荐算法01,是首页频道推荐,一个是文章相似结果推荐,用户物品画像构建就是用户喜欢看什么样的文章,打标签,文章画像就是有那些重要的词,用权重和向量表示,推荐架构和业务流
推荐系统,推荐算法01,是首页频道推荐,一个是文章相似结果推荐,用户物品画像构建就是用户喜欢看什么样的文章,打标签,文章画像就是有那些重要的词,用权重和向量表示,推荐架构和业务流
|
5月前
|
机器学习/深度学习 自然语言处理 算法
【Tensorflow深度学习】优化算法、损失计算、模型评估、向量嵌入、神经网络等模块的讲解(超详细必看)
【Tensorflow深度学习】优化算法、损失计算、模型评估、向量嵌入、神经网络等模块的讲解(超详细必看)
91 1
|
5月前
|
算法 测试技术 C#
C++二分向量算法:最多可以参加的会议数目 II
C++二分向量算法:最多可以参加的会议数目 II
|
10月前
|
算法 测试技术 C#
C++单调向量算法应用:所有子数组中不平衡数字之和
C++单调向量算法应用:所有子数组中不平衡数字之和
|
5月前
|
算法 测试技术 C#
C++二分向量算法:最多可以参加的会议数目 II
C++二分向量算法:最多可以参加的会议数目 II
|
5月前
|
人工智能 算法 C语言
【408数据结构与算法】—线性表的定义和分析(二)
【408数据结构与算法】—线性表的定义和分析(二)
下一篇
无影云桌面