数据结构——线性表

最新推荐文章于 2022-09-30 15:55:41 发布
最新推荐文章于 2022-09-30 15:55:41 发布
阅读量290 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cure_myself/article/details/115061172
版权

数据结构——线性表的实现（模板类）

一.顺序表

1.无参构造函数

template<typename T>
SeqList<T>::SeqList( )
{  
    length=0; //表长初始化为0
}

2.有参构造函数

template <class T>  
SeqList::SeqList(T a[ ], int n)
{  
       if (n>MaxSize) throw "参数非法";//不能超出数组最大长度，MaxSize是线性表的最大可存储长度
       for (i=0; i<n; i+ +)  
             data[i]=a[i];
       length=n; //更新表长
 }

3.插入操作

template <class T>  
void SeqList::Insert(int i, T x)//i为在线性表中的位置（1，2，3，4，5...），而非在数组中的位置（0，1，2，3，4...）
{
      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++;
}

4.删除操作

template <class T>  
T SeqList::Delete(int i)//i为在线性表中的位置（1，2，3，4，5...），而非在数组中的位置（0，1，2，3，4...）
{
	  T x;
      if (length==0) throw  "下溢";
      if (i<1 | | i>length) throw  "删除位置错误 ";
      x=data[i-1];//要删除的元素
      for (int j=i;j<length;j++)//表中元素前移
           data[j-1]=data[j];
      length--;
      return x;
}

5.查找操作、判空操作与遍历操作

查找操作分为按值查找（Locate）和按位查找（Get），这三种功能思路比较简单，不再赘述，但应注意判溢。

二.单链表（带头结点）

1.结点

template <class T>
struct Node
{
     T data;
     Node<T> *next;
};

2.无参构造函数

template <class T>
LinkList<T>::LinkList()
{
	first=new Node<T>;//生成头结点
	first->next=NULL;//置空
}

3.有参构造函数

1.头插法（倒序）
template <class T>  
LinkList:: LinkList(T a[ ], int n)
{       
    first=new Node<T>;//生成头结点 
    first->next=NULL;   
    Node<T> *s=NULL;
    for (i=0; i<n; i++)
    {
        s=new Node<T>; //生成结点
        s->data=a[i];   //赋初值
        s->next=first->next;   //插在头结点后面     
        first->next=s;
     }
 }
2.尾插法（正序）
template <class T>  
LinkList:: LinkList(T a[ ], int n)
{ 
    first=new Node<T> ; 
    Node<T> *rear=first;//生成指向头结点的尾指针 
    Node<T> *s=NULL;        
    for (i=0; i<n; i++)
    {
        s=new Node<T> ; 
        s->data=a[i];   
        rear->next=s;//插在尾结点后面
        rear=s;       
    }
    rear->next=NULL;     
}

4.插入操作

template <class T>  
 void LinkList::Insert(int i, T x)
 {      
     Node<T> *p=first ;//工作指针  
     Node<T> *s=NULL;
     int count=0;    //计数器
     /*
	第一次循环，工作指针指向第一个元素，count=1，
	当count=i-1时，工作指针指向第i-1个元素，循环结束
	*/
     while (p && count<i-1)//查找第i-1个结点
     {
          p=p->next; 
          count++;
     }
	 if (!p) throw "位置";
   	 else { 
       s=new Node<T>; 
       s->data=x;  
       s->next=p->next;       
       p->next=s;
   }
}

5.删除操作

template <class T>  
T LinkList::Delete(int i)
{
	Node<T> *p=first ; 
	Node<T> *q=NULL ;
	int count=0;  
    while (p && count<i-1) //查找第i-1个结点
    {
         p=p->next;
         count++;
     }
   if (!p | | !p->next) //结点p不存在或其后继不存在
        throw “位置异常”; 
   else {  
         q=p->next; //第i个结点
         T x=q->data;  //暂存被删除结点 
         p->next=q->next; //断开第i个结点，连接第i-1和第i+1个结点  
         delete q; 
         return x;
    }
 }

