数据结构初阶 顺序表的讲解

简介: 数据结构初阶 顺序表的讲解

一. 线性表

1.1 定义

线性表(linear list)是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构,常见的线性表:顺序表、链表、栈、队列、字符串…

线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的,线性表在物理上存储时,通常以数组和链式结构的形式存储。


看这个定义 我们再联想前面的知识

是不是发现数组的使用和这个定义十分相似

没错 其实顺序表本质上就是数组

但是它再数组上增加了一点内容

1.2 特点

它分为静态的和动态的

这个特点是不是又发现和我们上面做的项目通讯录十分相似

它是连续存储的 不能跳过元素


二. 顺序表

2.1 定义

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储。在数组上完成数据的增删查改。

2.2 代码

typedef int SLDateType;
#define N 1000
//静态顺序表---开少了不够用 开多了浪费
typedef struct SeqList
{
  SLDateType a[N];
  int size;
}SL;

我们说类似这个结构的 就是一个顺序表


但是呢 为了我们以后改变数字方便 我们可以把这里的100 定义成一个宏 这样我们以后如果想修改顺序表的大小 只要改变宏就可以了


上面就是一个标准的静态数据表 假如说 我们想使用顺序表来管理一个字符串


我们可以改变int类型 变为char类型的数据 但是这样每次改也太麻烦了 所以我们依旧可以再上面定义一个宏变量


我们说 就可以使用这样的格式 方便以后一次性改变所有的变量类型,这样子就能得到一个相对完美的静态顺序表啦


2.3 功能需求

在创建好这个静态表之后 我们要开始大概创建它的一些功能啦

比如说以下的一些功能

void SLInit(SL* ps);
void SLDestory(SL* ps);
void SLPrintf(SL* ps);
void SLPushBack(SL* ps,SLDateType x);//尾部插入
void SLPopBack(SL* ps);//尾部删除
 
void SLPushFront(SL* ps, SLDateType x);//头插
void SLPopFront(SL* ps);//头删

初始化 尾插 头插等等

2.4 静态顺序表的特点以及缺点

特点: 如果满了就不让插入

缺点: 不知道给多少合适

2.5 动态的顺序表

typedef int SLDateType;
#define INIT_CAPACITY 4
typedef struct SeqList
{
  SLDateType* a;
  int size;     //有效数据个数
  int capacity; //最大容量
}SL;

是不是跟我们的通讯录特别相似

其实原理本质上都是一样的 这里只是命名更加规范了

2.6 动态顺序表接口的实现

初始化

void SLInit(SL* ps)
{
  ps->a = (SLDateType*)malloc(sizeof(SLDateType) * INIT_CAPACITY);
  if (ps->a == NULL)
  {
    perror("malloc-error");
    return;
  }
  ps->size = 0;
  ps->capacity = INIT_CAPACITY;
}

尾插

我们先写空间足够的情况

void SeqListPushBack(SL* ps, SLDateType x)
{
  ps->a[ps->size] = x;
  ps->size++;
}

代码表示如上

那么我们接下来我们写上面的两种情况

这里我们要注意的是 一开始我们将指针置空 占用的空间为0

所以说我们一开始至少要开始4个数据的空间

void SLInit(SL* ps)
{
  ps->a = (SLDateType*)malloc(sizeof(SLDateType) * INIT_CAPACITY);
  if (ps->a == NULL)
  {
    perror("malloc-error");
    return;
  }
  ps->size = 0;
  ps->capacity = INIT_CAPACITY;
}

这里我们使用一个打印函数看看整个数据的内容

void SLPrintf(SL* ps)
{
  int i = 0;
  for (i = 0; i < ps->size; i++)
  {
    printf("%d\n", ps->a[i]);
  }
}

打印出结果如下

在使用完成之后我们还需要一个借口函数来释放我们的动态开辟的内存 从而避免内存泄漏的问题

void SLDestory(SL* ps)
{
  free(ps->a);
  ps->a = NULL;
  ps->capacity = ps->size = 0;
}

接下来我们看尾删函数

void SLPopBack(SL* ps)
{
  //暴力检查
  assert(ps->size>0);
  //温柔检查
  /*if (ps->size == 0)
  {
    return;
  }*/
  ps->size--;
}

尾删的话其实我们只要将size-- 就可以


三. 代码

头文件

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//
//typedef int SLDateType;
//#define N 1000
静态顺序表---开少了不够用 开多了浪费
//typedef struct SeqList
//{
//  SLDateType a[N];
//  int size;
//}SL;
 
 
//动态顺序表--按需申请
typedef int SLDateType;
#define INIT_CAPACITY 4
typedef struct SeqList
{
  SLDateType* a;
  int size;     //有效数据个数
  int capacity; //最大容量
}SL;
 
//增删查改
void SLInit(SL* ps);
void SLDestory(SL* ps);
void SLPrintf(SL* ps);
void SLPushBack(SL* ps,SLDateType x);//尾部插入
void SLPopBack(SL* ps);//尾部删除

主文件

