链表实现（线性，链表）

最新推荐文章于 2024-08-30 23:27:16 发布
最新推荐文章于 2024-08-30 23:27:16 发布
阅读量633 收藏
点赞数
分类专栏： 数据结构 C++ 文章标签： list null output delete class 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jpday/article/details/8065907
版权

//顺序线性表
/*#include<iostream>
using namespace std;
#define Virtuallength 100
#define AddspaceList 50
#define TRUE 1
#define ERROR 0

class List
{
private:
 int *item;
 int length;
 int MAXlength;
public:
 int InitList(int n=Virtuallength)
 {
  item=new int [n];
  if(item==NULL) return ERROR;
        length=0;
  MAXlength=n>Virtuallength?n:Virtuallength;
  return TRUE;
 }
 void DestroyList()   //删除
 {
  if(item)
   delete [] item;
 }
 void output()     //输出线性表
 {
  if(length==0)
  {
   cout<<"The List is null "<<endl;
   return ;
  }
  cout<<"The length of the List is "<<length<<endl;
  cout<<"The content of the the List is ";
  for(int i=0;i<length;i++)
   cout<<item[i]<<" ";
  cout<<endl;
 }
   int Getlength()   //计算线性表的长度
   {
    return length;
   }
   int IsEmpty()   //判断是否为空
   {
    if(length==0)
    {
     return ERROR;
    }
    else
    {
     return TRUE;
    }
   }
   int ListInser(int i,int e)  //在第i个数前面插入元素e
   {
    if(length==MAXlength)
    {
     return ERROR;
    }
    if((i<1)||(i>length+1))
    {
     return ERROR;
    }
    for(int j=length-1;j>=i-1;j--)
     item[j+1]=item[j];  //数组还是从0开始
    item[i-1]=e;
    length++;
    return 0;
   }
   int ListDelete(int i,int &e)  //删除第i个元素
   {
    if(!IsEmpty())
    {
     return ERROR;
    }
    if((i<1)||(i>length))
    {
     return ERROR;
    }
    e=item[i-1];//因为这里是把item[i-1]给删除了，是把前面一个数字删除，所以i>0才满足
    for(int j=i-1;j<length-1;j++)
     item[j]=item[j+1];//for(int j=i;j<=length-1;j++)item[j-1]=item[j];   
    length--;
    return TRUE;
   }
   int addspace()    //增加线性表的空间，扩大存储
   {
    cout<<"每一次调用扩大空间的函数所增加的空间为:"<<AddspaceList<<endl;
    if(length>MAXlength)
    {
    item=(int *)realloc(item,AddspaceList+MAXlength);//使用了动态分配空间的函数
    }
    if(item==NULL)return ERROR;
  MAXlength=MAXlength+AddspaceList;

    return TRUE;
   }
   int judgespace()
   {
     double s;
 cout<<"最大长度为:"<<MAXlength<<endl;
 cout<<"实际长度为:"<<length<<endl;
 s=length*1.0/MAXlength*100;
 cout<<"实际长度占最大长度的:"<<s<<'%'<<endl;
 return TRUE;
   }
};
int main()
{
 List list;
 int i,s;
 list.InitList(500);
 list.output();
 list.DestroyList();
 list.InitList(100);
 list.output();
 for(i=0;i<10;i++)  //因为实在线性表中数据的前面插入的
 list.ListInser(list.Getlength()+1,i);
 list.output();
 for(i=2;i<=list.Getlength()+1;i++)//0 2 4 6 8 9
    list.ListDelete(i,s);
 list.output();
 list.addspace();
 list.judgespace();
 return 0;
}*/
/*#include<iostream>
using namespace std;
#define Virtuallength 100
#define AddspaceList 50
#define TRUE 1
#define ERROR 0

class List
{
private:
 int *item;
 int length;
 int MAXlength;
public:
 int InitList(int n=Virtuallength)
 {
  item=new int [n];
  if(item==NULL) return ERROR;
        length=0;
  MAXlength=n>Virtuallength?n:Virtuallength;
  return TRUE;
 }
 void DestroyList()   //删除
 {
  if(item)
   delete [] item;
 }
 void output()     //输出线性表
 {
  if(length==0)
  {
   cout<<"The List is null "<<endl;
   return ;
  }
  cout<<"The length of the List is "<<length<<endl;
  cout<<"The content of the the List is ";
  for(int i=0;i<length;i++)
   cout<<item[i]<<" ";
  cout<<endl;
 }
   int Getlength()   //计算线性表的长度
   {
    return length;
   }
   int IsEmpty()   //判断是否为空
   {
    if(length==0)
    {
     return ERROR;
    }
    else
    {
     return TRUE;
    }
   }
   int ListInser(int i,int e)  //在第i个数前面插入元素e
   {
    if(length==MAXlength)
    {
     return ERROR;
    }
    if((i<1)||(i>length+1))
    {
     return ERROR;
    }
    for(int j=length-1;j>=i-1;j--)
     item[j+1]=item[j];  //数组还是从0开始
    item[i-1]=e;
    length++;
    return 0;
   }
   int ListDelete(int i,int &e)  //删除第i个元素
   {
    if(!IsEmpty())
    {
     return ERROR;
    }
    if((i<1)||(i>length))
    {
     return ERROR;
    }
    e=item[i-1];//因为这里是把item[i-1]给删除了，是把前面一个数字删除，所以i>0才满足
    for(int j=i-1;j<length-1;j++)//注意要删除最后一个数，所以要减1
     item[j]=item[j+1];
    length--;
    return TRUE;
   }
   int addspace()    //增加线性表的空间，扩大存储
   {
    cout<<"每一次调用扩大空间的函数所增加的空间为:"<<AddspaceList<<endl;
    if(length>MAXlength)
    {
    item=(int *)realloc(item,AddspaceList+MAXlength);//使用了动态分配空间的函数
    }
    if(item==NULL)return ERROR;
  MAXlength=MAXlength+AddspaceList;

    return TRUE;
   }
   int judgespace()
   {
     double s;
 cout<<"最大长度为:"<<MAXlength<<endl;
 cout<<"实际长度为:"<<length<<endl;
 s=length*1.0/MAXlength*100;
 cout<<"实际长度占最大长度的:"<<s<<'%'<<endl;
 return TRUE;
   }
};
int main()
{
 List list;
 int i,s;
 list.InitList(500);
 list.output();
 list.DestroyList();
 list.InitList(100);
 list.output();
 for(i=0;i<10;i++)  //因为实在线性表中数据的前面插入的
 list.ListInser(list.Getlength()+1,i);
 list.output();
 for(i=2;i<=list.Getlength();i++)//删除最后一个数，所以要=
    list.ListDelete(i,s);//0 2 4 6 8 9
 list.output();
 list.addspace();
 list.judgespace();
 return 0;
}*/