6.析构函数

template <class T>  
LinkList:: ~LinkList( )
{   
	Node<T> *p=first;
	Node<T> *q=NULL; 
    while (p)//非空时
  {
        q=p;    
        p=p->next;  
        delete q;    
    }
}

7.链表长度

template <typename T>
int LinkList<T>::Length()  
{
    Node<T> *p=first->next;//工作指针初始指向第1个结点
    int count=0;
    while(p)
    {
        p=p->next;
        count++;
    }
    return count;
}

8.查找操作

1.按位查找
template <typename T>
T LinkList<T>::Get(int i)   
{
    Node<T>*p=first->next;
    int count =1;
    while(p&&count<i)
    {
        p=p->next;
        count++;
    }
    if(p==nullptr)
        throw "查找位置错误";
    else
        return p->data;
}
2.按值查找（默认查找第一次出现的）
template <typename T>
int LinkList<T>::Locate(T x) 
{
    Node<T>*p=first->next;
    int count=1;
    while(p!=nullptr)
    {
        if(p->data==x)
            return count;
        p=p->next;
        count++;
    }
    return 0;
}

9.判空操作

template <typename T>
int LinkList<T>::Empty() 
{
    if(first->next==nullptr)
        return 1;
    return 0;
}

10.遍历操作

template<typename T>
void LinkList<T>::PrintList()  
{
    Node <T>*p=first->next;
    while(p!=nullptr)
    {
        cout<<p->data<<'\t';
        p=p->next;
    }
    cout<<endl;
}

三.循环链表（解决前驱问题）

1.插入操作

template <class T>  
 void LinkList::Insert(int i, T x)
 {   
 	 Node<T> *p=first ;
 	 Node<T> *s=NULL;   
     int count=0;    
     while (p->next!=first && count<i-1)
     {
          p=p->next; 
          count++;
     }
	 if (!p) throw "位置";
   	 else { 
       s=new Node<T>; 
       s->data=x;  
       s->next=p->next;       
       p->next=s;
   }
}

2.循环链表合并（加入尾指针）

LinkList<T>   merge _1(LinkList<T> LA, LinkList<T> LB)
{  /* 将两个链表的首尾相连 */ 
     p =new Node<T> ;
     q =new Node<T>; 
     p=LA; 
     q=LB;  
	 while (p->next! =LA)  p=p->next;   /* 找到表LA的表尾， 用p指向它 */
	 while (q->next! =LB)    q=q->next;  /* 找到表LB的表尾， 用q指向它 */       
     q->next=LA;  /* 修改表LB 的尾指针， 使之指向表LA 的头结点 */ 
     p->next=LB->next;  /* 修改表LA的尾指针， 使之指向表LB 中的第一个结点 */
}

四.双向链表（关键语句）

1.结点

template <class T>
struct DulNode
{
     T data;
     DulNode<T> *prior, *next;
};

2.插入操作

//p指向第i-1个结点
s->prior=p;//待插入结点的前驱指向第i-1个结点
s->next=p->next;//待插入结点的后继指向第i个结点
p->next->prior=s;//第i个结点的前驱指向待插入结点
p->next=s;//第i-1个结点的后继指向待插入结点

3.删除操作

//p指向第i个结点
(p->prior)->next=p->next;
(p->next)->prior=p->prior;
delete p;

4.无头结点的双向循环链表的构建

#include <iostream>
using namespace std;
template <typename T>
class Node
{
public:
    T data;
    Node<T> *next,*prior;
};
template <typename T>
class DCirLinkList
{
public:
    DCirLinkList();
    DCirLinkList(T a[],int l);
private:
    Node<T> *door;//进入循环的入口
    int length;
};
template<typename T>
DCirLinkList<T>::DCirLinkList()
{
    door=new Node<T>;
    door=nullptr;
    door->next=door;
    door->prior=door;
    length=0;
}
template<typename T>
DCirLinkList<T>::DCirLinkList(T a[],int l)
{
    length=l;
    door=new Node<T>;
    Node<T> *p=door;
    p->data=a[0];
    for(int i=1;i<l;i++){
        Node<T> *t=new Node<T>;
        t->data=a[i];
        p->next=t;
        t->prior=p;
        p=p->next;
    }
    door->prior=p;
    p->next=door;
}
int main()
{
    int a[5]={1,2,3,4,5};
    DCirLinkList<int> x(a,5);

}