#include"SeqList.h"
void SLInit(SL* ps)
{
  ps->a = (SLDateType*)malloc(sizeof(SLDateType) * INIT_CAPACITY);
  if (ps->a == NULL)
  {
    perror("malloc-error");
    return;
  }
  ps->size = 0;
  ps->capacity = INIT_CAPACITY;
}
 
void SLDestory(SL* ps)
{
  free(ps->a);
  ps->a = NULL;
  ps->capacity = ps->size = 0;
}
void SLPrintf(SL* ps)
{
  int i = 0;
  for (i = 0; i < ps->size; i++)
  {
    printf("%d\n", ps->a[i]);
  }
}
 
 
//尾部插入
void SLPushBack(SL* ps,SLDateType x)
{
  if (ps->size == ps->capacity)
  {
    SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * ps->capacity * 2);
    if (tmp == NULL)
    {
      perror("realloc fail");
      return;
    }
    ps->a = tmp;
    ps->capacity *= 2;
  }
  ps->a[ps->size++] = x;
}
 
//尾部删除
void SLPopBack(SL* ps)
{
  //暴力检查
  assert(ps->size>0);
  //温柔检查
  /*if (ps->size == 0)
  {
    return;
  }*/
  ps->size--;
}
 
 
void SLPushFront(SL* ps, SLDateType x)
{
  if (ps->size == ps->capacity)
  {
    SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * ps->capacity * 2);
    if (tmp == NULL)
    {
      perror("realloc fail");
      return;
    }
    ps->a = tmp;
    ps->capacity *= 2;
  }
  while (ps->size-1 >= 0)
  {
    ps->a[ps->size] = ps->a[ps->size-1];
  }
  ps->a[0] = x;
  ps->size++;
}

测试文件

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"
 
void TestSeqList1()
{
  SL s;
  SLInit(&s);//初始化
  SLPushBack(&s, 1);//尾部插入
  SLPushBack(&s, 2);//尾部插入
  SLPushBack(&s, 3);//尾部插入
  SLPushBack(&s, 4);//尾部插入
  SLPushBack(&s, 5);//尾部插入
  SLPushBack(&s, 6);//尾部插入
  SLPushBack(&s, 7);//尾部插入
  SLPushBack(&s, 8);//尾部插入
  SLPushBack(&s, 9);//尾部插入
  
  SLPopBack(&s);//尾部删除
  SLPopBack(&s);
  SLPrintf(&s);
 
 
  SLDestory(&s);//销毁数据
 
}
 
 
 
int main()
{
  TestSeqList1();
  return 0;
}


以上便是本文所有内容,如有错误请各位大佬不吝赐教,感谢留言

目录
相关文章
|
1月前
|
存储 编译器 C语言
数据结构-顺序表详解(看这篇就足够了,哈哈哈)
数据结构-顺序表详解(看这篇就足够了,哈哈哈)
52 2
|
25天前
|
存储 算法 安全
2024重生之回溯数据结构与算法系列学习之顺序表【无论是王道考研人还真爱粉都能包会的;不然别给我家鸽鸽丢脸好嘛?】
顺序表的定义和基本操作之插入;删除;按值查找;按位查找等具体详解步骤以及举例说明
|
25天前
|
存储 C语言
【数据结构】顺序表(c语言实现)(附源码)
本文介绍了线性表和顺序表的基本概念及其实现。线性表是一种有限序列,常见的线性表有顺序表、链表、栈、队列等。顺序表是一种基于连续内存地址存储数据的数据结构,其底层逻辑是数组。文章详细讲解了静态顺序表和动态顺序表的区别,并重点介绍了动态顺序表的实现,包括初始化、销毁、打印、增删查改等操作。最后,文章总结了顺序表的时间复杂度和局限性,并预告了后续关于链表的内容。
56 3
|
25天前
|
算法 安全 NoSQL
2024重生之回溯数据结构与算法系列学习之顺序表习题精讲【无论是王道考研人还真爱粉都能包会的;不然别给我家鸽鸽丢脸好嘛?】
顺序表的定义和基本操作之插入;删除;按值查找;按位查找习题精讲等具体详解步骤以及举例说明
|
1月前
|
存储 Java
数据结构第二篇【关于java线性表(顺序表)的基本操作】
数据结构第二篇【关于java线性表(顺序表)的基本操作】
31 6
|
1月前
|
存储 安全 Java
【用Java学习数据结构系列】探索顺序表和链表的无尽秘密(附带练习唔)pro
【用Java学习数据结构系列】探索顺序表和链表的无尽秘密(附带练习唔)pro
25 3
|
1月前
|
存储 C语言
探索C语言数据结构:利用顺序表完成通讯录的实现
本文介绍了如何使用C语言中的顺序表数据结构实现一个简单的通讯录,包括初始化、添加、删除、查找和保存联系人信息的操作,以及自定义结构体用于存储联系人详细信息。
22 2
|
1月前
|
存储
数据结构(顺序表)
数据结构(顺序表)
27 0
|
1月前
|
存储 算法
【数据结构】新篇章 -- 顺序表
【数据结构】新篇章 -- 顺序表
15 0
|
1月前
|
存储 测试技术
探索数据结构:顺序表的实现与应用
探索数据结构:顺序表的实现与应用