//main.cpp部分

#include"List.cpp"

int  main()

{

    StaticList<int> SL;

    SL.Insert(,);

    SL.Insert(,);

    SL.Insert(,);

    SL.Insert(,);

    SL.Insert(, );

    SL.Insert(, );

    std::cout << "原始的静态链表如下：" << std::endl;

    SL.show();

    SL.Insert(, );

    std::cout << "在静态链表中第2个位置插入100后结果如下：" << std::endl;

    SL.show();

    int m;

    int delete_index = ;

    SL.Delete(m, delete_index);

    std::cout << "删除的对应" << delete_index << "处的值为：" << m << std::endl;

    std::cout << "删除后的静态链表如下：" << std::endl;

    SL.show();

    int find_val = ;

    int index = SL.Find(find_val);

    std::cout << "查找到" << find_val << "在列表中的位置为:" << index << std::endl;

    return ;

}

//List.h

#pragma once

#include<iostream>

#include<vector>

const int MAXSIZE = ;

template<typename ElemType>

class StaticList;

template<typename ElemType>

class Node

{

    friend class StaticList<ElemType>;

private:

    ElemType data;

    int cur;

};

template<typename ElemType>

class StaticList

{

public:

    StaticList();

    virtual ~StaticList();

    bool Insert(const ElemType& v, int index = );

    bool Delete(ElemType& v, int index = );

    int Find(const ElemType v);

    void show()const;

private:

    int NewSpace();

    void DeleteSpace(int index);

    bool Empty()const;

    bool Full()const;

    std::vector<Node<ElemType>*> StList;

    int Length = ;

};

//List.cpp

#include"List.h"

#include<iostream>

#include<algorithm>

template<typename ElemType>

StaticList<ElemType>::StaticList():Length()

{

    for (int i = ; i < MAXSIZE - ; ++i)

    {

        Node<ElemType>* node = new Node<ElemType>();

        StList.push_back(node);

    }

    for (ElemType i = ; i < MAXSIZE - ; ++i)

        (*StList[i]).cur = i + ;

    Node<ElemType>* node = new Node<ElemType>();

    StList.push_back(node);

    (*StList[MAXSIZE - ]).cur = ;

}

template<typename ElemType>

StaticList<ElemType>::~StaticList()

{

    std::for_each(StList.begin(), StList.end(), [](Node<ElemType>* node) { delete node; });

}

template<typename ElemType>

bool StaticList<ElemType>::Insert(const ElemType& v, int index)

{

    if (Full())

    {

        std::cout << "Can't insert element." << std::endl;

        return false;

    }

    if (index< || index>Length + )

    {

        std::cout << "The invalid index" << std::endl;

        return false;

    }

    int k = NewSpace();

    int j = MAXSIZE - ;

    if (k)

    {

        (*StList[k]).data = v;

        for (int i = ; i <= index - ; ++i)

        {

            j = (*StList[j]).cur;

        }

        (*StList[k]).cur = (*StList[j]).cur;

        (*StList[j]).cur = k;

        ++Length;

        return true;

    }

    return false;

}

template<typename ElemType>

bool StaticList<ElemType>::Delete(ElemType& v, int index)

{

    if (Empty())

    {

        std::cout << "Can't delete element in an empty list!\n";

        return false;

    }

    if (index <  || index>Length)

    {

        std::cout << "The invalid index!\n";

        return false;

    }

    int k = MAXSIZE - ;

    int i = ;

    for (; i <= index - ; ++i)

    {

        k = (*StList[k]).cur;

    }

    i = (*StList[k]).cur;

    (*StList[k]).cur = (*StList[i]).cur;

    v = (*StList[i]).data;

    DeleteSpace(i);

    --Length;

    return true;

}

template<typename ElemType>

int StaticList<ElemType>::Find(const ElemType v)

{

    if (Empty())

    {

        std::cout << "Can't find value in an empty List!\n";

        return -;

    }

    int i = ;

    while ( != i && (*StList[(*StList[i]).cur]).data != v)

        i = (*StList[i]).cur;

    ++i;

    if ( == i)

    {

        std::cout << "Can't find the value  " << v << " in the list" << std::endl;

        return -;

    }

    return i;

}

template<typename ElemType>

void StaticList<ElemType>::show()const

{

    if (Empty())

    {

        std::cout << "The List is empty" << std::endl;

        return;

    }

    int k = (*StList[MAXSIZE - ]).cur;

    std::cout << "The List is:" << std::endl;

    for (int i = ; i <= Length; ++i)

    {

        std::cout << (*StList[k]).data << " ";

        k = (*StList[k]).cur;

    }

    std::cout << std::endl;

}

template<typename ElemType>

bool StaticList<ElemType>::Full()const

{

    if (Length > MAXSIZE - )

        return true;

    return false;

}

template<typename ElemType>

bool StaticList<ElemType>::Empty()const

{

    return ( == Length);

}

template<typename ElemType>

void StaticList<ElemType>::DeleteSpace(int index)

{

    (*StList[index]).cur = (*StList[]).cur;

    (*StList[]).cur = index;

}

template<typename ElemType>

int StaticList<ElemType>::NewSpace()

{

    int i = (*StList[]).cur;

    if ((*StList[]).cur)

    {

        (*StList[]).cur = (*StList[i]).cur;

    }

    return i;

}