数据结构与算法 线性表

最新推荐文章于 2024-07-24 19:35:30 发布
最新推荐文章于 2024-07-24 19:35:30 发布
阅读量207 收藏
点赞数 1
分类专栏： 笔记 文章标签： 数据结构 指针 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/printf_umut/article/details/115740464
版权

线性表

线性表的定义：
  • 由n(n≥0)个数据元素(a1,a2,…, an)构成的有限序列。
  • 记作: L=(a1,a2,…,an)
    a i-1是ai的直接前驱 ai+1是a i的直接后继
    a1 ──首元素 - 其没有前驱
    an──尾元素 - 其没有后继
  • 表长：线性表中元素的个数
  • 空表：不含元素的线性表
线性表的基本操作：
  1.InitList(&L)            //构造空表L。
  2.LengthList(L)          //求表L的长度
  3.GetElem(L,i,&e)        //取元素ai,由e返回ai
  4.PriorElem(L,ce,&pre_e) //求ce的前驱,由pre_e返回
  5.InsertElem(&L,i,e)     //在元素ai之前插入新元素e
  6.DeleteElem(&L,i)       //删除第i个元素
  7.EmptyList(L)           //判断L是否为空表
线性表的选择及算法：
  • 例一：顺序表的插入操作
    设 L.elem[0…maxleng-1]中有length个元素，在 L.elem[i-1]之前插入新元素e，(1<=i<=length+1)
  1. 算法一 ：用指针指向被操作的线性表,静态分配
 #define maxleng 100
 typedef struct     
   { ElemType elem[maxleng]；//下标:0,1,...,maxleng-1
     int length；            //表长
    } SqList；
   SqList L；
  
   int Insert1(SqList *L,int i,ElemType e)
   { if (i<1||i>L->length+1) return ERROR     //i值不合法
     if (L->length>=maxleng) return OVERFLOW  //溢出
     for (j=L->length-1；j>=i-1；j--；)  //先移动后面元素（直到移完第i-1个元素）
         L->elem[j+1]=L->elem[j]； //向后移动元素
     L->elem[i-1]=e；              //插入新元素
     L->length++；                 //长度变量增1 
     return OK;                     //插入成功
    }

过程如图示：
在这里插入图片描述

  1. 算法二：用引用参数表示被操作的线性表,静态分配
//L的定义同上
Status Insert2(SqList &L,int i,ElemType e)  //此处的L不再是指针
   { if (i<1||i>L.length+1) return ERROR     //i值不合法
     if (L.length>=maxleng) return OVERFLOW  //溢出
     for (j=L.length-1；j>=i-1；j--；)  
         L.elem[j+1]=L.elem[j]；      //向后移动元素
     L.elem[i-1]=e；                  //插入新元素
     L.length++；                     //长度变量增1 
     return OK                        //插入成功
    }    //总结：及将‘*L’、‘->’改为‘&L’、‘.’
  1. 算法三：用引用参数表示被操作的线性表，动态分配
#define LIST_INIT_SIZE 100 //初始长度
#define LISTINCREMENT 10 //增量
typedef struct     
   { ElemType *elem；//存储空间基地址
     int length；    //表长
     int listsize;   //当前分配的存储容量
                     //（以sizeof(ElemType)为单位
    } SqList；
    SqList L；

 int Insert3(SqList &L,int i, ElemType e)
  {int j;
   if (i<1 || i>L.length+1)     //i的合法取值为1至n+1
          return ERROR; 
   if (L.length>=L.listsize)    /*溢出时扩充*/
	  { 
     ElemType *newbase;
     newbase=(ElemType *) realloc(L.elem,
		(L.listsize+LISTINCREMENT)*sizeof(ElemType));
	  if (newbase==NULL) return OVERFLOW;   //系统空间已满，扩充失败
     L.elem=newbase; //更新线性表
     L.listsize+=LISTINCREMENT; //更新当前长度
	  }
	  //向后移动元素，空出第i个元素的分量elem[i-1]
for(j=L.length-1;j>=i-1;j--)
	L.elem[j+1]=L.elem[j];
L.elem[i-1]=e;                   /*新元素插入*/
L.length++;                      /*线性表长度加1*/
return OK; //同静态分配
}
  • realloc函数
    • 用法：指针名=（数据类型*）realloc（要改变内存大小的指针名，新的大小）。其中-新的大小可大可小（如果新的大小大于原内存大小，则新分配部分不会被初始化；如果新的大小小于原内存大小，可能会导致数据丢失）
    • 头文件：#include <stdlib.h> 有些编译器需要#include <malloc.h>，在TC2.0中可以使用alloc.h头文件
    • 返回值：如果重新分配成功则返回指向被分配内存的指针，否则返回空指针NULL。
    • 注：不用时需要free

