数据结构 DAY03 线性表

已于 2023-12-14 23:35:52 修改
阅读量673 收藏
点赞数
文章标签： 数据结构
于 2021-07-25 11:23:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47688695/article/details/119079277
版权
线性表的基本概念

从今天开始我们正式进入数据结构的学习，开始之前我们先思考几个问题。

  1. 生活中遇到哪些线性表的例子？

  2. 如何通过程序实现线性表？

  3. 线性表结构有哪些基本操作？

  4. 线性表结构在软件方面有哪些应用？

图片

看着上面的表情包是不是有种熟悉的味道，没错，这就是我们生活中最常见的线性表结构——糖葫芦。根据它的结构特性我们给出相应的定义，一个线性表，由有限个具有相同性质的元素构成，结构上要求，非表头和表尾元素有且只有一个前驱和后继。对于表头和表尾元素，如果是没有环的线性表，则表头元素没有前驱，表尾元素没有后继。如果有环则均存在前驱和后继元素，如下图所示。

图片

线性表的实现

线性表的实现，根据表元素存储方式的不同，可以分为两种。一种是线性表中的所有元素占用一片连续的存储空间，我们称之为顺序存储，一种是表中的所有元素不需要占据连续的空间，当表中插入新的元素的时候，额外申请元素所需要的空间，插入到线性表中即可，我们称之为链式存储，下面我们通过程序来依次实现以上两种存储方式。

  • 顺序表的实现（假设顺序表起始地址为b，每个元素占据内存为l）

图片

根据上图所示，显然我们可以使用数组来表示一个顺序表结构，具体如下所示：

// 使用数组来表示顺序表结构
#define MAXSIZE 100 // 顺序表最大长度
typedef int ElemType
typedef struct {
   ElemType data[MAXSIZE];
   int      len // 顺序表长度
}SqList;

使用数组来表示顺序存储结构有一个问题，就是在程序的执行过程中其能表示的元素的个数最大值是不可修改的，如果顺序表元素较少，则存在存储空间的浪费，如果顺序表元素比较多，则有可能导致顺序表的存储空间不够。基于这个问题，我们可以使用动态分配来实现顺序表结构，当内存空间不够用的时候可以重新分配一块更大的内存，并把当前数据拷贝到新的内存当中，具体操作请看后面的基本操作。

// 通过动态分配内存来实现顺序表结构
#define INIT_SIZE 100
#define INCREMENT 20
typedef int ElemType
typedef struct {
ElemType *data;
  int      len; // 顺序表长
  int      cap; // 顺序表最大容量
}SqList;
  • 链式表(链表)实现

图片

链式表相比于顺序表，不要求整个表分配在一块连续的存储空间，这对于占用内存比较大的数据来说比较方便，具体实现如下所示。

图片

// 使用链表实现线性表结构
typedef int ElemType
typedef struct LNode {
  ElemType     data;
  structLNode *next;
}LNode, *LinkList;

假设 L 是 LinkList 类型的变量，为了操作方便我们通常使用该变量的指针域作为链表的第一个节点，L 称之为链表的头节点，对链表判空直接看 L->next == NULL ? empty : nonempty 即可。

线性表的基本操作
  • 数组实现的顺序表
