第2章线性表
线性表是线性结构的典型代表。线性表是一种最基本、最简单的数据结构,数据元素之间仅具有单一的前驱和后继关系。
2.1 线性表的逻辑结构
2.1.1 线性表的定义
★线性表:简称表,是n(n≥0)个具有相同类型的数据元素的有限序列。
★线性表的长度:线性表中数据元素的个数。
★空表:长度等于零的线性表,记为:L=( )。
★非空表记为:L=(a1,a2 , …,ai-1, ai ,…, an)。其中,ai(1≤i≤n)称为数据元素;下角标i表示该元素在线性表中的位置或序号。
★线性表的特性:
1. 有限性:线性表中数据元素的个数是有穷的。
2. 相同性:线性表中数据元素的类型是同一的。
3. 顺序性:线性表中相邻的数据元素ai-1和ai之间存在序偶关系(ai-1,ai),即ai-1是ai的前驱,ai是ai-1的后继;a1无前驱,an无后继,其它每个元素有且仅有一个前驱和一个后继。
2.1.2 线性表的抽象数据定义类型
抽象数据类型定义为:
ADT List
Data
线性表中的数据元素具有相同类型,相邻元素具有前驱和后继关系
Operation
InitList
前置条件:表不存在
输入:无
功能:表的初始化
输出:无
后置条件:建一个空表
DestroyList
前置条件:表已存在
输入:无
功能:销毁表
输出:无
后置条件:释放表所占用的存储空间
Length
前置条件:表已存在
输入:无
功能:求表的长度
输出:表中数据元素的个数
后置条件:表不变
Get
前置条件:表已存在
输入:元素的序号i
功能:在表中取序号为i的数据元素
输出:若i合法,返回序号为i的元素值,否则抛出异常
后置条件:表不变
Locate
前置条件:表已存在
输入:数据元素x
功能:在线性表中查找值等于x的元素
输出:若查找成功,返回x在表中的序号,否则返回0
后置条件:表不变
Insert
前置条件:表已存在
输入:插入i;待插x
功能:在表的第i个位置处插入一个新元素x
输出:若插入不成功,抛出异常
后置条件:若插入成功,表中增加一个新元素
Delete
前置条件:表已存在
输入:删除位置i
功能:删除表中的第i个元素
输出:若删除成功,返回被删元素,否则抛出异常
后置条件:若删除成功,表中减少一个元素
Empty
前置条件:表已存在
输入:无
功能:判断表是否为空
输出:若是空表,返回1,否则返回0
后置条件:表不变
PrintList
前置条件:表已存在
输入:无
功能:遍历操作,按序号依次输出线性表中的元素
输出:线性表的各个数据元素
后置条件:线性表不变
endADT
说明:
(1)线性表的基本操作根据实际应用是而定;
(2)复杂的操作可以通过基本操作的组合来实现;
(3)对不同的应用,操作的接口可能不同。
2.2 线性表的顺序存储结构及实现
2.2.1 线性表的顺序存储结构——顺序表
存储要点:用一段地址连续的存储单元,
依次存储线性表中的数据元素
如何描述顺序表?
存储空间的起始位置、顺序表的容量(最大长度)、顺序表的当前长度
存储结构是数据及其逻辑结构在计算机中的表示;
存取结构是在一个数据结构上对查找操作的时间性能的一种描述。
“顺序表是一种随机存取的存储结构”的含义为:在顺序表这种存储结构上进行的查找操作,其时间性能为O(1)。
2.2.2顺序表的实现
顺序表类的声明:
const intMaxSize=100;
template<class DataType> //模板类
class SeqList
{
public:
SeqList( ) ; //构造函数
SeqList(DataType a[ ], int n);
~SeqList( ) ; //析构函数
int Length( );
DataType Get(int i);
int Locate(DataType x );
void Insert(int i, DataType x);
DataType Delete(int i);
private:
DataType data[MaxSize];
int length;
};
(1) 构造函数
无参构造函数SeqList( ):
SeqList<DataType>::SeqList( )
{
length = 0;
}
有参构造函数SeqList(DataType a[ ], int n):
template<class DataType>
SeqList<DataType>::SeqList(DataType a[ ], int n)
{
if (n > MaxSize) throw "参数非法";
for (i = 0; i < n; i+ +)
data[i] = a[i];
length = n;
}
(2)插入操作
算法描述——伪代码
1. 如果表满了,则抛出上溢异常;
2. 如果元素的插入位置不合理,则抛出位置异常;
3. 将最后一个元素至第i个元素分别向后移动一个位置;
4. 将元素x填入位置i处;
5. 表长加1;
算法描述——C++描述
template<class DataType>
voidSeqList<DataType>::Insert(int i, DataType x)
{
if (length >= MaxSize) throw "上溢";
if (i < 1 || i > length + 1) throw"位置";
for (j = length; j >= i; j--)
data[j] = data[j-1];
data[i-1] = x;
length++;
}
时间性能分析:
最好情况( i=n+1):
基本语句执行0次,时间复杂度为O(1)。
最坏情况( i=1):
基本语句执行n+1次,时间复杂度为O(n)。
平均情况(1≤i≤n+1):时间复杂度为O(n)。
(3) 删除操作
intSeqList::Delete (int i)
{
if (length==0) throw "下溢";
if (i<1||i>length) throw "位置非法";
int x=data[i-1];
for (int j=i;j<length;j++)
data[j-1]=data[j];
length--;
return x;
}
(4)查找操作
按位查找:
template<class DataType>
DataTypeSeqList<DataType> ::Get( int i )
{
if (i >= 1 && i <= length) throw “查找位置非法”;
else return data [i-1];
}
按值查找:
template<class DataType>
intSeqList<DataType> ::Locate(DataType x)
{
for (i = 0; i < length; i++)
if (data[i] == x) return i + 1;
return 0;
}
(4) 遍历操作:
voidSeqList::PrintList ()
{
for (int i=0;i<length;i++)
cout<<data[i]<<"";
cout<<endl;
}
顺序表的优点:
⑴无需为表示表中元素之间的逻辑关系而增加额外的存储空间;
⑵随机存取:可以快速地存取表中任一位置的元素。
顺序表的缺点:(原因:静态存储分配)
⑴插入和删除操作需要移动大量元素;
⑵表的容量难以确定,表的容量难以扩充;
⑶造成存储空间的碎片。
2.3 线性表的链接存储结构及实现
2.3.1 单链表
存储特点:
1.逻辑次序和物理次序不一定相同。
2.元素之间的逻辑关系用指针表示。
单链表是由若干结点构成的;单链表的结点只有一个指针域。
单链表的结点结构:
data:存储数据元素
next:存储指向后继结点的地址
template<class DataType>
struct Node
{
DataType data;
Node<DataType> *next;
};
申请结点:s=new Node <int> ;
引用数据元素:s->data;
引用指针域:s->next;
头指针:指向第一个结点的地址。
尾标志:终端结点的指针域为空。
空表:first=NULL;
非空表:
头结点:在单链表的第一个元素结点之前附设一个类型相同的结点,以便空表和非空表处理统一。
单链表类的声明:
template<class DataType>
class LinkList
{
public:
LinkList( );
LinkList(DataType a[ ], int n);
~LinkList( );
int Length( );
DataType Get(int i);
int Locate(DataType x);
void Insert(int i, DataType x);
DataType Delete(int i);
void PrintList( );
private:
Node<DataType> *first;
};
(1)构造函数:
无参构造函数:
template<class DT>
LinkList<DT>::LinkList()
{
first=new Node<DT>;
first->next=NULL;
}
有参构造函数:
尾插法
template<class DT>
LinkList<DT>::LinkList(DT a[],int n)
{
Node <DT> *r,*s;
first=new Node<DT>;
r=first;
for (int i=0;i<n;i++)
{
s=new Node<DT>;
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}
头插法
template<class DT>
LinkList<DT>::LinkList(DT a[],int n)
{
first=new Node<DT>;
first->next=NULL;
for ( i=0;i<n;i++)
{
s=new Node<DT>;
s->data=a[i];
s->next=first->next;
first->next=s;
}
}
(2) 析构函数
template<class DT>
LinkList<DT>::~LinkList()
{
while (first!=NULL)
{
q=first;
first=first->next;
delete q;
}
}
(3)插入操作
template<class DT>
voidLinkList<DT>::Insert (int i,DT x)
{
p=first;
count=0;
while (p!=NULL && count<i-1)
{
p=p->next;
count++;
}
if (p==NULL) throw"位置";
else
{
s=new Node <DT>;
s->data=x;
s->next=p->next;
p->next=s;
}
}
(4)删除操作
template<classDT>
DTLinkList<DT>::Delete (int i)
{
p=first;
count=0;
while (p!=NULL&&count<i-1)
{
p=p->next;
count++;
}
if (p==NULL||p->next==NULL) throw "位置";
else
{
q=p->next;
x=q->data;
p->next=q->next;
delete q;
return x;
}
}
(5)查找算法
按值查找
template<class DT>
intLinkList<DT>::Locate (DT x)
{
p=first->next;
count=1;
while (p!=NULL)
{
if(p->data==x) return count;
p=p->next;
count++;
}
return 0;
}
按位查找
template<class T>
TLinkList<T>::Get(int i)
{
p=first->next;
count=1;
while (p !=NULL&&count<i)
{
p=p->next; //工作指针p后移
count++;
}
if (p==NULL) throw "位置";
else return p->data;
}
(6)遍历操作
template<classDT>
voidLinkList<DT>::PrintList ()
{
p=first->next;
while(p!=NULL)
{
cout<<p->data<<"";
p=p->next;
}
}
(7) 求长度
template<classDT>
voidLinkList<DT>::Length ()
{
P=first->next;
count=0;
while(p!=NULL)
{
p=p->next;
count++;
}
return count;
}
算法设计的一般步骤:
第一步:确定入口(已知条件)、出口(结果);
第二步:根据一个小实例画出示意图;
第三步:①正向思维:选定一个思考问题的起点,逐步提出问题、解决问题;②逆向思维:从结论出发分析为达到这个结论应该先有什么;③正逆结合;
第四步:写出顶层较抽象算法,分析边界情况;
第五步:验证第四步的算法;
第六步:写出具体算法;
第七步:进一步验证,手工运行。
2.3.2 循环链表
将单链表的首尾相接,将终端结点的指针域由空指针改为指向头结点,构成单循环链表,简称循环链表。
空表和非空表的处理一致——附设头结点。
◆插入算法
s=newNode<DataType>;
s->data=x;
s->next=p->next;
p->next=s;
◆循环链表中没有明显尾端,如何避免死循环?
循环条件:
p != NULL—>p != first
p->next !=NULL—>p->next != first
◆开始结点:first->next
终端结点:将单链表扫描一遍,时间为O(n)
◆ 带尾指针的循环链表
一个存储结构设计得是否合理,取决于基于该存储结构的运算是否方便,时间性能是否提高。
2.3.3双链表
双链表:在单链表的每个结点中再设置一个指向其前驱结点的指针域
data:数据域,存储数据元素;
prior:指针域,存储该结点的前趋结点地址;
next:指针域,存储该结点的后继结点地址。
定义:
template<class DataType>
struct DulNode
{
DataType data;
DulNode<DataType> *prior, *next;
};
(1) 插入操作
在结点p的后面插入一个新结点s,需修改4个指针:
s->prior=p;
s->next=p->next;
p->next->prior=s;
p->next=s;
(2)删除操作
设指针p指向待删除结点,删除操作可通过下述语句完成,这两个语句顺序可颠倒。
(p->prior)->next=p->next;
(p->next)->prior=p->prior;
2.4顺序表和链表的比较
(1)存储分配方式比较
顺序表采用顺序存储结构,即用一段地址连续的存储单元依次存储线性表的数据元素,数据元素之间的逻辑关系通过存储位置来实现。
链表采用链接存储结构,即用一组任意的存储单元存放线性表的元素,用指针来反映数据元素之间的逻辑关系。
(2) 时间性能比较
时间性能是指实现基于某种存储结构的基本操作(即算法)的时间复杂度。
<1>按位查找:
顺序表的时间为O(1),是随机存取;
链表的时间为O(n),是顺序存取。
<2>插入和删除:
顺序表需移动表长一半的元素,时间为O(n);
链表不需要移动元素,在给出某个合适位置的指针后,插入和删除操作所需的时间仅为O(1)。
(3)空间性能比较
空间性能是指某种存储结构所占用的存储空间的大小。
定义结点的存储密度:
存储密度=数据域占用的存储量/整个结点占用的存储量
<1>结点的存储密度:
顺序表:结点的存储密度为1(只存储数据元素),没有浪费空间;
链表:结点的存储密度<1(包括数据域和指针域),有指针的结构性开销。
<2>结构的存储密度:
顺序表:需要预分配存储空间,如果预分配得过大,造成浪费,若估计得过小,又将发生上溢;
链表:不需要预分配空间,只要有内存空间可以分配,单链表中的元素个数就没有限制。
总结
⑴若线性表需频繁查找却很少进行插入和删除操作,或其操作和元素在表中的位置密切相关时,宜采用顺序表作为存储结构;若线性表需频繁插入和删除时,则宜采用链表做存储结构。
⑵当线性表中元素个数变化较大或者未知时,最好使用链表实现;而如果用户事先知道线性表的大致长度,使用顺序表的空间效率会更高。
总之,线性表的顺序实现和链表实现各有其优缺点,不能笼统地说哪种实现更好,只能根据实际问题的具体需要,并对各方面的优缺点加以综合平衡,才能最终选定比较适宜的实现方法。
2.5线性表的其他存储方法
2.5.1静态链表
静态链表:用数组来表示单链表,用数组元素的下标来模拟单链表的指针。
数组元素(结点)的构成:
data:存储放数据元素;
next:也称游标,存储该元素的后继在数组的下标。
first:静态链表头指针,为了方便插入和删除操作,通常静态链表带头结点
avail:空闲链表头指针,空闲链表由于只在表头操作,所以不带头结点
静态链表的存储结构定义如下:
const intMaxSize = 100; //100只是示例数据
template<class DataType>
struct SNode
{
DataType data; // DataType表示不确定的数据类型
intnext; //指针域(也称游标)
}
SList[MaxSize];
假设结点s插在结点p之后,则修改指针的操作为:
s = avail; //利用空闲链的第一个结点
avail = SList[avail].next; //空闲链的头指针后移
SList[s].data = x; //将x填入下标为s的结点
SList[s].next = SList[p].next; //将下标为s的结点插入到下标为p的结点后面
SList[p].next = s;
假设删除结点p的后继结点,则修改指针的操作为:
q = SList[p].next; //暂存被删结点的下标
SList[p].next = SList[q].next; //摘链
SList[q].next = avail; //将结点q插在链avail的最前端
avail = q; //空闲链头指针avail指向结点q
相对于顺序表而言,静态链表有什么优点?
优点:在执行插入和删除操作时,只需修改游标,不需要移动表中的元素,从而改进了在顺序表中插入和删除操作需要移动大量元素的缺点。
缺点:没有解决连续存储分配带来的表长难以确定的问题;静态链表还需要维护一个空闲链;静态链表不能随机存取。
2.5.2间接寻址
间接寻址:是将数组和指针结合起来的一种方法,它将数组中存储数据元素的单元改为存储指向该元素的指针。
插入操作移动的不是元素而是指向元素的指针。当元素占用的空间较多时,比顺序表的插入操作快得多。
线性表的间接寻址保持了顺序表随机存取的优点,同时改进了插入和删除操作的时间性能。