线性结构——顺序表

最新推荐文章于 2022-08-09 18:41:16 发布
最新推荐文章于 2022-08-09 18:41:16 发布
阅读量278 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangliang19950813/article/details/120867602
版权

一、概念

1.1 线性表

线性表 （linear list）是n个具有相同特性的数据元素的有限序列。
常见的线性表：顺序表、链表、栈、队列、字符串等
线性表在逻辑上是一条直线，物理结构上以数组或者链表形式存储

1.2 顺序表

地址连续的存储单元顺序存储线性表中的各个数据元素，逻辑上相邻的数据元素在物理位置上也相邻。( 用一段地址连续的存储单元依次存储线性表的数据元素 )。
在这里插入图片描述
在这里插入图片描述

顺序表分为两种

  1. 静态顺序表：使用定长数组存储。
  2. 动态顺序表：使用动态开辟的数组存储，容量不受限制,支持数据插入,删除,修改等一系列操作。

二、顺序表的实现

2.1 静态顺序表（数组）

略

2.2 动态顺序表实现

在这里插入图片描述

2.2.1 定义数据类型

typedef int datatype;

typedef struct
{
  datatype *Head;   //声明了一个名为Head的长度不确定的数组，也叫“动态数组”
  int ListLength;   //记录当前顺序表的长度
  int ListSize;     //记录顺序表分配的存储容量
}SqList;

2.2.2 初始化

SqList InitTable(int Size)  //初始化顺序表
{
    SqList TableList;

    TableList.Head == NULL;

    if (Size < 0) {
      printf ("size is out of range!\n");
    }

    TableList.Head=(int*)malloc(Size * sizeof(datatype));
    if (TableList.Head == NULL) {
      printf ("Init table fail !!!\n");
      //return ;
    }

    TableList.ListLength = Size;
    TableList.ListSize = 0;
    
    printf ("Init table is successful !!!\n");
    return TableList;
}

2.2.3 打印

void SqListPrint (SqList* Sq)  //打印顺序表
{
  if (Sq == NULL) {
    printf ("sqListPrint not table!!!\n");
    return ;
  }

  for(int i = 0; i < Sq->ListSize; i++) {
    printf ("%d -> ",Sq->Head[i]);
  }
    printf ("\n");
}

2.2.4 扩大存储空间

int CheckSqList (SqList* Sq) //检查数据空间是否填满，填满就扩大存储空间
{
  datatype  *data_tmp = NULL;
  
  if (Sq == NULL) {
    printf ("CheckSqList not table!!!\n");
    return -1;
  }

  if (Sq->ListLength <= Sq->ListSize) {  //判断数据是否存满，如果存满存储空间扩大一倍
    printf ("sqlist space is full, realloc new space!!!\n");
    data_tmp = realloc (Sq->Head, sizeof (datatype) * Sq->ListLength * 2);

    if (data_tmp == NULL) {
      printf ("checkSqlist realloc is error! line : %d",__LINE__);
      return -1;
      }
    Sq->Head = data_tmp;
    Sq->ListLength = Sq->ListLength * 2; 
  }
  
  return 0;
}

2.2.5 尾插

int InsertSqTail (SqList* Sq, datatype data)  //尾插
{
  
  if (CheckSqList (Sq)) {  //检查存储空间是否够用
    printf ("InsertSqTail CheckSqList is error !!!\n");
    return -1;
  }
  
  Sq->Head[Sq->ListSize] = data;
  Sq->ListSize++;

  return 0;
}

2.2.6 头插

int InsertSqHead (SqList* Sq, datatype data)  //头插
{
  if (CheckSqList (Sq)) {  //检查存储空间是否够用
    printf ("InsertSqHead CheckSqList is error !!!\n");
    return -1;
  }

  for (int i = 0; i < Sq->ListSize; i++) {
    Sq->Head[Sq->ListSize - i] = Sq->Head[Sq->ListSize - i - 1];
  }

  Sq->Head[0] = data;
  Sq->ListSize++;
  
  return 0;
}

2.2.7 选择插

