顺序表(线性结构)

类模版不能分别在.h和.cpp文件中定义，所以只能都放在.h文件里

seqList.h

# pragma
//类模版
template<typename T>

class seqList
{
public:
    seqList(int size=30);       //默认构造函数，容量默认为30吧
    ~seqList();            //析构函数
    void push_back(const T& x);
    bool empty();       //判断表是否为空
    bool full();        //判断表是否为满
    int length()const;  //长度
    bool insert(int i,const T&x );  //在顺序表第i个元素前插入x，如果插入成功，返回true
    bool del(int i);    //删除顺序表中第i个位置的元素，成功返回true
    T getElem(int i);   //返回顺序表中第i个位置上的元素
    int locateElem(const T&x);  //返回元素x在顺序表中的位置
    void setElem(int i, const T&x); //将表中第i个位置上的元素设置为x
    void traver();  //遍历
private:
    T *pT;//指向新申请的内存空间的地址
    const int iSize;//顺序表容量
    int iLen;//顺序表中长度
    void sort();
};


//类模版是不支持 分文件定义的，所以实现和声明放一起
template<typename T>
//构造函数
seqList<T>::seqList(int size) :pT(new T[size]), iSize(size), iLen(0)
{}

template<typename T>//每个函数实现前面都必须加上，没办法
seqList<T>::~seqList()
{
    delete[]pT;
}

template<typename T>
bool seqList<T>::empty()        //判断表是否为空
{
    return iLen == 0;
}

template<typename T>
bool seqList<T>::full()     //判断表是否为满
{
    return iLen == iSize;
}

template<typename T>
void seqList<T>::push_back(const T& x)
{
    if (!full())
        pT[iLen++] = x;

    else cout << "顺序表满！！！" << endl;
}

template<typename T>
int seqList<T>::length()const   //顺序表长度
{
    return iLen;
}

template<typename T>
bool seqList<T>::insert(int i, const T&x)   //在顺序表第i个元素前插入x，如果插入成功，返回true
{
    if (full())
    {
        cout << "顺序表已满，无法插入！！！" << endl;
        return false;
    }
    else if (i<1 || i>iLen)//在i位置的元素前插入，i必须在区间[1,iLen]内
    {
        cout << "插入位置不合法！！！" << endl;
        return false;
    }
    iLen++;
    for (int j = iLen - 1;j >= i;j--)
        pT[j] = pT[j - 1];
    pT[i - 1] = x;
    return true;

}

template<typename T>
bool seqList<T>::del(int i) //删除顺序表中第i个位置的元素，成功返回true
{
    if (empty())
    {
        cout << "顺序表为空，无法删除元素!!!" << endl;
        return false;
    }
    if (i<1 || i>iLen)
    {
        cout << "删除位置不合法!!1" << endl;
        return false;
    }
    for (int j = i - 1;j < iLen - 1;j++)
        pT[j] = pT[j + 1];
    iLen--;
    return true;
}

template<typename T>
T seqList<T>::getElem(int i)    //返回顺序表中第i个位置上的元素
{
    if (i<1 || i>iLen)
    {
        cout << "该位置不合法！！！" << endl;
        return 0;
    }
    return pT[i - 1];
}

template<typename T>
int seqList<T>::locateElem(const T&x)   //返回元素x在顺序表中第一次出现的位置，0表示表中无此元素
{
    for (int i = 0;i < iLen;i++)
    {
        if (pT[i] == x)
            return i + 1;
    }
    return 0;
}
template<typename T>
void seqList<T>::setElem(int i, const T&x)  //将表中第i个位置上的元素设置为x
{
    if (i<1 || i>iLen)
    {
        cout << "位置不合法！！！" << endl;
        return;
    }
    pT[i - 1] = x;
}

template<typename T>
void seqList<T>::traver()   //遍历
{
    for (int i = 0;i < iLen;i++)
        cout << pT[i]<<endl;
}

template <typename T>
void seqList<T>::sort() //默认从小到大排序
{
    //冒泡排序
    for (int i = 0;i < iLen - 1;i++)
        for (int j = 0;j < iLen - i-1;j++)
        {
            if (pT[j] > pT[j + 1])
            {
                pT[j] = pT[j] + pT[j + 1];
                pT[j + 1] = pT[j] - pT[j + 1];
                pT[j] = pT[j] - pT[j + 1];
            }
        }
}

main.cpp

# include<iostream>
# include<new>
# include"seqList.h"

using namespace std;

int main()
{
    seqList<int> myList(10);
    myList.traver();
    cout << endl;

    myList.push_back(1);
    myList.push_back(3);
    myList.push_back(5);
    myList.traver();
    cout << endl;

    myList.insert(1, 10);
    myList.traver();
    cout << endl;

    myList.del(1);
    myList.traver();
    cout << endl;

    myList.getElem(3);
    myList.setElem(4, 7);

    system("pause");
    return 0;
}