线性表之五，C++代码（学堂在线，华南理工大学）

数据结构List，叫列表，也叫线性表。栅栏fence的概念，也就是操作定位。

List的抽象模板类代码：

/* class List */
template <class Elem>
class List
{
public:
    //set the position of the fence
    virtual bool setPos(int pos) = 0;
    //insert an element
    virtual bool insert(const Elem& e) = 0;
    //remove an element 
    virtual bool remove(Elem& e) = 0;
};

Alistl类的模板类代码：

/* class AList */
const int DefaultListSize = 100;
template <class Elem>
class AList:public List<Elem>
{
private:
    Elem* listArray;//Array holding list
    int maxSize; //Maximum size of list
    int listSize; //Actual elem count
    int fence; //Position of fence;
public:
    AList(int size=DefaultListSize){
        listArray = new Elem[size];
        maxSize = fence = 0;
    }
    ~AList(){delete[] listArray;}
    //重写虚函数要声明
    virtual bool setPos(int pos);
    virtual bool insert(const Elem& e);
    virtual bool remove(Elem& e);
    bool getValue(Elem& it)const;
};
//set the Position of the fence
template <class Elem>
bool AList<Elem>::setPos(int pos){
    if((pos>=0)&&(pos<=listSize))//判断是否在合理的区间
        fence = pos;
    return (pos>=0)&&(pos<=listSize);
}
//get the first element after the fence
template <class Elem>
bool AList<Elem>::getValue(Elem& it)const{
    if(fence == listSize) return false;//判断是否重叠
    else{
        it = listArray[fence];
        return true;
    }
}
template <class Elem>
bool AList<Elem>::insert(const Elem& item){
    if(listSize == maxSize) return false;//判断是否有空间
    //Shift Elems up to make room
    for(int i=listSize; i>fence; i--)
        listArray[i] = listArray[i-1];
    listArray[fence] = item;
    listSize++;//Increment list size
    return true;
}
template <class Elem>
bool AList<Elem>::remove(Elem& it){
    if(fence == listSize) return false;
    it = listArray[fence];//Copy Elem
    for(int i=fence; i<listSize; ++i)
        listArray[i] = listArray[i+1];
    listSize--; //Decrement size
    return true;
}

链表结点模板类代码：

//list node
template <class Elem>
class Node{
public:
    Elem element;//Value for this node
    Node* next; //Pointer to next node
    Node(){next = NULL;}
    Node(const Elem& elemval,Node* nextval = NULL)
    {element = elemval; next = nextval;}
};

LList模板类代码：

template <class Elem>
class LList:public List<Elem>
{
private:
    Node<Elem>* head;//Point to list header
    Node<Elem>* tail;//Pointer to last Elem
    Node<Elem>* fence;//Last element on left
    int length; //Length of list
public:
    LList()
    {
        fence = head = tail = new Node<Elem>;
        length = 0;
    }
    virtual bool getValue(Elem& it)const;
    virtual bool insert(const Elem& item);
    virtual bool remove(Elem& it);
    virtual bool setPos(int pos);
};
template <class Elem>
bool LList<Elem>::getValue(Elem& it)const{
    if(fence == tail) return false;
    it = fence->next->element;
    return true;
}
template <class Elem>
bool LList<Elem>::insert(const Elem& item){
    fence->next = new Node<Elem>(item,fence->next);
    if(tail == fence) tail = fence->next;
    length++;
    return true;
}
template <class Elem>
bool LList<Elem>::remove(Elem& it){
    if(fence->next == NULL) return false;
    it = fence->next->element;//Remember value_comp
    Node<Elem>* ltemp = fence -> next;
    fence->next = ltemp->next;//Remove
    if(tail == ltemp) 
        tail = fence; //Reset tail
    delete ltemp;//Reclaim space
    length--;
    return true;
}
template <class Elem>
bool LList<Elem>::setPos(int pos){
    if((pos < 0) || (pos > length))
        return false;
    fence = head;
    for(int i=0; i<pos; ++i)
        fence = fence->next;
    return true;
}

Stack抽象模板类代码：

//Stack abstract class
template <class Elem>
class Stack
{
public:
    //Push an element onto the top of the stack
    virtual bool push(const Elem& e) = 0;
    //Remove the element at the top of the stack
    virtual bool pop(Elem& e) = 0;
    //Get a copy of the top element in the stack
    virtual bool topValue(Elem& e) const = 0;
    //Return the number of element in the stack
    virtual int getLength() const = 0;
    //Reinitialize the stack
    virtual void clear() = 0;
};

基于数组的栈模板类代码：

//Array-based stack implementation
template <class Elem>
class AStack:public Stack<Elem>
{
private:
    Elem* listArray;//Array holding stack elements
    int size; //Maximum size of stack
    int top; //The position to insert the new element
public:
    AStack(int sz)
    {
        size = sz;
        top = 0;
        listArray = new Elem[sz];
    }
    ~AStack(){delete[] listArray;}
    virtual bool push(const Elem& item);
    virtual bool pop(Elem& it);
};
template <class Elem>
bool AStack<Elem>::push(const Elem& item){
    if(top == size) return false; //Stack is full
    else{
        listArray[top++] = item; 
        return true;
    }
}
//pop top element 
template <class Elem>
bool AStack<Elem>::pop(Elem& it){
    if(top == 0) return false;
    else{
        it = listArray[--top];
        return true;
    }
}

队列抽象模板类代码：

template <class Elem>
class Queue
{
public:
    virtual bool enqueue(const Elem& e) = 0;
    virtual bool dequeue(Elem& e) = 0;
    virtual bool frontValue(Elem& e) = 0;
    virtual int getLength() const = 0;
    virtual void clear() = 0;
}

基于链表的队列模板类代码：

template <class Elem>
class LQueue:public Queue<Elem>
{
private:
    Node<Elem>* head;//Point to list header
    Node<Elem>* tail;//Pointer to last Elem
    int length; //Length of list
public:
    LQueue()
    {   //带头结点, 空队列head == tail
        head = tail = new Node<Elem>;
        length = 0;
    }
    virtual bool enqueue(const Elem& e);
    virtual bool dequeue(Elem& e);
    virtual bool frontValue(Elem& e);
    virtual int getLength() const;/* 不能与成员变量重名*/
    virtual void clear(); 
};
template <class Elem>
bool LQueue<Elem>::frontValue(Elem& it){
    if(head == tail) return false;//队列空
    it = head->next->element;
    return true;
}
template <class Elem>
bool LQueue<Elem>::enqueue(const Elem& item){ //入队
    Node<Elem>* ltemp = new Node<Elem>(item,NULL);
    tail->next = ltemp; //入队,插入尾部
    tail = ltemp; //更新尾部
    length++;
    return true;   
}
template <class Elem>
bool LQueue<Elem>::dequeue(Elem& it){
    if(head == tail) return false;//队列空
    it = head->next->element;//Remember value_comp
    Node<Elem>* ltemp = head -> next;
    head->next = ltemp->next;//Remove
    if(tail == ltemp)//最后一个出队 
        tail = head; //队列空
    delete ltemp;//Reclaim space
    length--;
    return true;
}
template <class Elem>
int LQueue<Elem>::getLength() const{
    return length;
}
template <class Elem>
void LQueue<Elem>::clear(){
    while(head){
        tail = head->next;
        delete head;
        head = tail;
    }
}