int InsertSq (SqList* Sq, int num, datatype data) //选择插 num是插入在第几个位置
{
  if (CheckSqList (Sq)) {  //检查存储空间是否够用
    printf ("InsertSq CheckSqList is error !!!\n");
    return -1;
  }
  
  if (num > Sq->ListSize || num < 0) {
    printf ("num is large !!! \n");
    return -1;
  }

  for (int i = 0; i <= Sq->ListSize - num; i++) {
    Sq->Head[Sq->ListSize - i] = Sq->Head[Sq->ListSize - i - 1];
  }
  Sq->Head[num - 1] = data;
  Sq->ListSize++;

  return 0;
}

2.2.8 尾删

int DeleteSqTail (SqList* Sq)   //尾删
{
  if (Sq == NULL) {
    printf ("DeleteSqTail not table !!!\n");
    return -1;
  }

  if (Sq->ListSize) {
    printf ("table is null data !!! \n");
    return -1;
  }
  
  Sq->Head[Sq->ListSize -1] = 0;
  Sq->ListSize--;
  
  return 0;
}

2.2.9 头删

int DeleteSqHead (SqList* Sq) //头删
{
  if (Sq == NULL) {
    printf ("DeleteSqHead not table !!!\n");
    return -1;
  }

  if (Sq->ListSize) {
    printf ("table is null data !!! \n");
    return -1;
  }

  for (int i = 1; i < Sq->ListSize; i++) {
    Sq->Head[i-1] = Sq->Head[i];
  }

  Sq->ListSize--;

  return 0;
}

2.2.10 选择删除

int DeleteSq (SqList* Sq, int num) //选择删， num 是第几个
{
  if (Sq == NULL) {
    printf ("DeleteSqHead not table !!!\n");
    return -1;
  }

  if (Sq->ListSize) {
    printf ("table is null data !!! \n");
    return -1;
  }

  for (int i = 1; i < Sq->ListSize - num; i++) {
    Sq->Head[num + i - 2] = Sq->Head[num + i - 1];
  }
  
  Sq->ListSize--;
  
  return 0;
}

2.2.11 寻找元素存在位置

int FindSqData (SqList* Sq, datatype ElemData) //寻找输入元素存在位置
{
  if (Sq == NULL) {
    printf ("FindSqData not table !!!\n");
    return -1;
  }

  for (int i = 0; i < Sq->ListSize; i++) {
    if (Sq->Head[i] == ElemData) {
      printf ("find data in : %d",i);
      return i;
    }
  }
  
  return 0;
}

2.2.12 返回当前长度

int FindSqListSize (SqList* Sq)  //返回当前长度
{
  if (Sq == NULL) {
    printf ("FindSqSize not table !!!\n");
    return -1;
  }

  return Sq->ListSize;
}

2.2.13 排序

#define  ORDER     1
#define  RE_ORDER  2

int OderSortSq (SqList* Sq , int Flag) //排序---冒泡排序
{
  if (Sq == NULL) {
    printf ("ChangeSqData not table !!!\n");
    return -1;
  }
  
  switch (Flag)
  {
  case ORDER:
    for (int i = 0; i < Sq->ListSize -1; i++) {
      for (int j = 0; j < Sq->ListSize - i - 1; j++) {
        if (Sq->Head[j] > Sq->Head[j+1]) {
          Sq->Head[j] = Sq->Head[j] + Sq->Head[j+1];
          Sq->Head[j+1] = Sq->Head[j] - Sq->Head[j+1];
          Sq->Head[j] = Sq->Head[j] - Sq->Head[j+1];
        }
      }
    }
    break;

  case RE_ORDER:
    for (int i = 0; i < Sq->ListSize -1; i++) {
      for (int j = 0; j < Sq->ListSize - i - 1; j++) {
        if (Sq->Head[j] < Sq->Head[j+1]) {
          Sq->Head[j] = Sq->Head[j] + Sq->Head[j+1];
          Sq->Head[j+1] = Sq->Head[j] - Sq->Head[j+1];
          Sq->Head[j] = Sq->Head[j] - Sq->Head[j+1];
        }
      }
    }
    break;

  default:
    printf ("Flag is error!\n");
    return -1;
  }
  

  return 0;
}

2.2.14 修改相应数据

