线性表

线性表

线性表(linear list )：元素组成的有限且有序的序列。

所谓的线性指的是一个连着一个，并非数学或物理中的线性。

特点：

均匀性：每个元素数据类型相同

有序性

数学结构：

二元组B=(K,R)B=(K,R)

KK为结点集合K={v0,v1,⋯,vn}K=\{v_0,v_1,\cdots,v_n\}

RR为关系集合R={r}R=\{r\}。

除了第一个结点外，所有结点都有前驱

除了最后一个结点外，所有结点都有后继

逻辑结构

线性结构：二元组B=(K,R)B=(K,R)

长度(length)，结点个数

空表(empty list )，长度为0的表

表头(head )

表尾(tail )

关系 rr 具有反对称性和传递性

//线性表的类模板
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;
}

参考王腾蛟课件