//线性表的链式存储
/*#include<iostream>
#define TRUE 1  //执行完成的返回值
#define ERROR 0 //执行异常的返回值
using namespace std;

struct A
 {
  int data;
  A *next;
 };

class Linklist
{
 private:
  A *head;
  int length;
 public:
  int Initlist()  //初始化私有数据
  {
   head=new A;  //指向头结点
   if(head==NULL)return ERROR;//检验是否开辟成功
   head->next=NULL;
   length=0;
   return TRUE;
  }
  void Destorylist()  //销毁，对于每一个节点的删除
  {
   int i;
   A *temp;
   for(i=0;i<length+1;i++)//因为要销毁所有数据，则必须改变头指针的指向
   {//为0是因为把头结点算了进去
    temp=head;//必须用temp保存head的指向
    head=head->next;
    delete temp;
   }
  }
  void output()  //链表的输出
  {
   if(length==0)
   {
   cout<<"当前链表为空"<<endl;
   return;
   }
   cout<<"当前链表长度为:"<<length<<endl;
   cout<<"链表的内容为:";
   A *temp=head->next;
   for(int i=0;i<length;i++) //从第一个节点开始
   {
    cout<<temp->data<<" ";
    temp=temp->next;
   }
   cout<<endl;
  }
  int Listlength() //测长度
  {
   return length;
  }
  int Insert(int s,int n) //插入数据，s表示在第s个前面插入，n表示插入的数据
  {
   if(s<1||s>length+1) return ERROR;//判断插入数据是否超出了长度
   A *t=new A;//开辟一个结构t存数据n
   if(t==NULL)return ERROR;
   t->data=n;
   A *p=head;//不能让它只想head-next，因为有可能在第一个数据的前面插入,
   int i;
   for(i=0;i<s-1;i++)//当链表中没有数据，则不执行循环
    p=p->next;
    t->next=p->next;
    p->next=t;
    length++;
    return TRUE;
  }
  int Listdelete(int s,int n)//删除第s个数据，并把数据保存在n中
  {
   if(length==0){cout<<"当前链表为空，不能删除!"<<endl;return ERROR;}
   if(s<1||s>length)return ERROR;
   A *p=head;
   int i;
   for(i=0;i<s-1;i++)
    p=p->next;//p指向要删除数据的前一个
   A *t=p->next;//t指向要删除的数据
    n=t->data;
    p->next=p->next->next;
    delete t;
    length--;
    return n;
  }
};
int main()
{
 Linklist a;
 a.Initlist();
 a.output();
 for(int i=1;i<=10;i++)  //i从0开始时，则输出偶数时则要注意前面要连续删除两个0和1
  a.Insert(a.Listlength()+1,i);
 a.output();
 int s;
 cout<<"删除的数据为:";
 for(i=1;i<a.Listlength()+1;i++)
 {
   s=a.Listdelete(i,s);
   cout<<s<<" ";
 }
 cout<<endl;
 a.output();
 return 0;
}*/