int ChangeSqData (SqList* Sq, int num, datatype data) //修改
{
  if (Sq == NULL) {
    printf ("ChangeSqData not table !!!\n");
    return -1;
  }
  
  Sq->Head[num-1] = data;
  
  return 0;
}

2.2.15 翻转

int ReversalSq (SqList *Sq)  //翻转顺序表
{
  int i;
  
  // 第一个与最后一个互换  第二个与倒数第二个互换 ......
  //最后实现全部数据翻转
  for (i = 0; i <= (Sq->ListSize - 1)/2; i++) {
    datatype datatmp = Sq->Head[i];
    Sq->Head[i] = Sq->Head[Sq->ListLength - 1 - i];
    Sq->Head[Sq->ListLength - 1 - i] = datatmp;
  }
  
  return 0;
}

2.2.16 销毁顺序表

int DestroySq (SqList* Sq) //销毁
{
  if (Sq == NULL) {
    printf ("ChangeSqData not table !!!\n");
    return -1;
  }

  free (Sq->Head);
  Sq->Head = NULL;
  Sq->ListLength = 0;
  Sq->ListSize = 0;

  return 0;
}

2.3 测试

int main(void)
{
  SqList  sqlist;

  sqlist = InitTable (INITSIZE);
  
  InsertSqTail (&sqlist, 4);
  InsertSqTail (&sqlist, 5);
  InsertSqTail (&sqlist, 2);
  InsertSqHead (&sqlist, 1);
  InsertSqHead (&sqlist, 3);
  printf("size : %d\n",FindSqListSize (&sqlist));
  SqListPrint (&sqlist);
  
  InsertSqTail (&sqlist , 9);
  InsertSqTail (&sqlist , 8);
  InsertSqTail (&sqlist , 6);
  InsertSq (&sqlist , 6, 7);
  InsertSq (&sqlist , 7, 10);
  printf("size : %d\n",FindSqListSize (&sqlist));
  SqListPrint (&sqlist);
  
  printf ("please start order: \n");
  OderSortSq (&sqlist, ORDER);
  SqListPrint (&sqlist);
  printf ("please start Reverse order: \n");
  OderSortSq (&sqlist, RE_ORDER);
  SqListPrint (&sqlist);
  
  printf ("please start change:\n");
  ChangeSqData (&sqlist, 1, 11);
  ChangeSqData (&sqlist, 2, 12);
  ChangeSqData (&sqlist, 3, 13);
  SqListPrint (&sqlist);
  
  printf ("begin reversal data!\n");
  ReversalSq (&sqlist);
  SqListPrint (&sqlist);
   
  DestroySq (&sqlist);

  return 0;
}

在这里插入图片描述

