数据结构篇——线性结构之顺序表与链表

线性表

线性表的概念
线性表简称表，是零个或多个元素的有穷序列，通常可以表示成 k0，k1, …，kn-1（n ≥ 1）

线性表的一些名词
– 表目：线性表中的元素（可包含多个数据项，记录）
– 索引（下标）：i 称为表目 ki 的“索引”或“下标”
– 表的长度：线性表中所含元素的个数 n
– 空表：长度为零的线性表 ( n = 0 )

线性表的特点
– 操作灵活，其长度可以增长、缩短

线性结构
二元组? = ?, ? ? = {?0, ?1, … , ??−1} ? = {?}
– 有一个唯一的 ，它没有前驱，有一个唯一的直接后继
– 一个唯一的 ，它有一个唯一的直接前驱，而没有后继
– 其它的结点皆称为 内部结点，每一个内部结点都有且仅有一个唯一的直
接有前驱，也有一个唯一的直接后继
< ??, ??+1 > ??是??+1的前驱，??+1是??的后继
– 前驱/后继关系r，具有 反对称性 和 传递性

线性结构的特点
− 均匀性：虽然不同线性表的数据元素可以是各种各样的，但对于同一线性表的各数据元素必定具有相同的数据类型和长度
− 有序性：各数据元素在线性表中都有自己的位置，且数据元素之间的相对位置是线性的

线性结构的分类
• 按复杂程度划分
– 简单的：线性表、栈、队列、散列表
– 高级的：广义表、多维数组、文件……
• 按访问方式划分
– 直接访问型 (direct access)
– 顺序访问型 (sequential access)
– 目录索引型 (directory access)
• 按操作划分（详见后）
– 线性表

所有表目都是同一类型结点的线性表
不限制操作形式
根据存储的不同分为：顺序表，链表

– 栈 (LIFO, Last In First Out)

插入和删除操作都限制在表的同一端进行

– 队列 (FIFO, First In First Out)

插入操作在表的一端， 删除操作在另一端

线性表类模板

template <class T> class List {
 void clear(); // 置空线性表
 bool isEmpty(); // 线性表为空时，返回 true
 bool append(const T value);
 // 在表尾添加一个元素 value，表的长度增 1
 bool insert(const int p, const T value);
 // 在位置 p 上插入一个元素 value，表的长度增 1
 bool delete(const int p);
 // 删除位置 p 上的元素，表的长度减 1
 bool getPos(int& p, const T value);
 // 查找值为 value 的元素并返回其位置
 bool getValue(const int p, T& value);
 // 把位置 p 元素值返回到变量 value
 bool setValue(const int p, const T value);
 // 用 value 修改位置 p 的元素值
};

线性表的逻辑结构
–线性表的长度
– 表头 (head)
– 表尾 (tail)
– 当前位置 (current position)
线性表的存储结构
1.顺序表
– 按索引值从小到大存放在一片相邻的连续区域
– 紧凑结构，存储密度为 1
2.链表
– 单链表
– 双链表
– 循环链表
线性表按操作分类
• 线性表
– 不限制操作
• 栈
– 在同一端操作
• 队列
– 在两端操作
线性表运算
• 建立线性表
• 清除线性表
• 插入一个新元素
• 删除某个元素
• 修改某个元素
• 排序
• 检索

顺序表

class arrList : public List<T> { // 顺序表，向量
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; curLen = position = 0;
 aList = new T[maxSize];
 }
 int length(); // 返回当前实际长度
 bool append(const T value); // 在表尾添加元素 v
 bool insert(const int p, const T value); // 插入元素
 bool delete(const int p); // 删除位置 p 上元素
 bool setValue(const int p, const T value); // 设元素值
 bool getValue(const int p, T& value); // 返回元素
 bool getPos(int &p, const T value); // 查找元素
};

顺序表也称向量，采用定长的一维数组存储结构
顺序表的特性
– 元素的类型相同
– 元素顺序地存储在连续存储空间中，每一个元素有唯一的索引值
– 使用常数作为向量长度
顺序表的插入

// 设元素的类型为T， aList是存储顺序表的数组， maxSize是其最大长度；
// p为新元素value的插入位置，插入成功则返回true， 否则返回false
template <class T> bool arrList<T> :: insert (const int p, const T value) {
int i;
if (curLen >= maxSize) { // 检查顺序表是否溢出
cout << "The list is overflow"<< endl; return false;
}
if (p < 0 || p > curLen) { // 检查插入位置是否合法
cout << "Insertion point is illegal"<< endl; return false;
}
for (i = curLen; i > p; i--)
aList[i] = aList[i-1]; // 从表尾 curLen -1 起往右移动直到 p
aList[p] = value; // 位置 p 处插入新元素
curLen++; // 表的实际长度增 1
return true;
}