// 初始化、插入、更新、删除操作
#define MAXSIZE 100 // 顺序表最大长度
typedef int ElemType;
typedef struct {
   ElemType data[MAXSIZE];
   int      len // 顺序表长度
}SqList;
bool init_sq_1(SqList *sq) {
   if (NULL == sq) {
       return false;
  }
   sq->len = 0;
   return true;
} // init_sq_1
bool insert_sq_1(SqList *sq, int pos, ElemType data) {
   // 判断顺序表是否为空，顺序表是否已满，pos是否合法
   if (sq == NULL || pos < 0 || pos > sq->len || sq->len == MAXSIZE) {
       return false;
  }
   int i = sq->len;
   for ( ; i > pos; i--) {
       sq->data[i] = sq->data[i-1];
  }
   sq->data[pos] = data;
   sq->len++;
   return true;
} // insert_sq_1
bool update_sq_1(SqList *sq, int pos, ElemType data) {
   // 判断顺序表是否为空，pos是否合法
   if (NULL == sq || pos < 0 || pos > sq->len || pos == MAXSIZE ) {
       return false;
  }
   // pos == sq->len 直接做插入操作
   if (pos == sq->len) {
       return insert_sq_1(sq, pos, data);
  }
   sq->data[pos] = data;
   return true;
} // update_sq_1
bool delete_sq_1(SqList *sq, int pos, ElemType *value) {
   // 判断顺序表是否为空，pos是否合法
   if (NULL == sq || pos < 0 || pos >= sq->len) {
       return false;
  }
   int i = pos;
   *value = sq->data[pos];
   for (; i < sq->len-1; i++) {
       sq->data[i] = sq->data[i+1];
  }
   sq->len--;
   return true;
} // delete_sq_1
  • 通过动态分配内存来实现的顺序表结构
// 初始化、插入、查找、删除操作
#define INIT_SIZE 100
#define INCREMENT 20
typedef int ElemType;
typedef struct {
ElemType *data;
int      len; // 顺序表长
int      cap; // 顺序表最大容量
}SqList;
bool init_sq_2(SqList *sq) {
   if (NULL == sq) {
       return false;
  }
   sq->data = (ElemType*)malloc(sizeof(ElemType)*INIT_SIZE);
   if (NULL == sq->data) {
       return false;
  }
   sq->len = 0;
   sq->cap = INIT_SIZE;
   return true;
} // init_sq_2
bool insert_sq_2(SqList *sq, int pos, ElemType data) {
   // 判断顺序表是否为空，pos是否合法
   if (NULL == sq || pos < 0 || pos > sq->len) {
       return false;
  }
   // 当前动态数组已经满了，插入新元素需要重新申请一块内存
   int i = 0;
   ElemType *newData = NULL, *tmpData = NULL;
   if (sq->len == sq->cap) {
     tmpData = (ElemType*)malloc(sizeof(ElemType)*(sq->cap+INCREMENT));
     if (tmpData == NULL) {
       return false;
    }

     newData = tmpData;
     for (i = 0; i < sq->len; i++) {
       *tmpData++ = sq->data[i];
    }
     free(sq->data);
     sq->data = newData;
     sq->cap += INCREMENT;
  }

   // 插入新元素到中间位置
   for (i = sq->len; i > pos; i--) {
     sq->data[i] = sq->data[i-1];
  }
   sq->data[pos] = data;
   sq->len++;

   return true;
} // insert_sq_2
bool update_sq_2(SqList *sq, int pos, ElemType value) {
   // 判断顺序表是否为空，pos是否合法
   if (NULL == sq || pos < 0 || pos >= sq->len) {
       return false;
  }
   sq->data[pos] = value;
   return true;
} // update_sq_2
bool delete_sq_2(SqList *sq, int pos, ElemType *value) {
   // 判断顺序表是否为空，pos是否合法
   if (NULL == sq || pos < 0 || pos >= sq->len) {
       return false;
  }

   int i = pos;
   *value = sq->data[pos];
   for (i = pos; i < sq->len; i++) {
     sq->data[i] = sq->data[i+1];
  }
   sq->len--;

   return true;
}
  • 使用链表实现的线性表结构
