线性表--线性存储

基类：

#ifndef LINEARLIST_H
#define LINEARLIST_H

/*
 * FileName: LinearList.h
 *Creater:QianChenglong
 *Date:2011/10/18
 *Comments: 线性表的抽象基类
 */

template<typename T>
class LinearList{
public:
    virtual int getLength() const=0;//求表长；
    virtual  int find(const T& value)const=0;//根据值搜索位序；
    virtual void setData(int i,const T value) =0;//赋值；
    virtual T getData(int i) const=0;//取值；
    virtual bool insert(int i,T& x) =0;//插入；
    virtual bool remove(int i,T& value) =0;//删除；
    virtual bool isEmpty() const=0;//判断表空；
    virtual void output() const=0;//输出；
};

#endif

类定义：

#ifndef SEQLIST_H
#define SEQLIST_H

#include<iostream>
#include<cstdlib>
#include"LinearList.h"

template<typename T>
class SeqList: public LinearList<T>{
private:
    T* data;//存放数组；
    int maxSize;//最大存储个数；
    int length;//当前已存表项数；
    static int initializedCapacity;//初始空间
    void overflowProcess();//空间溢出时的处理
public:
    SeqList();//默认构造函数；
    SeqList(SeqList<T>& L);//复制构造函数；
    ~SeqList();//析构函数
    
    int capacity() const;//返回容量；
    int getLength() const;//返回表长
    int find(const T& x) const;//搜索x在表中的位置,成功返回位序，失败返回0；

    T getData(int i) const;//取序号为i的值(从1开始)；
    void setData(int i,const T value);//把逻辑位序为i的值置成value

    void PushBack(T& x);
    bool insert(int i,T& x);//插入:将x插入位序为i的位置,成功返回1，失败返回0；

    bool remove(int i,T& value);//删除位序为i的元素，value返回删除值,成功返回1，失败返回0；

    bool isEmpty() const;//判空
    bool isFull() const;//判满

    void sort();//排序，从小至大；

    
    SeqList<T>& operator=(SeqList<T>& L);//赋值；

    void output() const;
    template<T> friend std::ostream& operator<<(std::ostream& out,SeqList<T>& x);//函数模板作为类模板的友元函数的声明方式；
};

#include"SeqList.cpp"

#endif

类实现：

#ifndef SEQLIST_CPP
#define  SEQLIST_CPP

#include<iostream>
#include<cstdlib>
#include"SeqList.h"
///////////////////////////////////////////////////////////////////
template<typename T>
int SeqList<T>::initializedCapacity=100;//模板的静态数据成员的定义

/////////////////////////////////////////////////////////////////
template<typename T>
std::ostream& operator<<(std::ostream& out,SeqList<T>& x){//重载<<
    int length=x.getLength();
    for(int i=0;i!=length;++i)
        out<<x.getData(i+1)<<' ';
    out<<std::endl;
    return out;
}

/////////////////////////////////////////////////////////////////
template< typename T>
SeqList<T>::SeqList()
    :maxSize(initializedCapacity)
{//默认构造函数
    length=0;
    if(!(data=new T[maxSize])){//分配内存
        std::cerr<<"内存分配失败\n";
        exit(0);
    }
}

///////////////////////////////////////////////////////////////////////
template< typename T>
SeqList<T>::SeqList(SeqList<T>& L)
{
    maxSize=L.Size();
    length=L.Length();
    if(!(data=new T[maxSize]))
    {
        std::cerr<<"存储分配错误！\n";
        exit(1);
    }
    for(int i=0;i!=length;++i)
        data[i]=L.getData(i);
}

////////////////////////////////////////////////////////////////
template< typename T>
int SeqList<T>::find(const T& foundValue) const{//查找值为x的
    int i;
    for(i=0;i!=length;++i){
        if(data[i]==foundValue)
            break;//若找到则退出
    }
    if(data[i]==foundValue)
        return i+1;
    else
        return 0;
}

