线性表

线性表

• 线性表(linear list )：元素组成的有限且有序的序列。
• 所谓的线性指的是一个连着一个，并非数学或物理中的线性。
• 特点：
  
  • 均匀性：每个元素数据类型相同
  • 有序性
• 数学结构：
  
  • 二元组$B=(K,R)$
  • $K$为结点集合$K=\{v_0,v_1,\cdots,v_n\}$
  • $R$为关系集合$R=\{r\}$。
  • 除了第一个结点外，所有结点都有前驱
  • 除了最后一个结点外，所有结点都有后继

逻辑结构

• 线性结构：二元组$B=(K,R)$
• 长度(length)，结点个数
• 空表(empty list )，长度为0的表
• 表头(head )
• 表尾(tail )
• 关系 r <script type="math/tex" id="MathJax-Element-518">r</script> 具有反对称性和传递性

//线性表的类模板
template <class T>
class List{
public:
    List();
    ~List();

    void clear();
    bool isEmpty();
    bool apend(const T value);
    bool insert(const int pos,const T value);
    bool delete(const int pos);
    bool setValue(const int pos,const T value);
    bool getValue(const int pos,T& value); //查找下标为pos的值，赋给value
    bool getPos(const T value,int& pos); //查找值为value的位置，赋给pos
}

存储结构

顺序表

• 称为顺序表，或向量，用定长的一维数组实现的顺序存储结构。

//顺序表
template <class T>
class arrList:public class List{
private:
    T* aList;
    int maxSize;   //操作中顺序表可能达到的最大长度
    int curLen;
    int position;
public:
    arrList(const int size){
        maxSize = size; 
        aList = new T[maxSize];
        curLen = position = 0;
    }
    ~arrList(){ 
        delete [] aList;
    }

    void clear(){
        delete [] aList;
        position = curLen = 0;
        aList = new T[maxSize];
    }
    int length();
    bool apend(const T value);
    bool insert(const int pos,const T value);
    bool delete(const int pos);
    bool setValue(const int pos,const T value);
    bool getValue(const int pos,T& value); //查找下标为pos的值，赋给value
    bool getPos(const T value,int& pos); //查找值为value的第一个位置，赋给pos
};

链表

• 链表(linked list )，通过指针来连接的变长的链式存储结构
• 分类
  
  • 单链表(singly linked list )，
  • 双链表(double linked list )
  • 循环链表(circularly linked list )

单链表

//单链表的结点
template <class T>
class Link{
public:
    T data;
    Link<T>* next;

    Link(const T info,const Link<T>* nextValue = NULL){
        data = info;
        next = nextValue;
    }
    Link(const Link<T>* nextValue){
        next = nextValue;
    }

};

//单链表
template<class T>
class linkList{
private:
    Link<T>* head;
    Link<T>* tail;

    Link<T>* setPos(const int pos);
public:
    linkList(int s);
    ~linkList();

    bool isEmpty();
    void clear();
    int length();

    bool apend(const T value);
    bool insert(const int pos,const T value);
    bool delete(const int pos);
    bool getValue(const int pos,T& value); //查找下标为pos的值，赋给value
    bool getPos(const T value,int& pos); //查找值为value的第一个位置，赋给pos
}

双链表

//双链表的结点
template <class T>
class Link{
public:
    T data;
    Link<T>* next;
    Link<T>* prev;

    Link(const T info,const Link<T>* preValue = NULL,const Link<T>* nextValue = NULL){
        data = info;
        prev = preValue
        next = nextValue;
    }
    Link(const Link<T>* preValue = NULL,const Link<T>* nextValue){
        next = nextValue;
        prev = prevValue;
    }
};  

线性表的运算

顺序表

//插入算法
template<class T>
bool arrList<T>::insert(const int pos, const T value){
    if(curLen >= maxLength)
        return false;
    if(pos < 0 || pos >= curLen)
        return false;
    for(int i = curLen - 1;i >= pos;i--)
        aList[i+1] = aList[i];
    aList[pos] = value;
    curLen ++;
    return true;
}

//删除算法
template<class T>
bool arrList<T>::bool delete(const int pos){
    if(curLen >= maxLength || curLen <= 0)
        return false;
    if(pos < 0 || pos >= curLen)
        return false;
    for(int i = pos;i < curLen - 1;i++)
        aList[i] = aList[i+1];
    curLen --;
    return true;
}

单链表

• 注意点
  
  • 对一个结点操作，首先必须找到它，即用一个指针指向它。
  • 头指针的处理
  • 插入或删除时指针的顺序

//查找算法
template<class T>
Link<T>* linkList<T>::setPos(const int pos){
    int count = 0;
    Link<T>* pointer = new Link<T>(head->next); //要new一个空间，并且从head->next开始
    while(p != NULL && count++ < pos)
        pointer = pointer->next; //如果pos大于链表长度则返回NULL
    return pointer;
}

//插入算法
template<class T>
bool linkList<T>::insert(const int pos,const T value){
    if(!setPos(pos-1))  
        return false;
    Link<T>* pointer = setPos(pos - 1); //使用检索函数简化算法
    Link<T>* node = new Link<T>(value);
    node->next = pointer-next;
    pointer->next = node;
    return true;
}

//删除算法
template<class T>
bool linkList<T>::delete(const int pos){
    if(setPos(pos - 1) == NULL)
        return false;
    Link<T>* pointer1 = setPos(pos - 1);
    Link<T>* pointer2 = pointer1->next;
    if(pointer2 == tail){  //删除尾部结点
        pointer1->next = NULL;
        tail = pointer1;
        delete pointer2;
    }
    else{  //正常删除结点
        if(pointer2 != NULL){
            pointer1->next = pointer2->next; //如此删除
            delete pointer2; //释放内存
        }
    }
    return true;
}

//求长度算法
template<class T>
int linkList<T>::length(){
    int count = 0;
    Link<T>* pointer = head->next;
    while(pointer != NULL)
    {
        pointer = pointer->next;
        count ++；
    }
    return count;
}

---

参考王腾蛟课件