第二章——线性表

最新推荐文章于 2024-07-25 14:12:59 发布

泡泡>3<

最新推荐文章于 2024-07-25 14:12:59 发布

阅读量162

点赞数

分类专栏：笔记文章标签：作业笔记

本文链接：https://blog.csdn.net/qq_44609879/article/details/102415540

版权

笔记专栏收录该内容

13 篇文章 0 订阅

订阅专栏

线性表

定义：是零个或多个具有相同类型的数据元素的有限序列。
数据元素的个数定义为线性表的长度。长度等于零时称为空表。

线性表的抽象数据类型定义

ADT List
Data
线性表中的数据元素具有相同类型，相邻元素具有前驱和后继关系
Operation
InitList
前置条件：线性表不存在
输入：无
功能：线性表的初始化
输出：无
后置条件：一个空的线性表
DestroyList
前置条件：线性表已存在
输入：无
功能：销毁线性表
输出：无
后置条件：释放线性表所占用的存储空间
Length
前置条件：线性表已存在
输入：无
功能：求线性表的长度
输出：线性表中数据元素的个数
后置条件：线性表不变
Get
前置条件：线性表已存在
输入：元素的序号 i
功能：在线性表中取序号为 i 的数据元素
输出：如果序号合法，返回序号为 i 的元素值，否则抛出异常
后置条件：线性表不变
Locate
前置条件：线性表已存在
输入：数据元素 x
功能：在线性表中查找值等于 x 的元素
输出：如果查找成功，返回元素 x 在表中的序号，否则返回 0
后置条件：线性表不变
Insert
前置条件：线性表已存在
输入：插入位置 i ；待插元素 x
功能：在线性表的第 i 个位置处插入一个新元素 x
输出：若插入不成功，抛出异常
后置条件：若插入成功，表中增加了一个新元素

Delete
前置条件：线性表已存在
输入：删除位置 i
功能：删除线性表中的第 i 个元素
输出：若删除成功，返回被删元素，否则抛出异常
后置条件：若删除成功，表中减少了一个元素
Empty
前置条件：线性表已存在
输入：无
功能：判断线性表是否为空表
输出：若是空表，返回 1 ，否则返回 0
后置条件：线性表不变
PrintList
前置条件：线性表已存在
输入：无
功能：按位置的先后次序依次输出线性表中的元素
输出：线性表的各个数据元素
后置条件：线性表不变

顺序表

顺序表的实现：

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 ( ) ; // 遍历线性表，按序号依次输出各元素 
};

构造函数：
无参构造函数（构造一个空的顺序表）

SeqList ( ) {length=0;}

构造一个非空的顺序表
SeqList ( T a[ ], int n ) ; //有参构造函数

有参构造函数的实现：

template <class T> 
SeqList<T>:: SeqList(T a[], int n)
{
  if (n>MaxSize) throw "参数非法";
  for (int i=0; i<n; i++)  
    data[i]=a[i];
  length=n;
}

顺序表的插入算法：
算法实现

template <class T> 
void SeqList<T>::Insert(int i, T x){ 
    int j;
    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 T>
T SeqList<T>::Delete(int i){ 
   int j; 
   T  x;
  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;
}

顺序表的查找操作：
1.按位置查找，即查找指定位置上的元素
2.按值查找，即查找指定的值在顺序表中的位置

按位置查找

template <class T> 
T SeqList<T>::Get(int i)
{
    if (i<1 && i>length) throw "查找位置非法";
    else return data[i-1];
}
//按位查找算法的时间复杂度为 O ( 1 ) 。

按值查找

template <class T>
int SeqList<T>::Locate(T x){     
   for (int i=0; i<length; i++)
    if (data[i]==x) 
      return i+1 ;  //下标为i的元素等于x，返回其序号i+1
   return 0;  //退出循环，说明查找失败
}

指针变量的特点：
变量的三要素
名字，内存地址，值
变量的左值，右值
左值指变量的内存地址
右值：值
在赋值表达式中，赋值号左边需要左值，右边需要右值；如a=a+100
指针变量
指针变量的右值本身又是一个左值。

单链表

定义形式

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

不带头结点的单链表构造：
尾插法：

    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;   
    }
头插法：
{
    f

irst=NULL;
    for(int i=0;i<n;i++)    { 
         s=new node<T>;
         s->data=a[i];
         s->next=first;
         first=s;   
    }
}
单链表两种查

找方法：
按位查找，按值查找
单链表插入算法

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

删除算法

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(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;
 }
}
尾插：
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>
class DoubleLink {
private:
 Node<T> *head;
public:
 DoubleLink() ；
 ~DoubleLink();
 void Append(T data);
 void Display();
 void Insert(int locate , T data);
 T    Get(int locate);
 T  Delete(int locate);
};

静态链表

同样可以借助一维数组来描述：
＃define Maxsize= 链表可能达到的最大长度
template
structNode{
ElemType data; 
int next; 
};

泡泡>3<

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
第二章——线性表

线性表定义：是零个或多个具有相同类型的数据元素的有限序列。数据元素的个数定义为线性表的长度。长度等于零时称为空表。线性表的抽象数据类型定义ADT ListData线性表中的数据元素具有相同类型，相邻元素具有前驱和后继关系OperationInitList前置条件：线性表不存在输入：无功能：线性表的初始化输出：无后置条件：一个空的线性表DestroyList前置条件：...
复制链接

扫一扫