基本数据结构：顺序表

最新推荐文章于 2024-02-05 20:47:54 发布
转载最新推荐文章于 2024-02-05 20:47:54 发布 · 764 阅读
文章标签：
#顺序表
算法专栏收录该内容
23 篇文章
订阅专栏
顺序表，数组就是典型的顺序表，顺序表便于查询元素，单移动、删除时间开销比较大，好了废话少说，直接上代码，对照源码看吧
[cpp]view plaincopy 
   
 #ifndef SEQLIST_H  
 #define SEQLIST_H  
   
 #include <iostream>  
 #include <stdlib.h>  
 using std::cin;  
 using std::cout;  
 using std::cerr;  
 using std::endl;  
 using std::ostream;  
 using std::istream;  
   
 const int defaultSize = 100;  
 const int initLen = 20;  
   
 template <class T>  
 class SeqList  
 {  
   
 public:  
     SeqList(const int maxSize = defaultSize);//带默认参数的构造函数  
     SeqList(const SeqList<T> &seqList);  
     ~SeqList()  
     {  
         delete []data;//销毁数组  
     }  
   
     int length() const//返回顺序表内已有数据的长度  
     {  
         return last + 1;  
     }  
   
     int maxSize() const//返回顺序表的最大容量  
     {  
         return this->size;  
     }  
   
     bool isEmpty()//返回顺序表是否为空  
     {  
         return (last == -1);  
     }  
   
     bool isFull()//返回顺序表是否已满  
     {  
         return (last == size-1);  
     }  
   
     int search(T &x) const;//查找x是否在顺序表中存在，存在返回其位置，不存在返回0  
   
     T& getData(int i) const//返回第i个编号位置的元素  
     {  
         if(i>0 && i<=last+1)  
         {  
             return data[i-1];  
         }  
           
     }  
   
     void setData(int i, T &x)//对第i个编号位置的元素赋值  
     {  
         if (i>0 && i<=last+1){  
             data[i-1] = x;  
         }  
           
     }  
   
     bool insert(int i, T &x);//在第i个编号位置插入元素  
     bool remove(int i, T &x);//把第i个编号位置的元素移走  
     void reSize(int newSize);//调整顺序表的大小，关键是要把原来的数据复制过来  
     SeqList<T>& operator= (const SeqList<T> &rhs);  
     void init();//这个方法无实际意义，纯粹是为了测试用单独引入的1个方法  
   
     friend ostream& operator << (ostream& os,const SeqList<T>& seqList)  
     {  
         for(int i = 0; i <= seqList.last; i++)  
         {  
             os << "#" << i+1 << ":" << seqList.data[i] << endl;  
         }  
   
         return os;  
     }  
   
 private:  
     T *data;//存放的数组  
     int size;//最大可存放的项  
     int last;//当前尾巴元素的小标  
 };  
   
   
 template <class T>  
 SeqList<T>::SeqList(int maxSize)  
 {  
     if(maxSize > 0)  
     {  
         this->size = maxSize;//创建数组  
         this->last = -1;  
         data = new T[maxSize];  
         if(data == NULL)  
         {  
             cerr << "malloc memory failed!" << endl;  
             return;  
         }  
     }  
 }  
   
 template <class T>  
 SeqList<T>::SeqList(const SeqList<T>& seqList)  
 {  
     size = seqList.maxSize();  
     last = seqList.length() - 1;  
     data = new T[size];  
   
     if (data == NULL){  
         cerr << "Memory allocating error!" << endl;  
         return;  
     }  
   
     for (int i = 1; i <= last+1; i++){  
         data[i-1] = seqList.getData(i);  
     }  
 }  
   
 template <class T>  
 int SeqList<T>::search(T &x) const  
 {  
     for(int i = 0; i <= last; i++)  
     {  
         if(this->data[i] == x)//找到后返回下标  
         {  
             return i+1;  
         }  
     }  
   
     return 0;  
 }  
   
 template <class T>  
 bool SeqList<T>::insert(int i, T &x)  
 {  
     if(isFull())  
     {  
         return false;  
     }  
   
     if( i < 0 || i > last + 1)//注意我们讲的是顺序表  
     {  
         return false;  
     }  
   
     for(int j = last; j >= i-1; j--)  
     {  
         this->data[j+1] = this->data[j];  
     }  
     this->data[i-1] = x;//插入  
     last++;//现有尾巴下标后移  
   
     return true;  
 }  
   
 template <class T>  
 bool SeqList<T>::remove(int i, T &x)  
 {  
     if(isEmpty())  
     {  
         return false;  
     }  
     if(i < 1 || i >= last+1)  
     {  
         return false;  
     }  
       
     x = this->data[i-1];  
     for(int j = i; j <= last; j++)//后面的元素向前移  
     {  
         this->data[j-1] = this->data[j];  
     }  
   
     last--;  
     return true;  
 }  
   
 template <class T>  
 void SeqList<T>::reSize(int newSize)  
 {  
     if(newSize <= 0)  
     {  
         cerr << "invalid newSize!" << endl;  
         return;  
     }  
   
   
     if(newSize != size)  
     {  
         int end = -1;//要拷贝数据的终止下标  
         if(size < newSize)//新的容量比原来要大  
         {  
             end = last;  
         }  
         else //新的容量比原来小  
         {  
             end = newSize - 1;  
         }  
   
         T* newArray = new T[newSize];  
         if( newArray == NULL)  
         {  
             cerr << "malloc memory failed!" << endl;  
             return;  
         }  
   
         T* srcPtr = data;  
         T* descPtr = newArray;  
         for(int i = 0; i <= end; i++)  
         {  
             *descPtr++ = *srcPtr++;  
         }  
   
         delete []data;//删除原来的数组  
         data = newArray;//data指向新的数组  
         last = end;//重新记录尾巴元素的下标  
         size = newSize;//重新新的容量  
     }  
 }  
   
 template <class T>  
 SeqList<T>& SeqList<T>::operator= (const SeqList<T> &rhs)  
 {  
     size = seqList.maxSize();  
     last = seqList.length() - 1;  
     if(data != NULL)  
     {  
         delete []data;  
     }  
     data = new T[size];  
   
     if (data == NULL){  
         cerr << "Memory allocating error!" << endl;  
         return;  
     }  
   
     for (int i = 1; i <= last+1; i++)  
     {  
         data[i-1] = seqList.getData(i);  
     }  
   
     return *this;  
 }  
   
 template <class T>  
 void SeqList<T>::init()  
 {  
     for(int i = 0; i < initLen; i++)  
     {  
         last++;  
         this->data[last] = (T)rand() / 100;  
     }  
 }  
 #endif  