Mr.小张
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性顺序表
ppppppc
01-18 1762
定义线性顺序表是线性表中一种利用顺序结构实现的数据结构。线性顺序表又被称为线性表的顺序映射或者线性表的顺序存储结构。 它指的是利用一组地址连续的存储单元依次存储线性表的数据元素。就如上图所示，线性顺序表的元素之间是连续的。假设线性顺序表的每个元素需要占用d个存储单元，并且规定线性顺序表 第一个存储单元的地址为基地址（首地址）。那么线性顺序表中第i+1个元素的地址和第i个元素的地址有一下关系对以上
顺序表(线性结构)
那又怎样的博客
03-11 367
类模版不能分别在.h和.cpp文件中定义，所以只能都放在.h文件里seqList.h# pragma //类模版 template<typename T>class seqList { public: seqList(int size=30); //默认构造函数，容量默认为30吧 ~seqList(); //析构函数 void push_ba
线性结构顺序表
qq_40146935的博客
09-19 179
保证了物理上的相邻关系，体现逻辑上的前驱后继关系
线性结构 顺序表
wr8023nt的博客
02-03 236
头文件 #ifndef _SEQUENCELIST_H_ #define _SEQUENCELIST_H_ #define SIZE       10 #define FAILURE    10000 #define SUCCESS    10001 typedef int DataType; struct SequenceList {   DataType *data;
线性结构之顺序表
汪云辉的博客
05-07 454
目录1 顺序表的基本形式2 顺序表的结构与实现3 顺序表的操作4 python中的顺序表 生活中很多事物是有顺序关系的，如班级座位从前到后是按排的顺序，从左到右是按列的顺序，可以很方便的定位到某一个位置，但如果座位是散乱的，就很难定位。 在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生...
数据结构实验——顺序表
12-22
顺序表是一种线性数据结构，它的元素在内存中是连续存放的，就像数组一样。每个元素都有一个唯一的索引，索引从0开始，可以通过索引来直接访问表中的任何元素。这种结构的优点是访问速度快，因为通过索引可以直接...
数据结构C++顺序表
03-04
本主题聚焦于一种基础且重要的数据结构——顺序表，尤其关注如何在C++中实现这一概念。 顺序表是一种线性数据结构，其中元素在内存中按顺序存储。在C++中，我们可以使用数组来实现顺序表。这种结构的优点是访问速度...
线性表——顺序表PPT学习教案.pptx
10-04
线性表——顺序表PPT学习教案 线性表是一种典型的线性结构，其基本特点是线性表中的数据元素是有序且是有限的。线性表可以分为顺序表和链表两种存储结构，今天我们主要讨论顺序表。 1. 线性表的定义 线性表是具有...
数据结构-顺序表C++实现
03-30
在本实验中，我们将关注一种基础且重要的数据结构——顺序表，它在C++中得到了实现。顺序表是一种线性数据结构，其中元素按照它们被添加的顺序存储在连续的内存空间中。 首先，我们要理解顺序表的基本操作。顺序表...
合工大数据结构顺序表实验
04-14
本实验“合工大数据结构顺序表实验”聚焦于数据结构中的一个重要基础概念——顺序表。顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储，就像数组一样。对于18级合工大的学生来说，这个实验旨在深化他们...
线性结构，顺序表
qq_30243515的博客
06-26 265
关于线性结构要了解以下几个方面: 1.线性结构 2.线性表抽象数据类型 3.顺序表 4.顺序表应用 线性结构定义： 如果一个数据元素序列满足： 1.除第一个和最后一个数据元素外,每个数据元素只有一个前驱数据元素和一个后继数据元素; 2.第一个数据元素没有前驱数据元素; 3.最后一个数据元素没有后继数据元素。 则称这样的数据结构为线性结构 线性表抽象数据类型 线性表抽象数据类型主要包括两个方面: 既数据集合和该数据集合上的操作集合。 数据集合可以表示为a0,a1,a2…an-1,每个数据元素的数据类型可以是任
线性结构-顺序表
m0_51274562的博客
08-09 82
线性表的顺序存储：存储数据元素时，把数据元素按照逻辑关系（先后顺序），依次存储在一段连续的内存空间，借助元素在这段连续空间的地址，来表示数据之间的先后关系，就叫做顺序存储。顺序存储：数据在存储时，申请的是一段连续的内存空间，把数据存储到这段连续空间（地址相邻）中。存储线性表时，除了要存储具体线性表的数据意外，还要存储数据与数据之间的关系(线性表：数据元素关系为线性关系的逻辑结构。顺序表的运算：要满足顺序表结构要求。线性关系、线性结构、先后关系).........
数据结构之线性结构-顺序表
weixin_44037272的博客
06-26 456
前言 基础概念 基本操作 顺序表 前言 基础概念 线性表是最简单的一种数据结构，是具有相同数据类型的n(n>=0)个数据元素的有限序列。n为表长，当n=0是为空表。线性表L： L=\{x_1,x_2,···,x_n\} L={x 1 ​ ,x 2 ​ ,⋅⋅⋅,x n ​ } L=\{x_i| x_i \in ElemSet, i=1,2,3,···,n,n\geq0\} L={x i ​ ∣x i ​ ∈ElemSet,i=1,2,3,⋅⋅⋅,n,n≥0} 线性结构特点：在数据元素
数据结构之线性结构（顺序表）【一】
lance的博客
07-21 1553
线性结构是一个数据结构的有序集（次序）。线性结构的基本特征：1.集合中必存在唯一的第一元素和最后元素。2.除最后元素在外，均有唯一的后继，除第一元素之外，均有唯一的前驱。抽象数据类型线性表定义：ADT List{数据对象：D数据关系：R基本操作：1.{结构初始化}InitList
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值