// 初始化、插入、查找、删除操作
typedef struct LNode {
 // 为了操作方便，头节点的data用于记录链表的长度
 ElemType     data;
 struct LNode *next;
}LNode, *LinkList;
bool init_link_list(LinkList L) {
 if (NULL == L) {
   return false;
}
 L->data = 0;
 L->next = NULL;
 return true;
} // init_link_list
bool insert_link_list(LinkList L, int pos, ElemType data) {
 // 判断链表是否为空，pos是否合法
 if (L == NULL || pos < 0 || pos > L->data) {
   return false;
}

 int i = 0;
 LNode *tmpNode = L->next;
 LNode *newNode = NULL, *prior = L;
 // 创建新节点
 newNode = (LNode*)malloc(sizeof(LNode));
 if (newNode == NULL) {
   return false;
}
 newNode->data = data;
 newNode->next = NULL;
 // 确定插入节点位置
 while (i++ < pos && tmpNode != NULL) {
   prior = tmpNode;
   tmpNode = tmpNode->next;
}
 prior->next = newNode;
 newNode->next = tmpNode;
 L->data ++ ;

 return true;
} // insert_link_list
bool update_link_list(LinkList L, int pos, ElemType data) {
 // 判断链表是否为空，pos是否合法
 if (L == NULL || pos < 0 || pos >= L->data) {
   return false;
}

 int i = 0;
 LNode *tmpNode = L->next;
 while (i++ < pos) {
   tmpNode = tmpNode->next;
}
 tmpNode->data = data;

 return true;
} // update_link_list
bool delete_link_list(LinkList L, int pos, ElemType *data) {
 // 判断链表是否为空，pos是否合法
 if (L == NULL || pos < 0 || pos >= L->data) {
   return false;
}

 int i = 0;
 LNode *tmpNode = L->next;
 LNode *prior = L;
 while (i++ < pos && tmpNode != NULL) {
   prior = tmpNode;
   tmpNode = tmpNode->next;
}

 *data = tmpNode->data;
 prior->next = tmpNode->next;
 free(tmpNode);
 L->data--;
 return true;
} // delete_link_list
应用
  • 设将 n (n > 1) 个整数存放到一维数组中，设计一个再时间和空间两方面都尽可能高效的算法，将 R 中保存的序列循环左移 p (0<p<n) 个位置，即将 R 中的数据由(X0, X1, X2 … Xn) 变换为(Xp, X(p+1), …, X0, X1, …, X(p-1))。

图片

  • 解析图示

从下图我们可以看出，要实现一维数组的左移操作，我们可以先将将整个数组进行reverse，然后将数组分成两部分分别进行元素reverse，第一部分为前n-p个元素，第二部分为后p个元素，reverse 结束最终实现数组左移操作。

图片

  • 示例代码
bool ShiftLeft(SqList *SQ, int left, int right) {
  int tmpData = 0;
  if (left > right || left < 0 || right > SQ->len-1) {
    printf("left %d or right %d invalid \n", left, right);
    return false;
  }
  // reverse table
  while (left < right) {
    tmpData = SQ->data[left];
    SQ->data[left] = SQ->data[right];
    SQ->data[right] = tmpData;

    left++;
    right--;
  }
  return true;
}
  • 判断链表是否存在环

图片

  • 解析

我们定义两个指针，一个 fast 指针，一个 low 指针。两个指针初始位置都是链表的头节点，分别移动这两个指针，fast 指针每次移动两个位置，low 指针每次移动一个位置。下图中我们可以看到，如果链表存在环，fast 指针和 low 指针必然相遇。如果链表没有环，则 fast 必然先指向 NULL。

图片

图片

  • 示例代码