关于顺序结构的评价：

  • 优点：
    (1)是一种随机存取结构，存取任何元素的时间是一个
    常数，速度快；
    (2)结构简单，逻辑上相邻的元素在物理上也是相邻的；
    (3)不使用指针，节省存储空间。
  • 缺点：
    (1)插入和删除元素要移动大量元素，消耗大量时间；
    (2)需要一个连续的存储空间；
    (3)插入元素可能发生“溢出”；
    (4)自由区中的存储空间不能被其它数据占用(共享)。

线性表的链式存储结构

1.单链表：

  • 1)不带表头结点的单链表：
    在这里插入图片描述
  • 带表头结点的单链表：（默认类型）
    在这里插入图片描述
单链表的定义：
struct node  //也可用typedef
       { ElemType data；     //data为抽象元素类型
         struct node *next； //next为指针类型 
        }；
     指向结点的指针变量head,p,q说明:
      struct node *head,*p,*q；
 生成单链表：
  1.后进先出表：（head后插入）
    head=malloc(sizeof(struct node)) //前面也可无强制类型转换，等式会自动转换成左侧数据类型
      tail=head
    p1=malloc(sizeof(struct node))
      tail->next=p1  //可以结合scanf函数 给p的data域赋值 
      tail=p1
    p2=malloc(sizeof(struct node))
      tail->next=p2  //也可不用tail 写成p1->next=p2
      tail=p2
      ..........
      tail->next=NULL;   //or pn=NULL
  2.先进后出表：（head前插入）
   head=(struct node *)malloc(LENG)； //生成表头结点
     head->next=NULL；                  //置为空表             
   p=(struct node *)malloc(LENG)；//生成新结点
      scanf(“%d”,&e)；
     p->data=e；                   //输入数送新结点的data
     p->next=head->next；     //新结点指针指向原首结点
     head->next=p；           //表头结点的指针指向新结点
      scanf(“%d”,&e)；          //再输入一个数
  		return head；               //返回头指针
     }
各类基本操作：
1.插入：
f=(struct node *)malloc(LENG)； //生成
 f->data=x；                      //装入元素x
 f->next=p->next；                //新结点指向p的后继
 p->next=f；                      //新结点成为p的后继
2.删除：
  q->next=p->next；
  free(p)；
  • 已基本操作为基础的功能实现
    • 例：假定有一个无表头结点的递增排序的链表，插入一个新结点，使其仍然递增。
  • 算法1：生成不带头结点的递增有序单链表：① 空表插入；② 尾部插入；③ 首部插入；④ 一般插入。
struct node * creat3_1(struct node *head，int e) 
{ q=NULL； p=head；                  //q,p指针(不是节点)去扫描,查找插入位置
  while (p && e>p->data)             //未扫描完,且e大于当前结点
   { q=p； p=p->next；}              //q,p后移,查下一个位置
  f=(struct node *)malloc(LENG)；    //生成新结点
  f->data=e；                        //装入元素e
  if (p==NULL){    
              f->next=NULL;
              if  (q==NULL)           //(1)对空表的插入
                    head=f; 
              else  q->next=f;}       //(2)作为最后一个结点插入
  else  if (q==NULL)                  //(3)作为第一个结点插入
          {f->next=p;  head=f;}
        else
          {f->next=p； q->next=f；}   //(4)一般情况插入新结点
  return head; }

在这里插入图片描述

  • 算法2：生成带头结点的递增有序单链表
