静态链表

静态链表存储于数组中，但其顺序不是按数组下标的顺序，而是像链表一样，由当前结点link域的值决定下一个结点的位置，这是链表的特性。由于存储于数组中，故称为静态链表。

静态链表与单链表的区别

　　单链表的结点通过new产生，结点被限制在动态存储区内。因此，指示结点位置的指针类型是长整型。而静态链表的结点被限制在静态数组内。因此，指示结点位置的指针(link成员)是整型。
　　单链表中不用通过delete释放，释放后的结点由编译软件管理，而静态链表中不用的结点要自己管理。

静态链表类

#ifndef __STATICLINKLIST_H__
#define __STATICLINKLIST_H__
#include <iostream>
using namespace std;

const int MAX_SIZE = 10;
template<typename T>
class SLinkList{
public:
    SLinkList();
    void ClearList();
    bool ListEmpty() const;
    int  ListLength() const;
    bool ListInsert(int i, T e);
    bool ListDelete(int i, T &e);
    void ListPrint();
private:
    int  my_new();
    void my_delete(int k);
private:
    struct component{
        T data;
        int link;
    };
    component SL[MAX_SIZE];
};

/*private function*/
template<typename T>
int SLinkList<T>::my_new() {
    /*若备用链表非空，则返回分配的结点下标;否则返回0*/
    int i = SL[MAX_SIZE - 1].link;
    if (i){
        SL[MAX_SIZE - 1].link = SL[i].link;
    }
    return i;
}

/*private function*/
template<typename T>
void SLinkList<T>::my_delete(int k) {
    /*将下标为k的空闲结点回收到备用链表中,成为备用链表的第一个结点*/
    SL[k].link = SL[MAX_SIZE - 1].link;
    SL[MAX_SIZE - 1].link = k;
}

template<typename T>
SLinkList<T>::SLinkList() {
    /*构造一个空闲链表,表头为单元[0],其余单元链表成一个备用链表*/
    int i;
    SL[0].link = 0;
    SL[MAX_SIZE - 1].link = 1;
    for (i = 1;i<MAX_SIZE - 2;i++){
        SL[i].link = i + 1;
    }
    SL[MAX_SIZE - 2].link = 0;
}


template<typename T>
void SLinkList<T>::ClearList() {
    int j, i = SL[MAX_SIZE - 1].link;
    while (i) {
        j = i;
        i = SL[i].link;
    }
    SL[j].link = SL[0].link;
    SL[0].link = 0;
}

template<typename T>
bool SLinkList<T>::ListEmpty() const {
    return SL[0].link == 0;
}

template<typename T>
int SLinkList<T>::ListLength() const {
    int j = 0, i = SL[0].link;
    while (i) {
        i = SL[i].link;
        j++;
    }
    return j;
}

template<typename T>
bool SLinkList<T>::ListInsert(int i, T e) {
    /*在 第i个元素前插入新元素e*/
    int m, k = 0;
    for (m = 1;m<i;m++){
        k = SL[k].link;
        if (k == 0) break;
    }
    if (m < i) return false;
    else {
        m = my_new();
        if (m) {
            SL[m].data = e;
            SL[m].link = SL[k].link;
            /*将新单元指向第i-1个元素后面的元素*/
            SL[k].link = m;
            return true;
        }
        return false;
    }
}


template<typename T>
bool SLinkList<T>::ListDelete(int i, T &e) {
    int m, k = 0;
    for (m = 1;m<i;m++){
        k= SL[k].link;
        if (k == 0) break;
    }
    /*没有第i-1个结点或者没有第i个结点*/
    if (m < i || SL[k].link == 0) return false;
    else {
        m = SL[k].link;
        /*将i-1个元素指向待删除元素的后继元素*/
        SL[k].link = SL[m].link;
        e = SL[m].data;
        my_delete(m);
        return true;
    }
}


template<typename T>
void SLinkList<T>::ListPrint() {
    int i = SL[0].link;
    while (i) {
        cout<<SL[i].data<<" ";
        i = SL[i].link;
    }
    cout<<endl;
}

#endif