数据结构第二章总结

线性表简称表，是n个具有相同类型的数据元素的有限序列。

线性表中数据元素的个数称为线性表的长度。长度为零时称为空表。

线性表中数据元素的类型是同一的。

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

存储结构是数据及其逻辑结构在计算机中的表示；

存取结构是在一个数据结构上对查找操作的时间性能的一种描述。

随机存取结构：只要确定了存储顺序表的起始地址（即基地址），计算任意一个元素的存储地址的时间是相等的，具有这一特点的存储结构称为随机存取结构。

顺序表的类的声明

const int MaxSize=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(inti);       

 private:

     DataType data[MaxSize];

     int length;

};

无参构造函数

SeqList<DataType> ::SeqList( )

{ 

    length = 0;

}

有参构造函数

template <class DataType> 

SeqList<DataType> ::SeqList(DataTypea[ ], int n)

{ 

       if (n > MaxSize)throw "参数非法";

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

             data[i] = a[i];

       length = n;

 }

插入

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

}

按位查找

template <class DataType> 

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

{

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

 }

按值查找

template <class DataType> 

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

{

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

 }

 

单链表是用一组任意的存储单元存放线性表的元素，这组存储单元可以连续，也可以不连续，甚至可以零散的分布在内存中的任意位置为了能正确表示元素之间的逻辑关系，每个存储单元在存储数据元素的同时，还必须存储其后继元素所在的地址信息，这个地址信息称为指针，这两部分组成了数据元素的存储映像，称为结点。

单链表的结点结构

template <class DataType>

struct Node

{

     DataType data;

     Node<DataType>*next;

};

 

单链表正是通过每个结点的指针域将线性表数据元素按其逻辑次序链接在一起，由于每个结点只有一个指针域，故称为单链表。

单链表中第一个元素无前驱，所以设头指针指向第一个元素所在的结点（称为开始结点），整个单链表的存取必须从头指针开始进行，因而头指针具有标识一个单链表的作用；同时，由于最后一个元素无后继，故最后一个元素所在的结点（称为终端结点）的指针域为空，即NULL，也称尾标志。

除了开始结点外，其他每个结点的存储地址都存放在其前驱结点的next域中，而开始结点是由头指针指示的。

单链表由头指针唯一指定，整个单链表必须从头指针开始进行。

所谓遍历单链表是指按照序号依次访问单链表中的所有结点并且仅仅访问一次。

单链表是顺序存取结构。

单链表的类的声明

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;

};

遍历操作

template <class DataType>

void LinkList<DataType> :: PrintList( )

{

     p = first->next;

     while (p != NULL)

     {

         cout <<p->data;

         p = p->next;  

     }

}

按位查找

template <class DataType>

void LinkList<DataType> :: PrintList( )

{

     p = first->next;

     while (p != NULL)

     {

         cout <<p->data;

         p = p->next;  

     }

}

按值查找

template <class DataType> 

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

{

    p = first->next;  count = 1;        

    while (p != NULL)   

    {

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

        p = p->next;                  

        count++;

    }

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

}

插入

template <class DataType> 

 void LinkList<DataType>:: Insert(int i, DataType x)

 {

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

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

     {

   
a758
       p = p->next;                  

          count++;

     }

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

    else {

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

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

    }

构造函数

template <class DataType> 

LinkList<DataType> :: LinkList(DataType a[ ], int n)

{

    first = new Node;first->next = NULL;    

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

    {

         s = new Node;s->data = a[i];

         s->next =first->next;

         first->next = s;

    }

}

尾插法

template <class DataType> 

LinkList<DataType> :: LinkList(DataType a[ ], int n)

{

    first = new Node;                        //生成头结点

    r = first;                                       //尾指针初始化

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

    {

        s = new Node;s->data = a[i];       

        r->next = s; r =s;                

    }

    r->next = NULL;       

}

删除

template <class DataType> 

DataType LinkList<DataType> :: 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;

     }

}

析构函数

template <class DataType>

LinkList<DataType> :: ~LinkList( )

{

     while (first != NULL)

     {

         q = first;                

         first =first->next;        

         delete q;   

     }

}

 

 

循环链表

插入

template <class DataType> 

 void LinkList<DataType>::Insert(int i, DataType x)

 {     

     p = first ;   count = 0;   

     while (p != first&& count < i - 1)

     {

          p = p->next;

          count++;

     }

     if (p == NULL) throw"位置";

     else {

          s = newNode<DataType>; s->data = x; 

          s->next =p->next; p->next = s;

     }

}    

双链表

结点结构

template <class DataType>

struct DulNode

{

     DataType data;

     DulNode<DataType>*prior, *next;

};

 

顺序表和单链表的比较

结构的存储密度：

 顺序表：需要预分配存储空间，如果预分配得过大，造成浪费，若估计得过小，又将发生上溢；

 链表：不需要预分配空间，只要有内存空间可以分配，单链表中的元素个数就没有限制。

结点的存储密度：

 顺序表：结点的存储密度为1（只存储数据元素），没有浪费空间；

 链表：结点的存储密度<1（包括数据域和指针域），有指针的结构性开销。

 

若线性表需频繁查找却很少进行插入和删除操作，或其操作和元素在表中的位置密切相关时，宜采用顺序表作为存储结构；若线性表需频繁插入和删除时，则宜采用链表做存储结构。

当线性表中元素个数变化较大或者未知时，最好使用链表实现；而如果用户事先知道线性表的大致长度，使用顺序表的空间效率会更高