/////////////////////////////////////////////////////////////////////////////////////
template<typename T>
bool SeqList<T>::insert(int i,T& value){//将value插入到第i个位置，物理位序为i-1
    if(isFull())//若空间已满
        overflowProcess();
    if(i<=0||i>=length+2)//若插入位置不位于[1,length+1],则插入位置不存在；
        return 0;
    for(int n=length-1;n!=i-2;--n)//从后向前，依次后移
        data[n+1]=data[n];
    data[i-1]=value;
    ++length;
    return 1;
}

template<typename T>
bool SeqList<T>::remove(int i,T& value){//删除第i个值,用value返回被删除值，物理位序为i-1
    if(isEmpty())//若表空，则失败
        return 0;
    if(i<=0||i>=length)//若删除位置不存在，则失败
        return 0;
    else{
        value=data[i-1];
        for(int n=i-1;n!=length;++n){//从前向后，依次前移
            data[n]=data[n+1];
        }
        --length;
    }
}

////////////////////////////////////////////////////////////////////////
template<typename T>
SeqList<T>& SeqList<T>::operator=(SeqList<T>& L){//赋值函数
    maxSize=L.capacity();
    length=L.length();
    data=new T[maxSize];
    for(int i=0;i!=length;++i)
        data[i]=L.getData(i);
    return *this;
}

template<typename T>
void SeqList<T>::output() const{//输出表值
    for(int i=0;i!=length;++i)
    std::cout<<data[i]<<' ';
    std::cout<<std::endl;
}

///////////////////////////////////////////////////////////////
template<typename T>
void SeqList<T>::sort(){//按值从小到大排序
    int minSub;
    T term;
    for(int i=0;i!=length;++i)    {
        minSub=i;
        for(int j=i+1;j!=length;++j){
            if(data[minSub]>data[j])
                minSub=j;
        }
        if(minSub!=i){
            term=data[i];data[i]=data[minSub];data[minSub]=term;
        }
    }
}

/////////////////////////////////////////////////////////////////////////
template<typename T>
void SeqList<T>::PushBack(T& value){//将value插到表尾
    if(isFull())
        overflowProcess();
    data[length]=value;
    ++length;
}

////////////////////////////////////////////////////////////////////
template<typename T>
SeqList<T>::~SeqList(){//析构函数
    delete [] data;//删除data所指向的内存
    data=0;//指针置零
}

///////////////////////////////////////////////////////////////////////
template<typename T>
int SeqList<T>::capacity() const{//返回
    return maxSize;
}

//////////////////////////////////////////////////////////////////////
template<typename T>
T SeqList<T>::getData(int i) const{//取逻辑位序为i的元素的值
    return i>0&&i<=length?data[i-1]:NULL;//若失败返回NULL,有点问题
}

///////////////////////////////////////////////////////////////////////
template<typename T>
void SeqList<T>::setData(int i,const T value){
    if(i>0&&i<=length-1)
        data[i-1]=value;
    else
        std::cout<<"插入位置不存在。\n";
}

/////////////////////////////////////////////////////////////
template<typename T>
bool SeqList<T>::isEmpty() const{//判空
    return length==0;
}

///////////////////////////////////////////////////////////
template<typename T>
bool SeqList<T>::isFull() const{//判满
    return length==maxSize;
}

/////////////////////////////////////////////////////////////
template<typename T>
void SeqList<T>::overflowProcess(){//溢出处理
    maxSize+=20;//空间再增加20
    T* newData=new T[maxSize];
    for(int i=0;i!=length;++i)//数据复制到新分配的内存
        newData[i]=data[i];
    delete [] data;//释放原空间
    data=newData;
}

//////////////////////////////////////////////////////////
template<typename T>
int SeqList<T>::getLength() const{//返回表长
    return length;
}
#endif

功能测试：

#include<iostream>
#include"SeqList.h"

int main()
{
    SeqList<int> La;
    for(int i=1;i!=10;++i)
        La.insert(i,i);
    La.output();
    std::cout<<La.capacity()<<std::endl
        <<La.getLength()<<std::endl
        <<La.find(3)<<std::endl;
    int x;
    La.remove(3,x);
    std::cout<<x<<std::endl;
    La.output();

    int elem;
    while(std::cin>>elem)
        La.PushBack(elem);
    La.output();
    La.sort();
    La.output();
    std::cout<<La;
    std::cin.clear();
    return 0;
}