bool CircularLinkedList(LinkList L) {
  if (L == NULL) {
    // 链表为空
    return false;
  }

  // 初始位置设为头节点
  LinkList slow = L->next;
  LinkList fast = L->next;
  while (slow != NULL && fast->next != NULL) {
    slow = slow->next;
    fast = fast->next->next;
    if (slow == fast) {
      return true;
    }
  }
  // 说明 slow == NULL || fast->next == NULL
  // 没有环
  return false;
}
无涯本无
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线性表的应用举例
HLXchamp的博客
05-04 628
一元多项式的表示及相加 1、一元多项式的表示： 一元多项式可按升幂的形式写成： Pn(x)P_n(x)Pn​(x) = p0p_0p0​ + p1p_1p1​x1x^1x1 + p2p_2p2​x2x^2x2 + … + pnp_npn​xnx^nxn， PiP_iPi​是指数i项的系数. 一元多项式Qm(x)Q_m(x)Qm​(x)可用线性表Q来表示. Q= (q0q_0q0​，q1q_1q1​...
4.线性表的定义与特点
qq_54708219的博客
08-03 246
线性表（Linear List）：是具有相同特性的数据元素的一个有限序列。一些基本术语如下：例如：26个英文字母组成的线性表（A,B...Z），数据元素都是字母，元素之间都是线性。同一线性表中的元素必定具有相同特性，数据元素间的关系是线性关系。线性表的逻辑特征是：（1）在非空的线性表，有且仅有一个开始结点a_1，它没有直接前趋而仅有一个直接后继a_2；（2）有且仅有一个终端结点a_n，它没有直接后继，而仅有一个直接前趋a_(n-1)；
算法笔记 （六）数据结构之线性表如何理解
李龙生
08-26 916
线性表的理解？ &nbsp; &nbsp;&nbsp;&nbsp;线性表从字面上的理解是线性的表示结构，生活中有很多类似于线性的例子，比如人们在买东西或等其它事情的时候经常排成一个线性结构，可以是直线也可以是曲线，线性表从字面上面的意思理解为成一条直线的表，对于程序设计人我们最熟悉的莫过于关系型数据库如mysql等，它里面也有表的概念，我们可以对比着来理解线性表。 定义 &nbsp...
线性表的实际应用
pangyou3s的博客
12-25 425
线性表的实际应用
线性表及其应用
一越王超的博客
02-27 1889
本节我们需要弄清如下问题： 线性表的定义 线性表的抽象数据类型 线性表的顺序存储结构 线性表的链式存储结构 顺序与链式存储结构比较 线性表的简单应用 线性表的扩展 线性表的定义 线性表（linear_list）是最基本和最常用的一类数据结构，它表示的是线 性结构。 在线性结构中，数据元素之间存在着一对一的关系，其特 点是数据元素之间按某种规定存在一个顺序关系。 线性表的抽象数据类型 线性表的顺序存储结构 线性表的链式存储结构 顺序与链式...
数据结构实验一线性表的基本操作.docx
03-28
数据结构实验一线性表的基本操作 一、线性表的概念和类型 线性表是一种基本的数据结构，它是一种由零个或多个元素组成的有限序列，每个元素都是数据类型的实例。线性表可以分为两种类型：顺序存储结构和链式存储...
数据结构--线性表.cpp
03-08
数据结构--线性表.cpp
北邮 数据结构实验 线性表
05-21
北邮数据结构实验线性表 本资源详细介绍了北邮数据结构第一次实验中的线性表实验报告，包括实验要求、存储结构、关键算法分析和测试main()函数等方面的内容。 在存储结构方面，本资源介绍了带头结点的单链表的存储...
用C语言实现数据结构中的线性表
11-15
本人在学习数据结构时使用的是严蔚敏的《数据结构》，并根据课本内容完成了这个头文件，这个头文件把课本中的线性表的顺序表的表示和实现都囊括在内了。部分实现中也做了相应的优化处理。由于一次性只能发一个文件，...
数据结构--线性表--思维导图.pdf
08-29
数据结构--线性表--思维导图.pdf 该资源主要讲解了数据结构中的线性表，包括线性表的定义、基本操作、顺序表和链表的存储方式、操作效率比较等。 线性表的定义： 线性表是一种逻辑结构，表示元素之间一对一相邻的...
数据结构之线性表及其应用
10-15
线性表的两种实现方法array-based list以及singly linked list，实现他们的类型定义 给顺序表和链表的实现分别使用添加成员函数以及对象的应用两种方法实现线性表中元素的逆置(reverse)和单个元素移动到特定位置的操作(move)。 编写一个函数，用于合并两个顺序表。输入的顺序表按照其元素从小到大排序，输出的顺序表要求按照元素从大到小排序。要求算法在线性时间内完成任务。 编写一个函数，用于合并两个单链表。输入的单链表按照其元素从小到大排序，输出的单链表要求按照元素从大到小排序。要求算法在线性时间内完成任务。
线性表简单易懂的例子！原创！！调试通过！
10-03
新手必备的例子，我自学时写的！可以给你个参照！！
线性表
dfce62214326的博客
07-27 130
结点逻辑关系为线性的结构——线性表 现实生活中的线性关系： ①排队中的一一对应关系 ②（Caesar Code）字母表的表示方法 ③电话号码表的结构（姓名、电话、身份证号、地址） 线性表的定义：一个线性表是n（n>=0）个同类型结点的有限序列。 线性表的逻辑结构： 线性表的存储结构： 顺序表：将线性表中的元素依次放在一个连续的存储空间中，这样的线性表叫顺...
数据结构 实验一 线性表的应用
liuxiaocs7的博客
10-06 693
#include &amp;lt;iostream&amp;gt; using namespace std; const int MAXSIZE = 20; const int ERROR = 0; const int OK = 1; typedef int Status; //顺序表实现 //template &amp;lt;typename T&amp;gt; typedef struct Student { i...
线性表的应用
积少成多，水滴石穿
07-13 540
两个链表的合并#include&lt;bits/stdc++.h&gt; using namespace std; typedef struct Node{ int data; struct Node* next; }*List; List Creat() { List L,R,H; int n,i; scanf("%d",&amp;n); H=(List)malloc(sizeof(...
线性表的应用1
筱羊冰冰
07-12 163
应用1 一元多项式 a0+a1 * x1+a2 * x2+……这样的式子就是一元多项式了，只有一个变量且为指数项相加的形式。 理论上用一个结构体数组就行了，但是呢，如果是a0 + a100 * x100这样的，要是一个数组，血亏。 所以呢，链表就出来拯救世界了，此时结构体的数值域就应该是两个变量了，exp（指数）和 ...
线性表实例
Fire的博客
08-02 2585
线性表的本质：由0个或多个数据元素组成的集合 数据元素之间是顺序的 数据元素个数是有限的 数据元素的类型必须是相同的 专业的定义：线性表是具有相同类型的n(n>=0)个数据元素的有限序列（a0，a1，a2，...an） ai是表项，n是长度 性质：a0为线性表中的第一个元素，只有一个后继 an为线性表中的最后一个元素，只有一个前驱 除了a0和an之外的其他元素ai，既有一个直接前驱，也有一个直接后继
演示顺序线性表的例子
专注搜素引擎的爬取
04-01 729
看了数据结构的书，为了动动手，仿着程杰老师的代码，写了下面一个演示顺序线性表的例子，优点是去元素的时候O(1)就能解决，不好的地方是浪费空间啊。/* * list.cpp * * Created on: 2013-4-1 * Author: CJ */ #include using namespace std; #define MAXSIZE 20
线性表的顺序存储结构（查找、插入、删除等）
生活是场卖萌
07-30 2810
#include <stdio.h> #include <stdlib.h> #define LIST_INIT_SIZE 100//线性表存储空间的初始化分配量 #define LISTINCREMENT 10//线性表存储空间的分配增量（当存储空间不够时要用到） typedef int ElemType; struct List {     ElemType *elem;//存储空间的基地址
数据结构图书馆线性表
最新发布
05-22
线性表是数据结构中非常基础的一种数据结构，它是由n个具有相同数据类型的元素组成的有限序列。其中n为线性表的长度，线性表的两端分别为“表头”和“表尾”。线性表的基本操作包括插入、删除、查找等，它的实现方式...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值