数据结构1-顺序表

#include <iostream>
using namespace std;
const int MAXSIZE = 100;
//顺序表
/*无参构造，有参构造，析构，求顺序表长
按位查找，按值查找，
插入元素，删除元素，判断表为空
遍历顺序表*/


struct People
{
    int age;
    string name;
    string gender;

};

template <class Element>
class SeqList
{
    /*无参构造，有参构造，析构，求顺序表长
    按位查找，按值查找，
    插入元素，删除元素，判断表为空
    遍历顺序表*/
public:
    SeqList();
    SeqList(Element a[], int n);
    ~SeqList();
    int getLength();
    Element getElement(int i);
    int getLocate(Element x);
    bool insert(int i, Element x);
    Element delList(int del);
    bool isEmpty();
    void printList();
    


private:
    Element data[MAXSIZE];
    int length;
};

/*无参构造，有参构造，析构，求顺序表长
    按位查找，按值查找，
    插入元素，删除元素，判断表为空
    遍历顺序表*/

template <class Element>
SeqList<Element>::SeqList() {
    
    length = 0;

}
template <class Element>
SeqList<Element>::SeqList(Element a[], int n) {
    if (n > MAXSIZE) throw "参数非法";
    for (int i = 0; i < n; i++)
    {
        //this->Element ab[i] = Element a[i];
        this->data[i] = a[i];
        length = n;

    }
}
template <class Element>
SeqList<Element>::~SeqList()
{
    length = 0;

}
template <class Element>
int SeqList<Element>::getLength()
{

    return length;

}
template <class Element>
Element SeqList<Element>::getElement( int i)
{
    if (i< 1|| i>length) throw "查找位置非法";
    //Element x;
    //x = data[i - 1];
    return data[i - 1];

}
template <class Element>
int SeqList<Element>::getLocate( Element x)
{
    for (int i = 0; i < length; i++)
    {
        if (data[i].name == x.name&& data[i].age == x.age&& data[i].gender == x.gender)
        {
            return i + 1;
        }
    }
    return -1;
}
template <class Element>
bool SeqList<Element>::insert(int i, Element x)
{
    if (length >= MAXSIZE) throw "上溢";
    if (i<1 || i>length + 1) throw"位置异常";
    for (int j = length - 1; j >= i-1; j--)
    {
        data[j + 1] = data[j];
        length--;
        
    }data[i - 1] = x;
    length++;
    return 1;

}
template <class Element>
Element SeqList<Element>::delList(int del)
{
    if (length == 0) throw "下溢";
    if (del<1 || del>length) throw "删除位置错误";
    Element x = data[del - 1];
    for (int i = del; i < length ; i++)
    {
        data[i - 1] = data[i];
    }
    length--;
    return x;

}
template <class Element>
bool SeqList<Element>::isEmpty()
{
    if (length == 0) return 1;
    else return 0;

}
template <class Element>
void SeqList<Element>::printList()
{
    for (int i = 0; i < length; i++)
    {
        cout << data[i].age << " " << data[i].name << " " << data[i].gender << endl;
    }

}
/*无参构造，有参构造，析构，求顺序表长
    按位查找，按值查找，
    插入元素，删除元素，判断表为空
    遍历顺序表*/
int main()
{
    People p1[] = { {3,"Sam","G"},{4,"Ben","B"} };
    //SeqList<People> l1();
    SeqList<People> l(p1,2);
    cout << "表长为：" << l.getLength() << endl;
    cout << "第2位为：" << l.getElement(2).name<<endl;
    People p2 = { 3,"Sam","G" };
    cout << "Sam在" << l.getLocate(p2) << "位" << endl;
    cout << "现在为：" << endl;
    l.printList();
    People p3 = { 8,"ker","B" };
    l.insert(3, p3);
    cout << "现在为：" << endl;
    l.printList();
    l.delList(2);
    cout << "现在为：" << endl;
    l.printList();
    cout << "空吗:" << l.isEmpty() << endl;
    l.printList();






    return 0;
}