此时q不可能为空 省去算法1中关于q的if语句
void creat3_2(struct node *head，int e) 
{ q=head；
  p=head->next；         //q,p扫描,查找插入位置
  while (p && e>p->data) //未扫描完,且e大于当前结点
   { q=p；
     p=p->next；         //q,p后移,查下一个位置
    }
  f=(struct node *)malloc(LENG)； //生成新结点
  f->data=e；                     //装入元素e
  f->next=p； q->next=f； //插入新结点
  //此处同时包含(2)作为最后一个结点插入 因为语句f->next=p 不影响结果
   }  可见 加头节点是明智的！（一般链表都默认拥有）
  • 算法3：在单链表的指定位置插入新元素（指定位置-不用pq定位）
    也不用考虑首位插入之类 f->next=p->next； p->next=f； 可包含全部
int insert( Linklist &L，int i, ElemType e) 
  {p=L；
   j=1;
   while (p && j<i)    
      {  p=p->next；   //p后移,指向下一个位置
         j++；}
   if (i<1 || p==NULL)           //插入点错误
		return ERROR;
   f=(LinkList) malloc(LENG)；   //生成新结点
   f->data=e；                   //装入元素e
   f->next=p->next； p->next=f； //插入新结点
   return OK;
  }
  • 例：在单链表中删除一个结点
    • 算法1：在带表头结点的单链表中删除元素值为e的结点(可有多个)
