数据结构笔记：顺序表、单链表以及循环链表

线性表

顺序表：

线性表的顺序存储结构成为顺序表。一般用数组来完成定义，存储值以及线性关系。

数组实现线性表，也就是把线性表中相邻的元素存储在数组中相邻的位置，从而导致了数据元素的序号和存放它的数组下表之间具有一一对应的关系。

特点：线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，

作用：线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。

顺序存储的实现：一维数组存储顺序表中的数据

顺序表实现的主体结构：

const int Maxsize=100;

template <class T>

class SeqList{

private:

T data[MaxSize]; // 存放数据元素的数组

int length; // 线性表的长度

public:

SeqList ( ) ;// 无参构造函数   

SeqList ( T a[ ], int n ) ; // 有参构造函数

~SeqList( ) { } // 析构函数为空

int Length ( ) {return length;} // 求线性表的长度

T Get ( int i ); // 按位查找，取线性表的第 i 个元素

int Locate ( T x ) ; // 按值查找，求线性表中值为 x 的元素序号

void Insert ( int i, T x ) ; // 在线性表中第 i 个位置插入值为 x 的元素

T Delete ( int i ) ; // 删除线性表的第 i 个元素

void PrintList ( ) ; // 遍历线性表，按序号依次输出各元素

};

 

链式存储结构以及实现：

特点：根据线性表的长度动态的申请存储空间，以解决顺序存储中存在的存储空间难以确定的问题。变量的三要素：名字，内存地址，值。变量的左值，右值。左值指变量的内存地址

右值：值。在赋值表达式中，赋值号左边需要左值，右边需要右值；如a=a+100 。指针变量：指针变量的右值本身又是一个左值。

单链表的定义，采用C++模板：

template <typename T>

struct Node

{

T data;

Node<T> *next;      //此处<T>也可以省略

};

template <class T>

class LinkList {

public:

LinkList ( ) {first=new Node<T>; first -> next= NULL ;}//创建空；

   LinkList ( T a[ ], int n ) ; //创建单链表

~LinkList ( ) ;析构函数，用于清空内存

int Length ( ) ;//得到单链表长度

T Get ( int i ) ; //用值查找位置

int Locate ( T x ) ;//用位置查找值

void Insert ( int i, T x ) ;//创建没有头指针的单链表

T Delete ( int i ) ; //删除其中值

void PrintList ( ) ; //遍历

private:

Node<T>  *first; // 单链表的头指针  , <T>可以省略

};

template <class T>  

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

    first=new Node<T>;   //生成头结点

   first->next=NULL;

   Node<T> *s;

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

          s=new Node<T>;

          s->data=a[i];  //为每个数组元素建立一个结点

          s->next=first->next;

          first->next=s;

}

}

template <class T>  

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

    Node<T> *r,*s;      //尾指针

    first=new Node<T>;   //生成头结点

r=first;          

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

        s=new Node<T>;

        s->data=a[i];  //为每个数组元素建立一个结点

        r->next=s; r=s;      //插入到终端结点之后

}

    r->next=NULL;    //单链表建立完毕，将终端结点的指针域置空

 }

template <class T>  

LinkList<T>:: PrintList()

{

    Node<T> *p;

p=first->next;          

     while(p)

{

cout<<p->data;

            p=p->next;

}

 }

头插法：

{

    first=NULL;

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

         s=new node<T>;

         s->data=a[i];

         s->next=first;

         first=s;   

    }

}

尾插法：

    node<T> *r;

     head=NULL;

    if（n<=0）return;

    s=new node<T>;

    s->data=a[0];

    s->next=head;

    head=s;   

    r=head;

for(int i=1;i<n;i++)    {

         s=new node<T>;

         s->data=a[i];

         r->next=s;

         r=s;   

    }

template <class T>

T LinkList<T>::Get(int i) {   

  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 return p->data;

}

template <class T>

T LinkList<T>::Get(int i) {   

   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 return p->data;

}

template <class T>  

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

   Node<T> *p; int j;

   p=first ; j=0;    //工作指针p初始化

   while (p && j<i-1)   {

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

     j++;

   }

   if (!p) throw "位置";

    else {

  Node<T> *s;

      s=new Node<T>;

  s->data=x;  //向内存申请一个结点s，其数据域为x

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

      p->next=s;

}

 }

不带头结点的单链表中插入结点

Insert(int i, T x){  

   Node<T> *p; int j;

   if（i<=0） throw “位置非法”；

   if （i==1 ）{ s=new Node<T>;s->next=head;head=s;return}

   p=first ; j=1;    //工作指针p初始化

   while (p && j<i-1)   {

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

     j++;

   }

   if (!p) throw "位置";

    else {

  Node<T> *s;

      s=new Node<T>;

  s->data=x;  //向内存申请一个结点s，其数据域为x

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

      p->next=s;

}

 }

template <class T>  

T LinkList<T>::Delete(int i){

  Node<T> *p; int j;

  p=first ; j=0;  //工作指针p初始化

  while (p && j<i-1) {  //查找第i-1个结点

    p=p->next;

    j++;

  }

  if (!p || !p->next) throw "位置";  //结点p不存在或结点p的后继结点不存在

    else {

        Node<T> *q; T x;

          q=p->next; x=q->data;  //暂存被删结点

          p->next=q->next;  //摘链

          delete q;

          return x;

}

}

template <class T>

LinkList<T>:: ~LinkList()

{

   Node<T> *q;

   while (first)

   {

       q=first->next;

       delete first;

       first=q;

    }

}

 

 

 

 

 

 

循环链表的定义

将单链表或者双链表的头尾结点链接起来，就是一个循环链表。

不增加额外存储花销，却给不少操作带来了方便

从循环表中任一结点出发，都能访问到表中其他结点。

template <class T>

struct Node

{

   T data;

   Node<T> *next;

};

template <class T>

class CycleLinkList{

  public:

    CycleLinkList( ); //空表构造

    CycleLinkList(T a[ ], int n);  

    CycleLinkList(T a[ ], int n,int i);

    ~CycleLinkList();           

    int Length();        

    T Get(int i);          

     void Insert(int i, T x);

    T Delete(int i);        

    void PrintList( );    

 private:

   Node<T> *first;  

};

//尾插法构造循环链表

template <class T>

CycleLinkList<T>:: CycleLinkList( )

{

         first=new Node<T>; first->next=first;

}template <class T>  

CycleLinkList<T>:: CycleLinkList(T a[ ], int n) {

    first=new Node<T>;   //生成头结点

Node<T> *r,*s;

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

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

        s=new Node<T>;

        s->data=a[i];  

        r->next=s;

         r=s;     

}

    r->next=first;    //单链表建立完毕，将终端结点的指针域指向头结点

 }

头插法构造循环链表

template <class T>  

CycleLinkList<T>:: CycleLinkList(T a[ ], int n,int k)

 {

    first=new Node<T>;   //生成头结点

first->next=first;

Node<T> *s;

for (int i=1; i<n; i++)

{

      s=new Node<T>;

  s->data=a[i];  //为每个数组元素建立一个结点

      s->next=first->next;

  first->next=s;

}

将非循环的单链表改造成循环的单链表

p=first;

while(p->next)

{

       p=p->next;  

 }

p->next=first

 

}