AI 助理
备案控制台
开发者社区 云计算 文章 正文

【数据结构】C--顺序表1.0版本(本文非常适合小白观看,已尽力详解,以及图解也是尽量列举)（下）

2023-10-23 40
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： 【数据结构】C--顺序表1.0版本(本文非常适合小白观看,已尽力详解,以及图解也是尽量列举)（下）

9️⃣中间插入:SLInsert

void SLInsert(SL* psl, int pos, SLDatatype x);

//中间插入:首先要看容量，调用检查容量的函数,接着挪动
void SLInsert(SL* psl,int pos,SLDatatype x)
{
  assert(psl);//应对可能传过来的NULL指针，而且好处是直接告诉你哪个文件的哪一行出问题
  //assert(0 <= pos && pos <= psl->size);//说明这个位置可以是顺序表的头和尾
  SLCheckCapacity(psl);
  int end = psl->size - 1;
  while (end >= pos)
  {
    psl->a[end + 1] = psl->a[end];
    --end;
  }
  psl->a[pos] = x;
  psl->size++;
}

图解:

79874258ad89406480d044d4d912cb15.png

假设没有assert断言pos的范围,开一组测试看看效果:记住越界是不一定报错的!

void TestSeqList5()
{
  SL s;
  SLInit(&s);
  SLPushBack(&s, 1);
  SLPushBack(&s, 2);
  SLPushBack(&s, 3);
  SLPushBack(&s, 4);
  SLPushBack(&s, 5);
  SLPushBack(&s, 6);
  SLPrint(&s);
  SLInsert(&s, 2, 30);
  SLPrint(&s);
  SLInsert(&s, 20, 30);//在不属于顺序表的地方,插入一个元素，越界但不一定报错！
  //SLPrint(&s);
  SLInsert(&s, -20, 30);//负数下标
  //SLPrint(&s);
}


ed71ebb6d8ea4f72974700356d43525d.png

加了assert(0 <= pos && pos <= psl->size)之后:

6cc680d99e084d21aada624a8ed45334.png

这里说一下，头插和尾插都可以调用SLInsert函数，提高代码的复用性

尾插：

void SLPushBack(SL* psl, SLDatatype x)
{
  assert(psl);
  //psl->a[psl->size] = x;
  //psl->size++;
  //SLCheckCapacity(psl);
  //psl->a[psl->size++] = x;
  SLInsert(psl, psl->size, x);
}


头插：

void SLPushFront(SL* psl, SLDatatype x)
{
  assert(psl);
  //SLCheckCapacity(psl);
   挪动数据
  //int end = psl->size - 1;
  //while (end >= 0)
  //{
  //  psl->a[end + 1] = psl->a[end];
  //  --end;
  //}
  //psl->a[0] = x;
  //psl->size++;
  SLInsert(psl, 0, x);
}


🔟中间删除:SLErase

void SLErase(SL* psl,int pos);

void SLErase(SL* psl, int pos)//从中间删除元素,也可以是首或者尾
{
  assert(psl);//应对可能传过来的NULL指针，而且好处是直接告诉你哪个文件的哪一行出问题
  assert(0 <= pos && pos < psl->size);//说明这个位置可以是顺序表的头和尾
  //assert(psl->size>0);//这句代码也可以不加，因为
  int start = pos + 1;
  while (start < psl->size)
  {
    psl->a[start - 1] = psl->a[start];
    ++start;
  }
  psl->size--;
}

图解:

398f4785e41b4ec3bf326a9dddf29248.png

再次调用这组测试,这次是为了测试从中间删除：

void TestSeqList5()
{
  SL s;
  SLInit(&s);
  SLPushBack(&s, 1);
  SLPushBack(&s, 2);
  SLPushBack(&s, 3);
  SLPushBack(&s, 4);
  SLPushBack(&s, 5);
  SLPushBack(&s, 6);
  SLPrint(&s);
  SLInsert(&s, 2, 30);//中间插入
  SLPrint(&s);
  //SLInsert(&s, 20, 30);
  //SLPrint(&s);
  //SLInsert(&s, -20, 30);
  //SLPrint(&s);
  SLErase(&s, 3);//删除中间下标为3的元素,把元素3删除了
  SLPrint(&s);
  SLPopFront(&s);
  SLPrint(&s);
  SLPopBack(&s);
  SLPrint(&s);
  SLDestroy(&s);
}