int Delete1(Linklist head, ElemType e) 
  { struct node *q,*p;
    int result=Yes； 
    q=head； p=head->next； //q,p扫描  
    while(p)
	 { 
       while(p&&p->data!=e) //查找元素为e的结点
       {   
	       q=p；                //记住可能要删元素的前一个结点p
   	       p=p->next；          //查找下一个结点
       }
       if (p)                //有元素为e的结点
       { 
          q->next=p->next；  //删除该结点
          free(p)；          //释放结点所占的空间
          p=q->next;	     //p指向下一个结点
          result=Yes;
       } 
	 }
    return result;
  • 算法2：在单链表中删除指定位置的元素
int Delete2( Linklist &L，int i,ElemType &e) 
  {p=L；
   j=1;
   while (p->next && j<i)     //循环结束时p不可能为空
      {  p=p->next；          //p后移,指向下一个位置
         j++；}
   if (i<1 || p->next==NULL)     //删除点错误
		return ERROR;
   q=p->next；                  //q指向删除结点 用于free
   p->next=q->next；            //从链表中摘出
   e=q->data;                   //取走数据元素值 记录
   free(q)；                    //释放结点空间
   return OK;
  }

关于单链表评价：

  • 优点：
    • 找出节点后，插入和删除元素相对于顺序表更快
    • 不需要预分配空间，元素个数不受限制
  • 缺点：
    • 查找某一结点的数据元素相比顺序表更慢

2.静态链表：

  • 及用数组描述的链表
    在这里插入图片描述
typedef struct  //静态链表的定义
{
  int data; //静态链表节点中的数据
  int cur;   //静态链表节点中的游标
}component;
  component a[100];

关于静态链表的评价：

  • 优点
    • 在插入和删除操作肘,只需要修改游标,不需要移动元素,从而改进了在顺序存储结构中的插入和删除操作需要移动大量元素的缺点
  • 缺点
    • 没有解决连续存储分配(数组)带来的表长难以确定的问题。
    • 失去了顺序存储结构随机存取的特性。

循环链表：

  1. 带表头结点的非空循环单链表
    在这里插入图片描述

  2. 带表头结点的空循环单链表
    在这里插入图片描述

  3. 只设尾指针的循环链表
    在这里插入图片描述

  4. 只设尾指针的循环空表
    在这里插入图片描述

  • 使用循环链表时，也比较提倡使用尾指针。可节省一些操作（如：两循环链表首位相连）中找到尾节点的时间，从而减少时间复杂度。
  • 循环链表的一些算法：
    • 求以head为头指针的循环单链表的长度,并依次输出结点的值。
int length(struct node *head)
   { int leng=0；             //长度变量初值为0
     struct node *p；
     p=head->next；           //p指向首结点
     while (p!=head)          //p未移回到表头结点
      { printf(“%d”,p->data)；//输出
        leng++；              //计数
        p=p->next；}           //p移向下一结点
    return leng；            //返回长度值
   }

关于循环链表的评价：

  • 优点：
    • 在单链表的基础上进一步改进，在遍历的时候可以从任意节点开始，增加了遍历的灵活性。
  • 缺点：
    • 没有解决单链表查找元素较慢的问题

双向链表：

  • 双向链表的结构
    在这里插入图片描述

1.非空双向链表
在这里插入图片描述
2.空表
在这里插入图片描述
3.双向循环链表
在这里插入图片描述
4.空表
在这里插入图片描述

  • 循环链表的基本操作
定义：
typedef struct Dnode
  { ElemType data；             //data为抽象元素类型
    struct Dnode *prior,*next； //prior,next为指针类型 
   }*DLList                     //DLList为指针类型

1.插入
 f->prior=p->prior；  //结点B的prior指向结点A
 f->next=p；          //结点B的next指向结点C
 p->prior->next=f；   //结点A的next指向结点B
 p->prior=f；         //结点C的prior指向结点B
 
2.删除
 p->prior->next=p->next；  //结点A的next指向结点C
 p->next->prior=p->prior； //结点C的prior指向结点A
  free(p)；                 //释放结点B占有的空间

插入：
在这里插入图片描述

删除：在这里插入图片描述
双向链表的评价：

  • 优点
    • 在单链表的基础上进行改良，查找元素可以双向查找，一定程度上提升了查找某元素所需的时间
  • 缺点
    • 需要记录前缀点（prior）增加了额外内存空间的开销
printf_umut
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——线性表的顺序存储结构简单输出代码
weixin_45310677的博客
02-18 2304
在C/C++语言中，借助数组类型来实现顺序表，也就是说，用数组存放线性表的元素及其逻辑关系，数组的基本类型就是线性表中元素的的类型，数组大小（即数组上界-下界+1）要大于等于线性表的长度，否则该数组不能存放对应线性表的所有元素。所以当线性表长度小于数组大小时，该数组中会有一部分空闲空间。 注意：顺序表采用数组来实现，但不能将任何一个数组都当作是一个顺序表，二者的运算是不同的。 在定义一个线性表...
数据结构与算法之线性表
齐光的博客
09-06 225
数据结构与算法之线性表（顺序表、链表） Java实现
线性表定义及其顺序存储
qq_51308373的博客
02-27 1999
前言 继前面算法的引入后，大家对什么是算法及其复杂度有了一定了解。数据元素存储主要形式有顺序存储结构、链式存储结构 。本节将介绍线性表及线性表的顺序存储。因内容过多，链式存储将单独写在后一篇文章里。 一、线性表概念及其抽象数据类型 前一篇在介绍复杂度时，我们举出了多项式的例子，从多项式例子中可得一些启发。 多项式表示问题的启示： 1.同一个问题可以有不同的表示（存储）方法 2.有一类共性问题：有序线性序列的组织和管理 1.什么是线性表 （1）线性表定义：由 同类型数据元素 构成 有序序列 的线性结构 （空格
数据结构学习笔记--单链表
qq_45640206的博客
02-15 554
中国大学MOOC数据结构的单链表学习笔记 单链表 单链表中节点的定义 单链表的特点是：当访问过一个节点，只能接着访问它的后继节点，而无法访问它的前驱节点。 插入节点操作 插入操作语句描述 s->next=p->next; p->next=s; 用图描述或许更直观一点 删除节点操作 操作语句描述 p->next=p->next->next 建立单链表 像顺序...
【数据结构】线性表的操作算法
慢热型网友的博客
06-12 3411
（1）创建一个线性表，将给定的含有n个元素的数组中的每个元素依次放入到顺序表中，并将n赋给顺序表的长度成员。算法如下 （2）初始化线性表 （3）销毁线性表，释放线性表L所占用的内存空间 （4）判断是否为空表，若L为空表则返回true，否则返回false （5）求线性表的长度ListLength（L） （6）输出运算表（DispList） 该运算当线性表L不为空时，顺序显示L中各元素的值 （7）求某个数据元素的值GetElem（L，i，&e）...
数据结构和算法-线性表
qq_38852782的博客
07-16 139
数据结构 基础知识 概念：数据组织的不同方式 以及 运算步骤 提高效率和空间利用情况 复杂度：运算次数 常用算法的复杂度分析：等学了算法来分析 数据储存的方式： 顺序储存：数组，在存储空间上 连续整块的空间 链式储存：链表，通过指针实现的不连续储存 常用的操作：数据对象的长度测量，元素的增加/删减，找特定位置的元素 基本的数据结构 堆栈： 队列： ...
educoder数据结构与算法线性表第2关：实现一个链接存储的线性表 定义线性表节点的结构.pdf
04-18
数据结构与算法线性表 本资源摘要信息涵盖了数据结构与算法线性表的第二关，实现一个链接存储的线性表，定义线性表节点的结构。下面是相关知识点的总结： 1. 链接存储的线性表：链接存储是指用链表来实现线性表的...
中南大学数据结构与算法线性表课后作业答案.pdf
07-14
线性表的实现和算法 线性表是数据结构中一种基本的数据结构形式，它可以用来存储和管理大量的...线性表的实现和算法是数据结构中非常重要的内容，了解链表和顺序表的实现和算法可以帮助我们更好地理解和应用数据结构。
《数据结构与算法》课程上机实验一（线性表）_C++_数据结构与算法_线性表_
10-03
在IT领域，数据结构与算法是计算机科学的基础，它们直接影响到程序的效率和设计。本实验聚焦于“线性表”，一种基础且重要的数据结构，它在编程中扮演着核心角色。线性表是由n（n>=0）个相同类型元素构成的有限序列...
数据结构与算法链式线性表.docx
01-10
数据结构与算法链式线性表是计算机科学中的一种重要数据结构，链式线性表是一种非顺序映像或链式映像的数据结构，具有物理位置任意的存储单元，存储单元可以是连续也可以是不连续的，链表中的元素的逻辑顺序和物理...
数据结构与算法-线性表
你若盛开，清风自来
01-14 1750
线性表例子 ●n维向量(x1，x2，…，xn)是一个长度为n的线性表 ●英文小写字母表(a，b，c，…，z)是一个长度为26的线性表 ●一年中的四个季节(春，夏，秋，冬)是一个长度为4的线性表 ●矩阵是一个比较复杂的线性表 ● 学生情况登记表是一个复杂的线性表 由若干数据项组成的数据元素称为记录 由多个记录构成的线性表又称为文件(file) 线性表定义 线性表是由n(n≥0)个属性相同数据元素a1...
创建一个不带头结点的循环单链表并进行相关操作
yuki_1209的博客
09-14 5222
关于循环单链表的创建，以及一些基本操作
不带头结点的单链表的创建（头插法和尾插法）
热门推荐
慢慢的博客
10-02 2万+
1、用头插法建立不带头结点的单链表 #include<iostream> using namespace std; //单链表的结构体 typedef struct Node { int data; struct Node *next; }Node; /*不带头结点的单链表的创建(头插法)*/ void LinkCreate(Node *&L) { int a=0; cout << "请输入数据" << endl; cin >> a
不带头结点的单链表c语言,数据结构：C语言实现----不带头结点单链表总结
weixin_42584758的博客
05-21 887
不带头结点的单链表结构体声明typedef struct Node{int data;struct Node *next;}Node, *LinkList;(1)初始化void InitLinkList(LinkList *plist) //plist为二级指针，主函数传递第一个结点指针的地址{assert(plist!=NULL);if(plist == NULL)return;*plist =...
2024.7.24 作业
最新发布
qq_64434282的博客
07-24 2260
【代码】2024.7.24 作业。
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
执梗的博客
07-23 1837
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 3013
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
2024秋招算法
weixin_43364551的博客
07-22 2249
根据代码随想录和力扣进行算法训练的笔记
数据结构与算法线性表
09-07
数据结构与算法中的线性表是指某类元素的集合，并且记录了元素之间的一种顺序关系。线性表是最基本的数据结构之一，在实际程序中被广泛应用，并且常被用作更复杂数据结构的实现基础。线性表可以使用不同的实现方式，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值