线性表的删除

// 设元素的类型为 T；aList是存储顺序表的数组； p 为即将删除元素的位置
// 删除成功则返回 true，否则返回 false
template <class T> // 顺序表的元素类型为 T
bool arrList<T> :: delete(const int p) {
int i;
if (curLen <= 0 ) { // 检查顺序表是否为空
cout << " No element to delete \n"<< endl;
return false ;
}
if (p < 0 || p > curLen-1) { // 检查删除位置是否合法
cout << "deletion is illegal\n"<< endl;
return false ;
}
for (i = p; i < curLen-1; i++)
 aList[i] = aList[i+1]; // 从位置p开始每个元素左移直到 curLen
 curLen--; // 表的实际长度减1
return true;
}

链表

根据链接方式和指针多少来分类
单链表
• 带头结点的单链表
– 整个单链表： head
– 第一个结点： head->next，head ≠ NULL
– 空表判断： head->next == NULL
当前结点a1：fence->next (curr 隐含)
单链表的节点类型

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 lnkList : public List<T> {
private:
Link<T> * head,
*tail; // 单链表的头、尾指针
Link<T> *setPos(const int p); // 第p个元素指针
 public:
lnkList(int s); // 构造函数
~lnkList(); // 析构函数
bool isEmpty(); // 判断链表是否为空
void clear(); // 将链表存储的内容清除，成为空表
int length(); // 返回此顺序表的当前实际长度
bool append(cosnt T value); // 表尾添加一个元素 value，表长度增 1
bool insert(cosnt int p, cosnt T value); // 位置 p 上插入一个元素
bool delete(cosnt int p); // 删除位置 p 上的元素，表的长度减 1
bool getValue(cosnt int p, T& value); // 返回位置 p 的元素值
bool getPos(int &p, const T value); // 查找值为 value 的元素
}

单链表的插入算法

// 插入数据内容为value的新结点作为第 i 个结点
template <class T> // 线性表的元素类型为 T
bool lnkList<T> :: insert(const int i, const T value) {
Link<T> *p,
*q;
if ((p = setPos(i -1)) == NULL) { // p 是第 i 个结点的前驱
cout << " 非法插入点"<< endl;
return false;
}
q = new Link<T>(value, p->next);
p->next = q;
if (p == tail) // 插入点在链尾，插入结点成为新的链尾
tail = q;
return true;
}

双链表
为弥补单链表的不足,而产生双链表
• 单链表的 next 字段仅仅指向后继结点，不能有效地找到前驱, 反之亦然
• 增加一个指向前驱的指针
双链表的节点类型

template <class T> class Link {
public:
 T data; // 用于保存结点元素的内容
Link<T> * next; // 指向后继结点的指针
Link<T> *prev; // 指向前驱结点的指针
Link(const T info, Link<T>* preValue = NULL, Link<T>* nextValue = NULL) {
// 给定值和前后指针的构造函数
data = info;
next = nextValue;
prev = preValue;
}
Link(Link<T>* preValue = NULL, Link<T>* nextValue = NULL) {
// 给定前后指针的构造函数
next = nextValue;
prev = preValue;
 }
}

循环链表
• 将单链表或者双链表的头尾结点链接起来，就是一个循
环链表
• 不增加额外存储花销，却给不少操作带来了方便
– 从循环表中任一结点出发，都能访问到表中其他结点
链表的注意事项
链表的边界条件
• 几个特殊点的处理
– 头指针处理
– 非循环链表尾结点的指针域保持为 NULL
– 循环链表尾结点的指针回指头结点
• 链表处理
– 空链表的特殊处理
– 插入或删除结点时指针勾链的顺序
– 指针移动的正确性
• 插入
• 查找或遍历

顺序表与链表的比较

• 顺序表
– 插入、删除运算时间代价 O(n)，查找则可常数时间完成
– 预先申请固定长度的连续空间
– 如果整个数组元素很满，则没有结构性存储开销
• 链表
– 插入、删除运算时间代价 O(1)，但找第i个元素运算时间
代价 O(n)
– 存储利用指针，动态地按照需要为表中新的元素分配存
储空间
– 每个元素都有结构性存储开销
顺序表和链表的选择
• 顺序表
– 结点总数目大概可以估计
– 线性表中结点比较稳定（插入删除少）
– n > DE / (P + E)
• 链表
– 结点数目无法预知
– 线性表中结点动态变化（插入删除多）
– n < DE / (P + E)