五.终极进阶

#include<iostream>
using namespace std;
template <typename T>
class Node{
public:
    T data;
    Node<T> *next;
};
template <typename T>
class LinkList{
public:
    LinkList();
    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);
    int Empty();
    void PrintList();
private:
    Node<T> *first;

};
template <typename T>
LinkList<T>::LinkList(){
    first=new Node<T>;
    first->next=nullptr;
}
template <typename T>
LinkList<T>::LinkList(T a[],int n){
    first=new Node<T>;
    Node<T> *r=first;
    first->next=nullptr;
    for(int i=0;i<n;i++){
        Node<T> *s=nullptr;
        s=new Node<T>;
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=nullptr;
}
template <typename T>
LinkList<T>::~LinkList(){
    Node<T> *p=first;
    while(first!=nullptr){
        first=first->next;
        delete p;
        p=first;
    }
}
template <typename T>
int LinkList<T>::Length(){
    int count=0;
    Node<T> *p=first->next;
    while(p){
        p=p->next;
        count++;
    }
    return count;
}
template <typename T>
T LinkList<T>::Get(int i){
    Node<T> *p=first->next;
    int count=1;
    while(p&&count<i){
        p=p->next;
        count++;
    }
    if(p==nullptr) throw "查找位置错误";
    else return p->data;
}
template <typename T>
int LinkList<T>::Locate(T x){
    Node<T> *p=first->next;
    int count=1;
    while(p){
        if(p->data==x) return count;
        p=p->next;
        count++;
    }
    return 0;
}
template <typename T>
void LinkList<T>::Insert(int i,T x){
    Node<T> *s=nullptr;
    s=new Node<T>;
    s->data=x;
    Node<T> *p=first;
    int count=0;
    while(p&&count<i-1){
        p=p->next;
        count++;
    }
    if(p==nullptr) throw "插入位置错误";
    else {
        s->next=p->next;
        p->next=s;
    }

}
template <typename T>
T LinkList<T>::Delete(int i){
    T x;
    Node<T> *p=first,*q=nullptr;
    int count=0;
    while(p&&count<i-1){
        p=p->next;
        count++;
    }
    if(!p||!p->next) throw "删除位置错误";
    else {
        q=new Node<T>;
        q=p->next;
        x=q->data;
        p->next=q->next;
        delete q;
        return x;
    }
}
template <typename T>
int LinkList<T>::Empty(){
    if(!first->next) return 1;
    else return 0;
}
template <typename T>
void LinkList<T>::PrintList(){
    Node<T> *p=first->next;
    while(p){
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}
int main(){
    int f[]={1,2,3,4,5,6,7};
    LinkList<int> a(f,7);
    a.PrintList();
    cout<<a.Get(3)<<endl;
    a.PrintList();
    cout<<a.Locate(4)<<endl;
    a.PrintList();
    a.Insert(5,9);
    a.PrintList();
    cout<<a.Delete(3)<<endl;
    a.PrintList();
    cout<<a.Empty()<<endl;
    cout<<a.Length();

#include<iostream>
using namespace std;
const int s=100;
template <typename T>
class SeqList{
public:
    SeqList();
    SeqList(T a[],int n);
    ~SeqList();
    int Length();
    T Get(int i);
    int Locate(T x);
    void Insert(int i,T x);
    T Delete(int i);
    int Empty();
    void PrintList();
private:
    T data[s];
    int length;

};
template <typename T>
SeqList<T>::SeqList(){
    length=0;
}
template <typename T>
SeqList<T>::SeqList(T a[],int n){
    if(n>s) throw "超出最大范围";
    for(int i=0;i<n;i++)
        data[i]=a[i];
    length=n;
}
template <typename T>
SeqList<T>::~SeqList(){}
template <typename T>
int SeqList<T>::Length(){
    return length;
}
template <typename T>
T SeqList<T>::Get(int i){
    if(i>s||i<1) throw "查找未知错误";
    return data[i-1];
}
template <typename T>
int SeqList<T>::Locate(T x){
    for(int i=0;i<length;i++)
        if(data[i]==x) return i+1;
    return 0;
}
template <typename T>
void SeqList<T>::Insert(int i,T x){
    if(length==s) throw "上溢";
    if(i<1||i>length+1) throw "插入位置错误";
    for(int j=length;j>=i;j--)
        data[j]=data[j-1];
    data[i-1]=x;
    length++;
}
template <typename T>
T SeqList<T>::Delete(int i){
    if(length==0) throw "overflow";
    if(i<1||i>length) throw "删除位置错误";
    T x=data[i-1];
    for(int j=i-1;j<length-1;j++)
        data[j]=data[j+1];
    length--;
    return x;
}
template <typename T>
int SeqList<T>::Empty(){
    if(length==0) return 1;
    return 0;
}
template <typename T>
void SeqList<T>::PrintList(){
    for(int i=0;i<length;i++)
        cout<<data[i]<<" ";
    cout<<endl;
}
int main(){
    SeqList<int> a;
    cout<<a.Empty()<<endl;
    a.Insert(1,3);
    cout<<a.Empty()<<endl;
    cout<<a.Get(1)<<endl;
    a.Insert(2,2);
    cout<<a.Locate(2)<<endl;
    a.Insert(3,3);
    a.Insert(4,4);
    a.Delete(3);
    a.PrintList();

}
cure_myheart
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构线性表实验报告
06-20
内涵顺序表和链表及各种功能内涵顺序表和链表及各种功能内涵顺序表和链表及各种功能内涵顺序表和链表及各种功能
数据结构与算法设计#1线性表
yuex666的博客
10-20 181
线性表的定义 表ADT （1）数据元素：单值元素、记录型元素 （2）唯一直接前驱、直接后继。是否按关键字有序排列 （3）操作：生成、清除、查找、插入、删除、排序等 线性表的顺序存储 1. 线性表的顺序存储结构：把线性表的结点一次存储在一组地址连续的存储单元中。 2. 线性表的特点： （1）线性表的逻辑顺序与物理存储顺序一致 （2）相邻元素之间无空隙 （3）已知基地址可以计算任意元素地址 线性表的链式表示和实现 单链表 结点的描述 ...
数据结构——线性表（单链表）
weixin_42823298的博客
09-30 884
单链表是一种链式存取的，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个节点的构成：（元素+指针） 元素就是存储数据的存储单元，指针就是连接每个节点的地址数据。定义：每个结点 除了存放数据元素外，还要存储指向下一个节点的指针；优点：不要求大片连续空间，改变容量方便；缺点：不可随机存取，要耗费一定空间存放指针局限性：无法逆向检索。
数据结构课程设计
wushenghuan的专栏
01-19 5173
首先是心得体会： 老实说做完这个真的是有心无力啊，原本计划使用java来实现的，本人自学了半个学期的java，感觉比学了一年的C语言更加有把握，但是，在java领域不知道如何使用链表的知识来完成通讯录的功能，其实我用java已经完成了该通讯录的功能了，但是不会引用链表的知识，最后只能选择用C++了，但是C++我把握得很不好，理解的还不够透切，原本在java里面我已经弄好界面和插入，登录，显示
数据结构学习总结（二）线性表
逆水行舟
02-02 570
文章目录前言1. 线性表及抽象数据类型1.1 线性表的定义1.2 线性表的抽象数据类型2. 顺序存储结构链式存储结构单链表静态链表循环链表双向链表 舒适的环境很难培养出坚强的品格，被安排好的人生， 也很难做出伟大的事。 前言 线性结构是最简单，也是最常用的数据结构之一。线性结构的特点是：在数据元素的有限集中，除第一个元素无直接前驱，最后一个元素无直接后继以外，每个数据元素有且仅有一个直接前驱元...
数据结构——线性表(选择题).docx
07-11
数据结构——线性表（选择题） 1.线性表是（）。 简单，线性表的概念与性质，02702001 [单选题] A、一个有限序列，可以为空(正确答案) B、一个无限序列，不可以为空 C、一个无限序列，可以为空 D、一个无限序列，不...
数据结构——线性表的实现.zip
09-18
数据结构——线性表的实现，包含链表和数组两种实现方式
数据结构——线性表分享.pdf
01-01
数据结构——线性表分享.pdf
数据结构——线性表类模板
12-19
数据结构——线性表类模板 数据结构——线性表类模板 数据结构——线性表类模板
算法与数据结构二(数据结构——线性表).doc
10-10
算法与数据结构二(数据结构——线性表).doc
数据结构实验——线性表子系统
07-31
用结构体描述一个字符型的单链表；创建线性表；在线性表中插入元素、删除元素、显示线性表中所有元素。
数据结构——线性表详细介绍（C)
07-12
[数据结构案例教程(c语言版)].徐翠霞.文字版.pdf 第一章内容 介绍了线性表的逻辑结构，各种存储表示方法，相关算法，代码等
数据结构——线性表操作
09-27
数据结构里面的线性表，线性表的基本操作。对于学习数据结构有一定的帮助！
数据结构——线性表顺序存储结构（C++代码）
09-28
简单的线性表顺序存储的示例，代码主要完成在顺序存储中的插入及删除元素的操作。 本程序在VS2008下编译通过
线性表基础（一）
菜鸟本菜的博客
10-27 184
线性表（ Linear List ）的定义 是零个或多个具有相同类型的数据元素的有限序列。 数据元素的个数定义为线性表的长度长度等于零时称为空表，一个非空表通常记为 L ＝ ( a 1 ， a 2 ，……， a n ) 其中， ai（ 1 ≤ i ≤ n ）称为数据元素，下标 i 表示该元素在线性表中的位置或序号，称元素 a i 位于表的第 i 个位置，或称 a i 是表中的第 i 个元素。...
【线性表】【线性表的抽象类形式】【无需创建表的操作——利用构造函数】【纯虚析构函数的作用——解决内存泄漏】
不再痛苦的秘密，你找到了吗
04-29 157
【线性表的抽象类形式】 把每一个操作都定义成一个纯虚函数，如果该类派生出一个类时，那么要重写这些纯虚函数；如果不重新定义这些纯虚函数，这些纯虚函数就留在了派生类中，那么派生类也变成了一个抽象类，不能真正使用。 先放代码如下： template<class elemType> class list { public: virtual void clear() = 0;//清除 virtual int length() const = 0;//长度 virtual...
C++实现向量构造的线性表
Jeff_Winger的博客
10-21 439
#include #include//copy，copy_backward函数 #include //ostringstream #include //字符串 #include//异常处理 #include //ostream_iterator输出流 #include//vector线性表 using namespace::std; //异常类 class illegalParameterVal
线性表（c++描述）
photoresist的博客
02-26 281
线性表（c++描述） 最近学了c++，把数据结构用c++再写一遍，加深一下对c++语法的理解 学习c++本来是想利用他的库，节省一下写算法的时间，c语言这种面向过程语言对每个数据结构都要再写一遍，或者因为数据类型，再修改一遍，复用性有比较大的局限性。写了一点线性表的算法后，发现c++的多态性确实很好用，模板类可以很轻松的应用于多种数据类型，但是，对于简单的题目来说，代码有些繁琐，特别是对抽象类的继承，顺序表需要继承这个纯虚函数，但链表不需要，有时候就有点头疼。 另外，吐槽下清华大学出版社的数据结构（c++）
数据结构中的线性表笔记
最新发布
08-20
- *1* *3* [数据结构——线性表](https://blog.csdn.net/qq_40479037/article/details/126435332)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值