线性表

最新推荐文章于 2022-12-07 21:39:28 发布
最新推荐文章于 2022-12-07 21:39:28 发布
阅读量201 收藏 3
点赞数 1
分类专栏： 数据结构笔记 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46748248/article/details/106189013
版权

2.1线性表的定义与特点

定义：
对于大量相同数据类型（int char）的数据可以用线性表存储，同一数据对象，相邻元素之间存在序偶关系。诸如此类由n（n>=0)个数据特性相同的元素构成的有限序列称为线性表（当n=0时，称为空表）

特点：

  1. 存在唯一的一个被称为“第一个”的数据元素。
  2. 存在唯一的一个被称为“最后一个”的数据元素。
  3. 除第一个外，结构中每个数据元素均只有一个前驱。
  4. 除最后一个外，结构中每个数据元素均只有一个后继。

2.2线性表基本操作的实现

初始

#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量 */
#define LISTINCREMENT 2 /* 线性表存储空间的分配增量 */
typedef struct
 {
   ElemType *elem; /* 存储空间基址 */
   int length; /* 当前长度 */
   int listsize; /* 当前分配的存储容量(以sizeof(ElemType)为单位) */
 }SqList;

宏定义与库

 /* c1.h (程序名) */
 #include<string.h>
 #include<ctype.h>
 #include<malloc.h> /* malloc()等 */
 #include<limits.h> /* INT_MAX等 */
 #include<stdio.h> /* EOF(=^Z或F6),NULL */
 #include<stdlib.h> /* atoi() */
 #include<io.h> /* eof() */
 #include<math.h> /* floor(),ceil(),abs() */
 #include<process.h> /* exit() */
 /* 函数结果状态代码 */
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define INFEASIBLE -1
 /* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */
 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
 typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
  1. Status InitList (SqList *L)
{ /* 操作结果：构造一个空的顺序线性表 */
   (*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
   if(!(*L).elem)
     exit(OVERFLOW); /* 存储分配失败 */
   (*L).length=0; /* 空表长度为0 */
   (*L).listsize=LIST_INIT_SIZE; /* 初始存储容量 */
   return OK;
 }
  1. Status DestroyList (SqList*L)
{ /* 初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L */
   free((*L).elem);
   (*L).elem=NULL;
   (*L).length=0;
   (*L).listsize=0;
   return OK;
 }
  1. Status ClearList (SqList*L)
{ /* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
   (*L).length=0;
   return OK;
 }
  1. Status ListEmpty(SqList L)
{ /* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
   if(L.length==0)
     return TRUE;
   else
     return FALSE;
 }
  1. Status ListLength(SqList L)
{ /* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
   return L.length;
 }
  1. Status GetElem(SqList L,int i,ElemType *e)
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
   /* 操作结果：用e返回L中第i个数据元素的值 */
   if(i<1||i>L.length)
     exit(ERROR);
   *e=*(L.elem+i-1);
   return OK;
 }
  1. Status LocateElem(SqList L,ElemType e)
{ /* 初始条件：顺序线性表L已存在 */
   /* 操作结果：返回L中第一个值与e相同的元素在L中的位置。 */
   int i;
   for(i=0;i<L.length;i++)
   {
       if(*(L.elem+i)==e)
       return i+1,break;
       else return 0;
   }
 }
  1. Status PriorElem(SqList L,ElemType cur_e,ElemType *pre_e)
{ /* 初始条件：顺序线性表L已存在 */
   /* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */
   /*           否则操作失败，pre_e无定义 */
   int i;
   for(i=2;i<=L.length;i++)
   {
   if(*(L.elem+i-1)==cur_e)
      {
	  *pre_e=*(L.elem+i-2);
	  return OK;
	  }
   }
   if(i>L.length) return INFEASIBLE;
 }
  1. Status NextElem(SqList L,ElemType cur_e,ElemType *next_e)
{ /* 初始条件：顺序线性表L已存在 */
   /* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */
   /*           否则操作失败，next_e无定义 */
   int i;
   for(i=1;i<L.length;i++)
   {
   if(*(L.elem+i-1)==cur_e)
      {
	  *pre_e=*(L.elem+i);
	  return OK;
	  }
   }
   if(i==L.length) return INFEASIBLE;
 }
  1. Status ListInsert(SqList *L,int i,ElemType e)
 { /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */
   /* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
   ElemType *newbase,*p;
   int j;
   if(i<1||i>(*L).length+1) /* i值不合法 */
     return ERROR;
   if((*L).length>=(*L).listsize) /* 当前存储空间已满,增加分配 */
   {
     newbase=(ElemType *)realloc((*L).elem,((*L).listsize+1)*sizeof(ElemType));
     if(!newbase)
       exit(OVERFLOW); /* 存储分配失败 */
     (*L).elem=newbase; /* 新基址 */
     (*L).listsize+=1; /* 增加存储容量 */
   }
   *L.length++;/* 表长增1 */
   p=(*L).elem+(*L).length-1;
   for(j=0;j<L.length-i;j++) /* 插入位置及之后的元素右移 */
     *p=*(p-1);
   *(L.elem+i-1)=e; /* 插入e */ 
   return OK;
 }
  1. Status ListDelete(SqList *L,int i,ElemType *e)
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
   /* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
   ElemType *p;
   int j;
   if(i<1||i>(*L).length) /* i值不合法 */
     return ERROR;
   p=*(L.elem+i-1); /* p为被删除元素的位置 */
   *e=*p; /* 被删除元素的值赋给e */
   for(j=0;j<L.length-i;j++) /* 被删除元素之后的元素左移 */
     *p=*(p+1);
   (*L).length--; /* 表长减1 */
   return OK;
 }
  1. Status ListTraverse(SqList L）
/* 初始条件：顺序线性表L已存在 */
   /* 操作结果：对线性表L进行遍历，对L的每个结点访问一次*/
 {  
   ElemType *p=L.elem;
   int i;
   for(i=1;i<=L.length;i++)
     printf("%d ",*p++);
   printf("\n");
   return OK;
 }

另一种写法

void  ListTraverse_L (LinkList L, Status (*visit)(ElemType)) 
{
       p=L->next;
       while(p){
          visit(p->data); p=p->next;
	   }
}
 
 Status visit(ElemType e){
    printf(“The value of the element is %d\n”, (int) e);
    return OK;
}

2.3线性表的链式结构表示与实现

顺序表在做插入和删除操作时，需要移动大量元素，因为其数组具有长度相对固定的静态特性，当表中元素过多且变化较大时，操作过程相对复杂，必然导致存储空间的浪费。链式存储结构很好的解决了这些问题。

1. 定义与表示
用一组任意的存储单元存储线性表的数据元素（可以连续也可以不连续），每个存储映像称为结点（node）。它包括两个域：其中存储数据元素信息的域称为数据域；存储直接后继位置的域称为指针域。指针域中存储的信息称为指针和链。n个结点链结成为一个链表，即为线性表的链式存储结构。又由于此链表的每个结点中只包括一个指针域，故又称线性链表或单链表。因为单链表是非随机存取的存储结构，要取得第i个数据元素必须从头指针出发顺链进行寻找，也称为顺序存储的存取结构。

单链表的构建：

typedef struct LNode
{
  Elemtype data;
  struct LNode *next;
}LNode,*LinkList;

一般情况下，为了便于首元结点，空表和非空表的统一处理，在单链表的第一个结点之前附设一个结点，称之为头结点。头指针是指向链表中第一个结点的指针。
在这里插入图片描述

2.4单链表基本操作的实现

  1. 初始化单链表
Status InitList(LinkList *L)
 { /* 操作结果：构造一个空的线性表L */
   *L=(LinkList)malloc(sizeof(struct LNode)); /* 产生头结点,并使L指向此头结点 */
   if(!*L) /* 存储分配失败 */
     exit(OVERFLOW);
   (*L)->next=NULL; /* 指针域为空 */
   return OK;
 }
  1. 销毁单链表
Status DestroyList(LinkList *L)
 { /* 初始条件：线性表L已存在。操作结果：销毁线性表L */
   LinkList q;
   while(*L)
   {
     q=(*L)->next;
     free(*L);
     *L=q;
   }
   return OK;
 }
  1. 清空单链表
Status ClearList(LinkList L) /* 不改变L */
 { /* 初始条件：线性表L已存在。操作结果：将L重置为空表 */
   LinkList p,q;
   p=L->next; /* p指向第一个结点 */
   while(p) /* 没到表尾 */
   {
     q=p->next;
     free(p);
     p=q;
   }
   L->next=NULL; /* 头结点指针域为空 */
   return OK;
 }
  1. 单链表判空
Status ListEmpty(LinkList L)
 { /* 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
   if(L->next) /* 非空 */
     return FALSE;
   else
     return TRUE;
 }
  1. 求单链表长度
int ListLength(LinkList L)
 { /* 初始条件：线性表L已存在。操作结果：返回L中数据元素个数 */
   int i=0;
   LinkList p=L->next; /* p指向第一个结点 */
   while(p) /* 没到表尾 */
   {
     i++;
     p=p->next;
   }
   return i;
 }
  1. 取元素
Status GetElem(LinkList L,int i,ElemType *e) /* 算法2.8 */
 { /* L为带头结点的单链表的头指针。当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR */
   int j=1; /* j为计数器 */
   LinkList p=L->next; /* p指向第一个结点 */
   while(p&&j<i) /* 顺指针向后查找,直到p指向第i个元素或p为空 */
   {
     p=p->next;
     j++;
   }
   if(!p||j>i) /* 第i个元素不存在 */
     return ERROR;
   *e=p->data; /* 取第i个元素 */
   return OK;
 }
  1. 找元素位置
int LocateElem(LinkList L,ElemType e)
 { /* 初始条件: 线性表L已存在 */
   /* 操作结果: 返回L中第1个与e相等的数据元素的位序。 */
   /*           若这样的数据元素不存在,则返回值为0 */
   int i=0;
   LinkList p=L->next;
   while(p)
   {
     i++;
     if(p->data==e) /* 找到这样的数据元素 */
       return i;
     p=p->next;
   }
   return 0;
 }
  1. 找元素的前驱
Status PriorElem(LinkList L,ElemType cur_e,ElemType *pre_e)
 { /* 初始条件: 线性表L已存在 */
   /* 操作结果: 若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱, */
   /*           返回OK;否则操作失败,pre_e无定义,返回INFEASIBLE */
   LinkList q,p=L->next; /* p指向第一个结点 */
   while(p->next) /* p所指结点有后继 */
   {
     q=p->next; /* q为p的后继 */
     if(q->data==cur_e)
     {
       *pre_e=p->data;
       return OK;
     }
     p=q; /* p向后移 */
   }
   return INFEASIBLE;
 }
  1. 找元素的后继
Status NextElem(LinkList L,ElemType cur_e,ElemType *next_e)
 { /* 初始条件：线性表L已存在 */
   /* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */
   /*           返回OK;否则操作失败，next_e无定义，返回INFEASIBLE */
   LinkList p=L->next; /* p指向第一个结点 */
   while(p->next) /* p所指结点有后继 */
   {
     if(p->data==cur_e)
     {
       *next_e=p->next->data;
       return OK;
     }
     p=p->next;
   }
   return INFEASIBLE;
 }
  1. 单链表的插入
Status ListInsert(LinkList L,int i,ElemType e) /* 算法2.9。不改变L */
 { /* 在带头结点的单链线性表L中第i个位置之前插入元素e */
   int j=0;
   LinkList p=L,s;
   while(p&&j<i-1) /* 寻找第i-1个结点 */
   {
     p=p->next;
     j++;
   }
   if(!p||j>i-1) /* i小于1或者大于表长 */
     return ERROR;
   s=(LinkList)malloc(sizeof(struct LNode)); /* 生成新结点 */
   s->data=e; /* 插入L中 */
   s->next=p->next;
   p->next=s;
   return OK;
 }
  1. 单链表的删除
Status ListDelete(LinkList L,int i,ElemType *e) /* 算法2.10。不改变L */
 { /* 在带头结点的单链线性表L中，删除第i个元素,并由e返回其值 */
   int j=0;
   LinkList p=L,q;
   while(p->next&&j<i-1) /* 寻找第i个结点,并令p指向其前趋 */
   {
     p=p->next;
     j++;
   }
   if(!p->next||j>i-1) /* 删除位置不合理 */
     return ERROR;
   q=p->next; /* 删除并释放结点 */
   p->next=q->next;
   *e=q->data;
   free(q);
   return OK;
 }
  1. 单链表的遍历
Status ListTraverse(LinkList L)
 { /* 初始条件：线性表L已存在 */
   /* 操作结果:依次对L的每个数据元素调用函数printf */
   LinkList p=L->next;
   while(p)
   {
     printf("%d ",(p->data));
     p=p->next;
   }
   printf("\n");
   return OK;
 }

2.5其他链表

2.6顺序表和链表的比较

2.7线性表的应用

  1. 线性表的合并
  2. 有序表的合并
  3. 一元多项式的运算
  4. 稀疏多项式的运算
  5. 图书信息管理系统
    （要求包含查找，插入，删除，修改，排序和计数总计六个功能）
myrsdsg
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构（青岛大学 王卓）】第2章 线性表 学习笔记（十五）2.7 线性表的应用1、2.7 线性表的应用2、2.7 线性表的应用3
wyatt007的博客
07-23 212
目录 2.7 线性表的应用1 1、线性表的合并 2.7 线性表的应用2 1、有序表的合并 2.7 线性表的应用3 1、有序表的合并 2.7 线性表的应用1 1、线性表的合并 问题描述：假设利用两个线性表La和Lb分别表示两个集合A和B，现要求一个新的集合。 算法步骤： 依次取出Lb中的每个元素，执行以下操作： ①在La中查找该元素。 ②如果找不到，则将其插入到La的最后。 【算法2.15】线性表的合并。 //线性表的合并 void union(List &La,
数据结构线性表
04-08
线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。
基础线性表
10-11
线性表（linear_list）是最常用且最简单的一种数据结构
线性表（持续更新中）
罗马尼亚硬拉
10-11 183
线性表主要分为顺序表和链表，本篇主要记录了上述两种表各个基本功能的实现过程以及其应用场景。
数据结构-线性链表(C语言实现)
一只喜欢code的fox
12-07 298
链表是逻辑上相邻的元素在物理存储上不一定相邻，因而在作插入和删除元素时不需要移动大量元素，但同时也因为物理存储不相邻，所以失去了随机存取的优点。 先理解几个概念：结点、头指针、头结点、首元结点...
线性表——单链表笔记
weixin_46096297的博客
10-08 551
线性表 顺序表和单链表 顺序表 单链表 单链表重点在于理解，头结点和头指针 头结点： 头结点不一定存在 头节点存放在第一个元素的结点之前 它的数据域一般没有意义，（但也可以存储标题、日期、建表人等信息） 头结点的存在是为了在某些时候更方便的处理链表 如对第一个元素前进行插入或者删除该结点，头结点能帮我们找到第一个元素的位置，因为它指向第一个元素。头结点的指针域指向第一个元素。 头指针： 头指针是必须存在 因为我们需要知道元素的位置，这个必须由指针来决定！ 头指针是指向链表第一个结点的指针！ 无论链表是否为空
线性表的顺序表示和实现
m0_62670778的博客
09-13 1080
ADT List{数据对象：D={ai|ai∈Elemset,i=1,2,…,n,n≥0}数据关系：R={|ai-1,ai∈D,i=2,…,n}#define MAXSIZE 10000 //图书表可能达到的最大长度typedef struct //图书信息定义{//图书ISBN//图书名字//图书价格}Book;{//存储空间的基地址//图书表中当前图书个数}SqList;//图书表的顺序存储结构类型为SqList。
数据结构学习笔记（一）——线性表
m0_61347989的博客
04-25 362
一、线性表的定义 零个或多个相同数据类型的数据元素的有限序列 二、线性表的抽象数据类型 ADT 线性表（List） DATA ​ 线性表的数据对象集合为{a1,a2,…,an)，每个元素的类型均为DataType。 ​ 其中，除第一个元素a1外，每一个元素有且只有一个直接前驱；除最后一个元素an外，每一个元素有且只有一个直接后继。 ​ 每个元素直接的关系是一对一。 Operation ​ InitList(*L)：初始化操作，建立一个空的线性表 ​
数据结构--线性表
森宝的博客
06-10 228
线性表最简单也是最常用的一种数据结构，它的特点是，在数据元素的非空有限集中 ，（1）存在唯一一个被称为“第一个”的数据元素，存在唯一一个被称为“最后一个”的数据元素。（2）除了第一个数据元素外，集合中的其他数据元素都有一个直接前驱，除了最后一个元素外，集合中的其他数据元素都有一个直接后继；   线性表可分为顺序线性表和链式线性表，它们各有优缺点，顺序线性表中的数据元素之间在逻辑上相邻也在无理数...
数据结构】新手入门——线性表（1）
LucyskyT的博客
11-01 307
【数据结构】新手入门——线性表（1） 一、顺序表 线性表的顺序表示，指的是用一组地址连续的存储单元依次存储线性表的数据元素。 存储地址 数据元素 b 1 b+L 2 … … b+（i-1）*L i b+i*L i+1 – – 类于此表，每个元素占用 L 个存储单元，在某个元素所对应的下一个元素的的地址即为该元素所对应地址加 L 的值。 ...
【线性表的基本操作】
qq_61369552的博客
09-20 345
线性表的基本操作
线性表_线性表实验作业_
10-01
某软件公司年初有n名员工，每名员工有姓名、职务、工号等属性，现在该公司还有共m次...现在请把所有员工建立一个线性表，建立离职、入职、查询函数，当有员工离职或入职时，修改线性表，并且根据输出格式中的要求输出。
数据结构实验报告-线性表-两个有序线性表的归并算法
04-10
从键盘输入数据，建立两个有序线性表(每个线性表的输入数据按由小到大次序输入来建立线性表，不必考虑排序算法)；输出建好的这两个有序线性表；将这两个有序线性表归并为一个有序线性表；输出归并后的有序线性表。 ...
数据结构-C++在dev C++平台运行 线性表 链接存储结构
03-27
数据结构-C++在dev C++平台运行 线性表 链接存储结构，程序正常运行，用于教学 ，便于交流
【数据结构基础笔记】第二章线性表之单链表
水亦心的博客
01-04 3372
目录 一、简要 1、涵盖内容 2、学习要求 二、导入 三、线性链表 1、链式存储结构 2、注意点 四、单链表 1、单链表优点 2、单链表缺点 3、结点类型描述 4、注意点 五、单链表的实现 1、链表的创立 2、链表的操作 3、代码应用 一、简要 好久没有写基础笔记了，当时为了写基础笔记是为了能重新巩固数据结构，后来因为考研，就改成了数据结构周周练，但是很多同学看...
数据结构学习笔记之线性表
WINGREZ‘S BLOG
11-05 1993
线性表线性表的类型定义：ADT List{ 数据对象： 数据关系： 基本操作： InitList(&L) 操作结果：构造一个空的线性表L。 DestroyList(&L) 初始条件：线性表L已存在。 操作结果：销毁线性表L。 ClearList(&L) 初始条件：线性表L已存在。 操作结果：将
线性表与13个基本操作的实现
热门推荐
BruthYU的博客
09-24 2万+
一、宏定义解释 ElemType ：线性表数据元素数据类型 LIST_INIT_SIZE : 线性表初始数据元素容量 Status ：函数返回值（一般替换int型） error ：0 INFEASIBLE ：0 OK ：0二、线性表结构体typedef struct { ElemType *elem;
数据结构学习篇（二） —— 线性表定义和实现
流逝
07-26 1219
数据结构学习篇（二）——线性表的定义和表示
线性表 insert
最新发布
12-22
线性表的插入操作是指在线性表的指定位置插入一个元素。根据引用中的定义，线性表的顺序存储是通过一段地址连续的存储单元依次存储线性表的元素，所以在插入元素时需要将插入位置之后的元素依次后移，为新元素腾出...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值