执行:这里第三行把3干掉了

c5fffb617993427192c2881cd4b7ca43.png

调用SLErase(函数

尾删：

void SLPopBack(SL* psl)
{
  assert(psl);
  // 暴力检查
  //assert(psl->size > 0);
   温柔的检查
  if (psl->size == 0)
    return;
  psl->a[psl->size - 1] = 0;
  //psl->size--;
  SLErase(psl, psl->size-1);
}


头删:

void SLPopFront(SL* psl)
{
  assert(psl);
  // 暴力检查
  //assert(psl->size > 0);
  ///*int start = 0;
  //while (start < psl->size-1)
  //{
  //  psl->a[start] = psl->a[start + 1];
  //  start++;
  //}*/
  //int start = 1;
  //while (start < psl->size)
  //{
  //  psl->a[start-1] = psl->a[start];
  //  start++;
  //}
  //psl->size--;
  SLErase(psl, 0);
}


1️⃣1️⃣查找:SLFind

int SLFind(SL* psl, SLDatatype x);//找到返回下标,没有找到返回-1

返回的-1也可以用其它负数,但是一般都是用-1。

int SLFind(SL* psl, SLDatatype x)//查找
{
  assert(psl);//应对可能传过来的NULL指针，而且好处是直接告诉你哪个文件的哪一行出问题
  for (int i = 0; i < psl->size; i++)
  {
    if (psl->a[i] == x)
    {
      return i;//返回要查找的元素的下标
    }
  }
  return -1;//走完一遍了还没找到就返回-1，因为下标不可能是负数
}


测试一组查找的代码:

void TestSeqList6()
{
  SL s;
  SLInit(&s);
  SLPushBack(&s, 1);
  SLPushBack(&s, 2);
  SLPushBack(&s, 3);
  SLPushBack(&s, 4);
    SLPushBack(&s, 6);//返回这个的下标,不会返回下面那个6的下标
  SLPushBack(&s, 5);
  SLPushBack(&s, 6);
  SLPrint(&s);
  int pos = SLFind(&s, 6);
  if (pos != -1)
  {
    SLErase(&s, pos);
  }
  SLPrint(&s);
  SLDestroy(&s);
}


找到了就返回该元素的下标,然后从中间删除它,注意这里有两个6，只返回第一个6的下标,因为第一个6是先放进去的

a613fb7dfed04c39aff25f1289add7f2.png

执行:

883afc74e73e40838b609b5ef4ada290.png

1️⃣2️⃣修改:SLModify

void SLModify(SL* psl, int pos, SLDatatype x);

void SLModify(SL* psl, int pos, SLDatatype x)
{
  assert(psl);//应对可能传过来的NULL指针，而且好处是直接告诉你哪个文件的哪一行出问题
  assert(0 <= pos && pos < psl->size);
  psl->a[pos] = x;
}

调用修改的代码：

void TestSeqList7()//用于测试修改
{
  SL s;
  SLInit(&s);
  SLPushBack(&s, 1);
  SLPushBack(&s, 2);
  SLPushBack(&s, 3);
  SLPushBack(&s, 4);
  SLPushBack(&s, 6);
  SLPushBack(&s, 5);
  SLPushBack(&s, 6);
  SLPrint(&s);
  int pos = SLFind(&s, 6);
  if (pos != -1)
  {
    SLModify(&s, pos, 10);//4下标的6已经改成10了
  }
  SLPrint(&s);
  SLDestroy(&s);
}


d52130f02a9d459a8937f8cdd33bed3e.png

这里再测试一下assert断言的好处:应对可能传过来的NULL指针，而且好处是直接告诉你哪个文件的哪一行出问题

void TestSeqList8()
{
  SL* s = NULL;
  SLPushBack(s, 1);
  SLPushBack(s, 2);
  SLPushBack(s, 3);
  SLPrint(s);
  SLDestroy(s);
}

e4b27155d0394fc4b0ec282f565944a4.png


三.整体实现代码


SeqLish.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//静态的顺序表
//#define N 10000
//typedef int SLDatatype;
//struct SeqList
//{
//  SLDatatype a[N];
//  int size;
//};
//动态顺序表
typedef int SLDatatype;//这个位置换成double会导致问题,可能会导致全元素都是0
typedef struct SeqList
{
  SLDatatype* a;
  int size;  //存储的有效数据的个数
  int capacity;//容量
}SL;//类型名重定义
void SLInit(SL* psl);
void SLDestroy(SL* psl);
void SLPrint(SL*psl);// 顺序表打印
void SLPushBack(SL* psl, SLDatatype x);//尾插
void SLPushFront(SL* psl, SLDatatype x);//头插
void SLPopBack(SL* psl);//尾删
void SLPopFront(SL* psl);//头删
void SLInsert(SL* psl, int pos, SLDatatype x);
void SLErase(SL* psl,int pos);
//找到返回下标,没有找到返回-1
int SLFind(SL* psl, SLDatatype x);
void SLModify(SL* psl, int pos, SLDatatype x);


SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
//顺序表的要求就是连续存储
void SLInit(SL* psl)
{
  psl->a = (SLDatatype*)malloc(sizeof(SLDatatype) * 4);//malloc扩容,因为malloc类型是->void* malloc (size_t size);所以需要强制转换
  //打印错误信息?
  if (psl->a == NULL)
  {
    perror("malloc fail");
    return;
  }
  psl->capacity = 4;//使用结构体指针指向访问对象的成员,当前容量
  psl->size = 0;//当前有效信息个数
}
void SLDestroy(SL* psl)//销毁不是整没了，而是还给操作系统了
{
  free(psl->a);
  psl->a = NULL;
  psl->size = 0;
  psl->capacity = 0;
}
void SLPrint(SL* psl)
{
  for (int i = 0; i < psl->size; i++)
  {
    printf("%d ", psl->a[i]);
  }
  printf("\n");
}
//?
void SLCheckCapacity(SL* psl)
{
  if (psl->size == psl->capacity)//有效信息的个数等于当前容量
  {
    SLDatatype* tmp =(SLDatatype*)realloc(psl->a, sizeof(SLDatatype) * psl->capacity * 2);
    if (tmp == NULL)//申请空间过大可能会申请失败
    {
      perror("realloc fail");
      return;
    }
    psl->a = tmp;//原地扩容用的是原来的地址，异地扩容用的是新的
    psl->capacity *= 2;//当前容量*2
  }
}
//尾插法
void SLPushBack(SL* psl, SLDatatype x)
{
  assert(psl);  
  SLCheckCapacity(psl);
  psl->a[psl->size++] = x;//检查当前容量,不够则扩容
}
//头插法必须从后往前挪动数据，不能从往前往后挪动
void SLPushFront(SL* psl, SLDatatype x)
{
  assert(psl);
  SLCheckCapacity(psl);
  //挪动数据
  int end = psl->size-1;
  while (end >= 0)
  {
    psl->a[end + 1] = psl->a[end];
    --end;
  }
  psl->a[0] = x;
  psl->size++;
}
//尾删
void SLPopBack(SL* psl)
{
  assert(psl);
  //暴力检查
  //assert(psl->size > 0);
  //温柔检查
  if (psl->size == 0)
  {
    printf("顺序表为空,删除失败\n");
    return;//不报错任何问题,直接回答主函数。
  }
    //psl->a[psl->size - 1] = 0;这句话不好,就是说把最后一个位置变成0
  psl->size--;
}
void SLPopFront(SL* psl)//从后往前
{
  assert(psl);
  //暴力检查
  assert(psl->size > 0);
  //温柔检查
  if (psl->size == 0)
    return;
  int start = 0;
  while (start < psl->size - 1)
  {
    psl->a[start] = psl->a[start + 1];
    start++;
  }
  /*int start = 1;
  while (start < psl->size)
  {
    psl->a[start - 1] = psl->a[start];
    start++;
  }*/
  psl->size--;
}
//中间插入:首先要看容量，调用检查容量的函数,接着挪动
void SLInsert(SL* psl,int pos,SLDatatype x)
{
  assert(psl);
  assert(0 <= pos && pos <= psl->size);
  SLCheckCapacity(psl);
  int end = psl->size - 1;
  while (end >= pos)
  {
    psl->a[end + 1] = psl->a[end];
    --end;
  }
  psl->a[pos] = x;
  psl->size++;
}
void SLErase(SL* psl, int pos)//从中间删除元素,也可以是首或者尾
{
  assert(psl);
  assert(0 <= pos && pos < psl->size);
  //assert(psl->size>0);
  int start = pos + 1;
  while (start < psl->size)
  {
    psl->a[start - 1] = psl->a[start];
    ++start;
  }
  psl->size--;
}
int SLFind(SL* psl, SLDatatype x)//查找
{
  assert(psl);
  for (int i = 0; i < psl->size; i++)
  {
    if (psl->a[i] == x)
    {
      return i;
    }
  }
  return -1;//走完一遍了还没找到就返回-1，因为下标不可能是负数。
}
void SLModify(SL* psl, int pos, SLDatatype x)
{
  assert(psl);
  assert(0 <= pos && pos < psl->size);
  psl->a[pos] = x;
}


Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
void TestSeqList1()
{
  SL s;
  SLInit(&s);
  SLPushBack(&s, 1);
  SLPushBack(&s, 1);
  SLPushBack(&s, 2);
  SLPushBack(&s, 3);
  SLPushFront(&s,5);
  SLPrint(&s);
  SLDestroy(&s);
}
void TestSeqList2()
{
  SL s;
  SLInit(&s);
  SLPushBack(&s, 1);
  SLPushBack(&s, 2);
  SLPushBack(&s, 3);
  SLPushBack(&s, 4);
  SLPushFront(&s, 5);
  SLPushFront(&s, 6);
  SLPrint(&s);
  SLDestroy(&s);
}
void TestSeqList3()//测试尾部删除的越界问题,以及打印值问题
{
  SL s;
  SLInit(&s);
  SLPushBack(&s, 1);
  SLPushBack(&s, 2);
  SLPushBack(&s, 3);
  SLPushBack(&s, 4);
  SLPushFront(&s, 5);
  SLPushFront(&s, 6);
  SLPrint(&s);
  SLPopBack(&s);
  SLPopBack(&s);
  SLPrint(&s);
  SLPopBack(&s);
  SLPopBack(&s);
  SLPrint(&s);
  SLPopBack(&s);
  SLPopBack(&s);
  SLPopBack(&s);
  SLPrint(&s);
  SLPushBack(&s, 1);
  SLPushBack(&s, 2);
  SLPushBack(&s, 3);
  SLPushBack(&s, 4);
  SLPrint(&s);
  SLDestroy(&s);
}
void TestSeqList4()
{
  SL s;
  SLInit(&s);
  SLPushBack(&s, 1);
  SLPushBack(&s, 2);
  SLPushBack(&s, 3);
  SLPushBack(&s, 4);
  SLPrint(&s);
  SLPopFront(&s);
  SLPopFront(&s);
  SLPrint(&s);
  SLPopFront(&s);
  SLPopFront(&s);
  SLPrint(&s);
  //SLPopFront(&s);
  //SLPopFront(&s);
  //SLPrint(&s);
  SLDestroy(&s);
}
void TestSeqList5()
{
  SL s;
  SLInit(&s);
  SLPushBack(&s, 1);
  SLPushBack(&s, 2);
  SLPushBack(&s, 3);
  SLPushBack(&s, 4);
  SLPushBack(&s, 5);
  SLPushBack(&s, 6);
  SLPrint(&s);
  SLInsert(&s, 2, 30);
  SLPrint(&s);
  //SLInsert(&s, 20, 30);
  //SLPrint(&s);
  //SLInsert(&s, -20, 30);
  //SLPrint(&s);
  SLErase(&s, 3);
  SLPrint(&s);
  SLPopFront(&s);
  SLPrint(&s);
  SLPopBack(&s);
  SLPrint(&s);
  SLDestroy(&s);
}
void TestSeqList6()
{
  SL s;
  SLInit(&s);
  SLPushBack(&s, 1);
  SLPushBack(&s, 2);
  SLPushBack(&s, 3);
  SLPushBack(&s, 4);
  SLPushBack(&s, 6);
  SLPushBack(&s, 5);
  SLPushBack(&s, 6);
  SLPrint(&s);
  int pos = SLFind(&s, 6);
  if (pos != -1)
  {
    SLErase(&s, pos);
  }
  SLPrint(&s);
  SLDestroy(&s);
}
void TestSeqList7()
{
  SL s;
  SLInit(&s);
  SLPushBack(&s, 1);
  SLPushBack(&s, 2);
  SLPushBack(&s, 3);
  SLPushBack(&s, 4);
  SLPushBack(&s, 6);
  SLPushBack(&s, 5);
  SLPushBack(&s, 6);
  SLPrint(&s);
  int pos = SLFind(&s, 6);
  if (pos != -1)
  {
    SLModify(&s, pos, 10);
  }
  SLPrint(&s);
  SLDestroy(&s);
}
void TestSeqList8()
{
  SL* s = NULL;
  SLPushBack(s, 1);
  SLPushBack(s, 2);
  SLPushBack(s, 3);
  SLPrint(s);
  SLDestroy(s);
}
void menu()
{
  printf("***************************************\n");
  printf("1、尾插数据  2、尾删数据\n");
  printf("3、头插数据  4、头删数据\n");
  printf("5、打印数据  -1、退出\n");
  printf("***************************************\n");
}
int main()
{
  //TestSeqList1();
  TestSeqList2();
  //TestSeqList3();
  //TestSeqList5();
  //TestSeqList8();
  return 0;
}


欢迎大佬指正，非常感谢您的支持!

文章标签：
日志服务
关键词：
数据结构顺序表
数据结构版本
数据结构列举
数据结构顺序表版本
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
Dream_Chaser～
目录
相关文章
禁默
|
1月前
|
存储 编译器 C语言
数据结构-顺序表详解（看这篇就足够了，哈哈哈）
数据结构-顺序表详解（看这篇就足够了，哈哈哈）
禁默
49 2
肾透侧视攻城狮
|
17天前
|
存储 算法 安全
2024重生之回溯数据结构与算法系列学习之顺序表【无论是王道考研人还真爱粉都能包会的；不然别给我家鸽鸽丢脸好嘛？】
顺序表的定义和基本操作之插入；删除；按值查找；按位查找等具体详解步骤以及举例说明
肾透侧视攻城狮
24 3
ephemerals__
|
17天前
|
存储 C语言
【数据结构】顺序表（c语言实现）（附源码）
本文介绍了线性表和顺序表的基本概念及其实现。线性表是一种有限序列，常见的线性表有顺序表、链表、栈、队列等。顺序表是一种基于连续内存地址存储数据的数据结构，其底层逻辑是数组。文章详细讲解了静态顺序表和动态顺序表的区别，并重点介绍了动态顺序表的实现，包括初始化、销毁、打印、增删查改等操作。最后，文章总结了顺序表的时间复杂度和局限性，并预告了后续关于链表的内容。
ephemerals__
49 3
肾透侧视攻城狮
|
17天前
|
算法 安全 NoSQL
2024重生之回溯数据结构与算法系列学习之顺序表习题精讲【无论是王道考研人还真爱粉都能包会的；不然别给我家鸽鸽丢脸好嘛？】
顺序表的定义和基本操作之插入；删除；按值查找；按位查找习题精讲等具体详解步骤以及举例说明
肾透侧视攻城狮
17 1
小强在此
|
1月前
|
存储 Java
数据结构第二篇【关于java线性表（顺序表）的基本操作】
数据结构第二篇【关于java线性表（顺序表）的基本操作】
小强在此
30 6
GuGuStudy
|
1月前
|
存储 安全 Java
【用Java学习数据结构系列】探索顺序表和链表的无尽秘密（附带练习唔）pro
【用Java学习数据结构系列】探索顺序表和链表的无尽秘密（附带练习唔）pro
GuGuStudy
23 3
GuGuStudy
|
1月前
|
存储 C语言
探索C语言数据结构：利用顺序表完成通讯录的实现
本文介绍了如何使用C语言中的顺序表数据结构实现一个简单的通讯录，包括初始化、添加、删除、查找和保存联系人信息的操作，以及自定义结构体用于存储联系人详细信息。
GuGuStudy
19 2
努力学习的小廉
|
1月前
|
存储 算法 索引
【数据结构】——顺序表
【数据结构】——顺序表
努力学习的小廉
66 1
椰椰椰耶
|
1月前
|
存储
【数据结构】线性表和顺序表
【数据结构】线性表和顺序表
椰椰椰耶
22 1
徐霞客320
|
1月前
|
存储
数据结构1——顺序表
数据结构1——顺序表
徐霞客320
17 1

热门文章

最新文章

  • 1
    我花了一夜用数据结构给女朋友写个H5走迷宫游戏
  • 2
    数据结构学习笔记【持续更新】
  • 3
    基于OHCI的USB主机 —— OHCI（自定义数据结构）
  • 4
    【数据结构与算法】一篇文章彻底搞懂二分查找（思路图解+代码优化）两种实现方式，递归与非递归
  • 5
    学数据结构，只需要基本的编程体验
  • 6
    数据结构（2）：栈的原理和实现
  • 7
    【数据结构7】查找
  • 8
    算法导论第十四章 数据结构的扩张
  • 9
    R语言学习笔记（一）数据结构
  • 10
    Smaller And Smarter Python数据结构：自己动手实现栈
  • 1
    `geopandas`是一个开源项目，它为Python提供了地理空间数据处理的能力。它基于`pandas`库，并扩展了其对地理空间数据（如点、线、多边形等）的支持。`GeoDataFrame`是`geopandas`中的核心数据结构，它类似于`pandas`的`DataFrame`，但包含了一个额外的地理列（通常是`geometry`列），用于存储地理空间数据。
    69
  • 2
    “解锁Python高级数据结构新姿势：图的表示与遍历，让你的算法思维跃升新高度
    40
  • 3
    Redis数据结构—跳跃表 skiplist 实现源码分析
    62
  • 4
    逆袭之路！用 Python 玩转图的 DFS 与 BFS，让数据结构难题无处遁形
    65
  • 5
    Python中的列表（List）和元组（Tuple）是两种重要的数据结构
    53
  • 6
    【数据结构OJ题】链表分割
    32
  • 7
    【数据结构常见七大排序（三）上】—交换排序篇【冒泡排序】And【快速排序】
    45
  • 8
    【数据结构常见七大排序（二）】—选择排序篇【直接选择排序】And【堆排序】
    33
  • 9
    【数据结构常见七大排序（一）】—插入排序篇【直接插入排序】And【希尔排序】
    45
  • 10
    【数据结构OJ题】链表的回文结构
    39

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • 机器阅读技术与应用
  • PHP进阶教程 - 由浅入深掌握面向对象开发 - 第二阶段
  • Serverless 赛题设置和解题思路解析
  • 机器学习入门-概念原理及常用算法
  • Go语言完全自学手册图文教程

    • 相关电子书

    更多
  • 如何使用Tair增强数据结构构建丰富在线实时场景
  • Apache Flink 流式应用中状态的数据结构定义升级
  • 图解算法小抄

    • 相关实验场景

    更多
  • 实验手册指导文档
  • 1分钟部署经典小游戏
    • 下一篇
    阿里云OSS设置跨域访问