//两个非递减集合的合并
/*#include<iostream>
using namespace std;
#define Virtuallength 100
#define AddspaceList 50
#define TRUE 1
#define ERROR 0

class List
{
private:
 int *item;
 int length;
 int MAXlength;
public:
 int InitList(int n=Virtuallength)
 {
  item=new int [n];
  if(item==NULL) return ERROR;
        length=0;
  MAXlength=n>Virtuallength?n:Virtuallength;
  return TRUE;
 }

 void DestroyList()   //删除
 {
  if(item)
   delete [] item;
 }

 void output()     //输出线性表
 {
  if(length==0)
  {
   cout<<"The List is null "<<endl;
   return ;
  }
  cout<<"The length of the List is "<<length<<endl;
  cout<<"The content of the the List is ";
  for(int i=0;i<length;i++)
   cout<<item[i]<<" ";
  cout<<endl;
 }

   int Getlength()   //计算线性表的长度
   {
    return length;
   }

   int IsEmpty()   //判断是否为空
   {
    if(length==0)
    {
     return ERROR;
    }
    else
    {
     return TRUE;
    }
   }

   int ListInser(int i,int e)  //???在第i个数前面插入元素e
   {
    if(length==MAXlength)
    {
     return ERROR;
    }
    if((i<1)||(i>length+1))
    {
     return ERROR;
    }
    if(length+1>MAXlength)
    {
    addspace();
    judgespace();
    }
    for(int j=length-1;j>=i-1;j--)//当length=0的时候，根本就没有执行该语句，且i必须=1才满足条件
     item[j+1]=item[j];
    item[i-1]=e;
    length++;
    return 0;
   }

   int ListDelete(int i,int &e)  //删除第i个元素
   {
    if(!IsEmpty())
    {
     return ERROR;
    }
    if((i<1)||(i>=length))
    {
     return ERROR;
    }
    e=item[i-1];//因为这里是把item[i-1]给删除了，是把前面一个数字删除，所以i>0才满足
    for(int j=i-1;j<length;j++)
     item[j-1]=item[j];
    length--;
    return TRUE;
   }

   int addspace()    //增加线性表的空间，扩大存储
   {
    cout<<"每一次调用扩大空间的函数所增加的空间为:"<<AddspaceList<<endl;
    item=(int *)realloc(item,AddspaceList+MAXlength);//使用了动态分配空间的函数
    if(item==NULL)return ERROR;
  MAXlength=MAXlength+AddspaceList;
    return TRUE;
   }

   //int addspace()    //增加线性表的空间，扩大存储
   //{
 //   cout<<"每一次调用扩大空间的函数所增加的空间为:"<<AddspaceList<<endl;
 //   if(length>MAXlength)
 //   {
 //   item=(int *)realloc(item,AddspaceList+MAXlength);//使用了动态分配空间的函数
   // }
   // if(item==NULL)return ERROR;
 // MAXlength=MAXlength+AddspaceList;
  //  return TRUE;
   //}

   int judgespace()
   {
     double s;
 cout<<"最大长度为:"<<MAXlength<<endl;
 cout<<"实际长度为:"<<length<<endl;
 s=length*1.0/MAXlength*100;
 cout<<"实际长度占最大长度的:"<<s<<'%'<<endl;
 return TRUE;
   }
   friend int together(List la,List lb,List &lc);
 };

 int together(List la,List lb,List &lc)
   {
    lc.InitList(la.Getlength()+lb.Getlength());//分配空间
    int *pa,*pb,*p1,*p2,*p3;
    pa=la.item+la.length-1;
    pb=lb.item+lb.length-1;
    p1=la.item;              //必须把a，b，c三个链表的初始链表先存放起来
    p2=lb.item;
    p3=lc.item;
    while((p1<=pa)&&(p2<=pb))  //必须要考虑相同的情况
    {

     if(*p1<*p2)
     {
      *p3=*p1;
      p3++;
      p1++;
     }     
     else
      if(*p1>*p2)
    {
     *p3=*p2;
     p3++;
     p2++;
    }
      else
      {
       *p3=*p2;
       p3++;
       p2++;
       p1++;
      }
  lc.length++;  //lc的长度还没有赋初值,必须要把lc的长度每个都加1   
    }
    while(p1<=pa)
    {
     *p3=*p1;
   p3++;
   p1++;
   lc.length++;
    }
    while(p2<=pb)
    {
     *p3=*p2;
   p3++;
   p2++;
   lc.length++;
    }
    return 0;
   }

int main()
{
 List a,b,c;int i;
 a.InitList(100);//初始化数组并分配空间
 b.InitList(100);
 for(i=0;i<5;i++)
 {
  a.ListInser(a.Getlength()+1,i);
  b.ListInser(b.Getlength()+1,i*i);
 }
    together(a,b,c);
 a.output();
 a.judgespace();
 b.output();
 b.judgespace();
 c.output();
 c.judgespace();
 c.addspace();
 cout<<"对c扩大空间后的空间计算:"<<endl;
 c.judgespace();
 return 0;
}*/

 

 

