山东中医药大学数据结构第二章线性表

2.1 线性表的逻辑结构

2.1.1线性表的定义

线性表（linear list) 简称表，是n（n≥0）个具有相同类型的数据元素的有限序列，线性表的数据元素的个数称为线性表的长度。

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

    后置条件：表不变

ADT

说明：（1）线性表的基本操作根据实际应用是而定；

（2）复杂的操作可以通过基本操作的组合来实现；

（3）对不同的应用，操作的接口可能不同。

2.2线性表的顺序存储结构的实现

2.2.1顺序表

线性表的顺序存储结构称为顺序表。

2.2.2顺序表的实现、

1.构造函数

顺序表的有参构造函数SeqList

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.求线性表的长度  求线性表的长度只需返回成员变量length的值

3.查找操作

（1）按位查找 Get

template <class DataType> 

DataType SeqList<DataType>::Get( int i )

{

     if (i >= 1 && i <= length) return a[i-1];

 }

（2）按值查找 Locate

template <class DataType> 

int SeqList<DataType>::Locate(DataType x)

{

     for (i = 0; i < length; i++)

         if (data[i] == x) return i + 1;

     return 0;         

}

 

4插入 Insert

template <class DataType> 

void SeqList<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++;

}

5.删除 Delete

 template<class DataType>

DataType SeqList <DataType>::Delete(int i)

{

   if (length==0) throw "下溢";

   if(i<1||i>length) throw"位置";

   x=data[i-1];

   for(j=i;j<length;j++)

      data [ j-1] = data [j];

   length--;

   return x;

}

6.遍历操作 PrintList

 

2.3线性表的链接存储结构及实现

2.3.1单链表

头指针：指向第一个结点的地址。

尾标志：终端结点的指针域为空。

头结点：在单链表的第一个元素结点之前附设一个类型相同的结点，以便空表和非空表处理统一。

2.3.2单链表的实现

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.遍历操作 PrintList

template <class DataType>

void LinkList<DataType> :: PrintList( )

{

     p = first->next;

     while (p != NULL)

     {

         cout << p->data;

         p = p->next;  

     }

}

 2.单链表按位查找操作

 

template <class T>

TLinkList<T>::Get(inti)

{  

  Node<T> *p; int j;

    p=first->next; j=1;  //或p=first; j=0;

   while (p &&j<i)   

 {

       p=p->next;      //工作指针p后移

      j++;

  }

   if (!p) throw "位置";

 else returnp->data;

}

3.单链表按值查找算法

template <classDataType> 

intLinkList<DataType>:: Locate(DataType x)

{

    p =first->next; count = 1;        

    while (p != NULL)   

{

     if (p->data== x) return count;    //查找成功，返回序号

     p =p->next;                  

    count++;

 }

return 0;                                         //退出循环表明查找失败

}

4.单链表的实现——插入

template <classDataType> 

voidLinkList<DataType> :: Insert(inti,DataType x)

 {

     p = first ; count= 0;            //工作指针p应指向头结点

      while (p != NULL && count <i - 1)    //查找第i – 1个结点

      {

           p =p->next;                  

          count++;

      }

 if (p == NULL)throw "位置";     //没有找到第i – 1个结点

else {

    s = newNode; s->data = x;         //申请一个结点s

     s->next =p->next; p->next = s;   //结点s插入结点p之后

   ｝

｝

5.单链表的构造函数

6.无参构造函数

7.单链表删除算法

8.单链表析构函数算法

2.3.3循环链表

将单链表的首尾相接，将终端结点的指针域由空指针改为指向头结点，构成单循环链表，简称循环链表。

2.3.4双链表

双链表：在单链表的每个结点中再设置一个指向其前驱结点的指针域。