JPDAYSUNDAY
关注
专栏目录
C语言来实现链表创建
xinzhilinger的博客
10-11 3万+
前言 链表是数据结构中很重要的内容，要想学会数据结构，首先要了解链表 链表的基本知识 1，链表的构成 链表是由一个头指针和一个个节点构成的，如图： 而节点则是一个个结构体，包含数据域和指针域两部分，其中，指针域存储的是指向下一个节点的指针 2，对于链表的操作 1，创建链表 2，初始化链表 3，遍历链表 4，对于链表进行增删查等操作 C语言对于链表的代码的实现 1，创建结构体并命名 创建链表前需要先创建结构体作为节点和头指针： typedef struct Node //typedef方法函数可以对于st
实验项目1-2 链表实现线性表表的操作.cpp
04-01
实验项目1-2 链表实现线性表表的操作.cpp
C语言链表超详解
热门推荐
k666499436的博客
05-17 12万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
c++实现单向链表
henjdx的博客
03-26 1125
单向链表属于链表中的一类，链表是用于数据元素的线性集合，其中每个元素都指向下一个元素，元素存储上并不连续。单向链表的特性是每个元素只知道其下一个元素是谁。
JS实现链表
最新发布
qq_65665724的博客
08-30 1062
数组是若干个元素按照顺序排列存放的一个集合，并且每个元素至少存在一个索引(index)或者关键字(key)所标识，每个元素的位置都可以通过计算索引拿到为什么说每个元素至少有一个索引呢，那是因为数组可以是多维度的但是我们在日常工作中一般常用的是一维数组，也可以称之为线性数组一维数组：[1,2,3];//数组的每一个元素是一个数据类型二维数组：[["a","b","c"],[1,2,3],123];//数组的每一个元素是一个一维数组。
线性结构-链表
m0_51274562的博客
08-09 938
在链表中，通常会添加一个不存储数据的节点，就是空节点，作为链表的第一个节点，之后的元素节 点，从第二个开始，操作链表就不会操作到第一个节点，方便链表的操作。除此之外还有循环链表，其差别是其最后一个元素指向的是头节点。数据元素之间的位置是任意（需要有这个元素才创建申请空间），在一个数据元素中由两部分构成，数据。关系：通过指针元素来表示，存储下一个数据元素的地址。第一个数据节点，存储数据的元素节点，叫做首元素节点。链表的一个数据元素就叫做一个节点（数据、关系）关系：前一个元素的地址，以及后一个元素的地址。...
线性链表
Carlo666的博客
10-10 3756
线性链表  采用链式存储的线性表 存储特点：每个结点都分两部分  数据域：存储元素的值  指针域：存放直接前趋或直接后继元素的地址信息 链表的存储结构 链表的定义和初始化 struct LNode { ElemType data; // 数据域，ElemType代表某种数据类型 struct LNode *next; // 指针域 } ; LNode* head; // 定义头指针 ...
多项式加法运算（链表实现）
2021dragon的博客
04-24 1万+
文章目录创建结点类型打印多项式尾插选择排序多项式相加代码总览 + 结果展示 创建结点类型 我们用链表存储一个多项式，那么该链表的每一个结点就代表多项式的某一项。所以我们的每一个结点必须包含三个信息：多项式的系数、多项式的指数以及指向下一个结点的指针。 typedef int SLTDataType;//指数、系数类型 typedef struct SListNode { SLTDataType coef;//系数 SLTDataType expon;//指数 struct SListNode* ne
线性表——链表
weixin_46640900的博客
06-30 2667
顺序表和链表都是线性表的一种。但链表与顺序表不同的是，他的物理上与逻辑上的机构并不一致。 顺序表的话，逻辑相邻，物理上也是相邻的。所以对于一整块连续的物理地址，当我们进行插入和删除操作的时候就会需要大量的移动元素。 而链表不需要使用地址连续的存储单元，即不需要满足物理与逻辑一致，通过"链"建立数据之间的逻辑关系，当进行插入或删除操作的时候，只需要修改指针即可。线性表的链式存储为单链表，通过任意一组存储单元来存储数据。链表通过许多节点构成，节点除了放自身的数据还有存放下一个节点的地址来保证链表的逻辑关系。而链
学生成绩管理系统_链表实现
weixin_63125497的博客
07-01 6397
实验:学生成绩管理，C语言实现，采用链表完成。编写程序完成对学生成绩的管理，要求实现的功能包括(以下功能分函数完成): 1、学生信息录入:从键盘按学号顺序输入 N名学生信息(学号、姓名和成绩) 2、学生信息输出:输出学生的信息 3、学生信息排序:按照成绩从低到高的顺序对录入的学生信息排序 4、学生信息查询:按照输入的学号查找并输出对应学生的信息 5、学生信息插入:按给定信息将学生信息插入到指定位置 6、学生信息删除:删除给定学生的信息 7、学生成绩统计:按分数段统计学生信息采用结构体数组完成。目录对存...
链表实现学生信息管理系统
small__fat的博客
09-14 7623
用链表来实现学生成绩管理 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式
基于C语言的超市商品管理系统链表实现实验报告.pdf
05-29
基于C语言的超市商品管理系统链表实现实验报告.pdf 本实验报告主要讲解了基于C语言的超市商品管理系统链表实现，涵盖了结构体的定义和使用方法、单链表的定义和使用方法、链表节点的查找与删除、输出单链表节点的...
线性链表的实现
03-06
具有链接存储结构的线性表，它用一组地址任意的存储单元存放线性表中的数据元素，逻辑上相邻的元素在物理上不要求也相邻，不能随机存取。一般用结点描述：结点（表示数据元素） =数据域（数据元素的映象） + 指针域...
用数据结构-链表实现通讯录管理系统
04-12
本项目以"用数据结构-链表实现通讯录管理系统"为主题，通过C语言实现了这一功能，旨在帮助用户管理他们的联系人信息。下面我们将深入探讨这个系统所涉及的主要知识点。 首先，我们来了解**链表**这一数据结构。链表...
链表-使用Python基于链表实现数组栈.zip
03-13
在Python中，我们可以直接使用列表来实现栈，但由于列表内部实现为动态数组，对于频繁的尾部操作（如push和pop），效率可能不如专门的链表实现。因此，题目中提到的“链表-使用Python基于链表实现数组栈”就是将栈的...
c++中有个清屏函数，system（“cls”）
Jpday的专栏
09-22 3万+
#include using namespace std; void max(int &x,int &y) {int a;  cout  int t;  t=x;  x=y;  y=t;  cin>>a;  cout  system("cls"); } int main() {  int a,b;  cin>>a>>b;  cout  system("cls")
C++ COLOR和COLORREF之间的相互转换
Jpday的专栏
12-30 1万+
由于在GDI+中使用的是画笔工具是Pen，不是CPen，颜色参数也是COLOR或画刷（必须在构造函数进行初始化，本身是一个带有参数的类）而不是COLORREF，必须发生转换 1.COLOR------COLORREF Color c; m_bBrush.GetColor(c); COLORREF color=RGB(c.GetR(),c.GetG(),c.GetB());
图结构的应用：教学计划编制问题
Jpday的专栏
05-01 1万+
有两种方法：一种没有学分排序，另一种考虑了学分排序，较推荐栈中排好序的方法，贪心更完全测试数据文本：C1 程序设计基础 # 2 C2 离散数学 C1 3 C3 数据结构 C1,C2 4 C4 汇编语言 C1 3 C5 语言的设计和分析 C3,C4 2 C6 计算机原理 C11 3 C7 编译原理 C3,C5 4 C8 操作系统 C3,C6 4 C9 高等数学 # 7 C10 线
C++ 判断主机是否处于联网状态下
Jpday的专栏
07-15 9644
直接让本机访问一个网站，如果成功的话，就说明成功联网，没有访问成功，则说明没有联网！！！#include #include #pragma comment(lib,"ws2_32.lib") #define LEN 1024 //接收数据的大小 using namespace std; int main() { //加载套接字库 WORD wVersionReques
C语言实现线性链表操作详解
本文主要介绍了线性链表的概念和C语言中实现线性链表的基本操作，包括makefile、List.h头文件以及List.c的源代码实现。 在数据结构中，线性链表是一种非顺序存储结构，它通过节点间的指针链接来表示元素之间的顺序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值