数据结构之顺序表

最新推荐文章于 2022-10-14 22:38:53 发布
最新推荐文章于 2022-10-14 22:38:53 发布
阅读量142 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43514458/article/details/89606001
版权

顺序表

顺序表是一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据 的增删查改。顺序表又分为静态顺序表和动态顺序表
1、使用静态顺序表存储

typedef int DataType
#define MAX_SIZE 100
struct SeqList{
	DataType array[MAX_SIZE];//用来存储顺序表中的元素
	int size;//顺序表中有效元素的个数
};

因为数组存储的元素是有限的，此处我们定义的是100。数组的空间是固定的，这个就是按静态顺序表存储 的。如果我们此时想存储101个元素，这个时候这个程序就得修改数组的大小了。所以一般情况下我们都采用动态顺序表来存储。
2、使用动态顺序表存储

typedef int DataType;
typedef struct{
     DataType* _array;
     int _capacity;//顺序表的总大小 
     int _size;//顺序表有效元素的个数
}SeqList，*PSeq;

首先我们要先对这个顺序表初始化

void SeqListInit(PSeq ps, int capacity) {
 ps->_array = (DataType*)malloc(sizeof(DataType)*capacity);
 if (ps->_array == NULL) {//对申请空间进行判断，看是否申请成功；
  assert(0);
  return;
 }
 ps->_capacity = capacity;
 ps->_size = 0;//初始化的时候，顺序表中的元素就是0；
}

对顺序表进行增加元素的操作（头插一个元素，尾插一个元素，任意地方插一个元素）

//尾插
void SeqListPushBack(PSeq ps, DataType data) {
 assert(ps);
 //顺序表满的情况
 CheckCapacity(ps);
 ps->_array[ps->_size] = data;
 ps->_size++;
}
//头插
void SeqListPushFront(PSeq ps, DataType data) {
 assert(ps);
 CheckCapacity(ps);
 //将顺序表中所有的元素统一向后搬移一个位置
 for (int i = ps->_size; i > 0; --i) {
  ps->_array[i] = ps->_array[i-1];
 }
 //插入元素
 ps->_array[0] = data;
 ps->_size++;
}
//任意位置插
void SeqListInsert(PSeq ps, int pos, DataType data) {
 assert(ps);
 if (pos < 0|| pos > ps->_size) {
  return;
 }
 for (int i = ps->_size; i > pos; --i) {
  ps->_array[i] = ps->_array[i - 1];
 }
 ps->_array[pos] = data;
 ps->_size++;
}

插入的时候有一个问题就是：如果顺序表中的元素满了，就插不进去了。所以我们在插入之前要对顺序表进行一个检查。

void CheckCapacity(PSeq ps) {
 assert(ps);
 if (ps->_size == ps->_capacity) {
  int newCapacity = ps->_capacity*2;
  //申请新空间
  int* pTemp = (DataType*)malloc(newCapacity * sizeof(DataType));
  if (pTemp == NULL) {
   assert(0);
   return;
  }
  //拷贝元素
  for (int i = 0; i < ps->_size; ++i) {
   pTemp[i] = ps->_array[i];
  }
  //释放旧空间
  free(ps->_array);
  //更新参数
  ps->_array = pTemp;
  ps->_capacity = newCapacity;
 }
}

对顺序表进行删除的操作（头删，尾删，任意位置删除）

//尾删
void SeqListPopBack(PSeq ps) {
 assert(ps);
 if (SeqListEmpty(ps)) {
  return;
 }
 ps->_size--;
 SeqListErase(ps, ps->_size - 1);
}
//头删
void SeqListPopFront(PSeq ps) {
 assert(ps);
 for (int i = 0; i < ps->_size-1; ++i) {
  ps->_array[i] = ps->_array[i+1];
 }
 ps->_size--;
}
//任意地方删除
void SeqListErase(PSeq ps, int pos) {
 assert(ps);
 if (pos < 0 || pos >= ps->_size) {
  return;
 }
 for (int i = pos; i < ps->_size-1; ++i) {
  ps->_array[i] = ps->_array[i + 1];
 }
 ps->_size--;
}

对顺序表进行查找

int SeqListFind(PSeq ps, DataType data) {
 assert(ps);
 for (int i = 0; i < ps->_size; ++i) {
  if (ps->_array[i] == data) {
   return i;
  }
 }
 return -1;
}

移除顺序表中所有值为data的元素

void SeqListRemoveAll(PSeq ps, DataType data) {
 assert(ps);
 int pos = -1;
   while (-1 != (pos = SeqListFind(ps, data))
      {
	  SeqListErase(ps,pos);
      }//时间复杂度o(n^2),算法要进行优化。
 }
 //时间复杂度o(n),空间复杂度o(1).
 void SeqListRemoveAll(PSeq ps, DataType data) {
 assert(ps);
 int count = 0;
 for (int i = 0; i < ps->_size; ++i) {
  if (ps->_array[i] == data) {
   count++;
  } else {
   ps->_array[i - count] = ps->_array[i];
  }
 }
 ps->_size -= count;
}

对顺序表进行清空操作

void SeqListClear(PSeq ps) {
 assert(ps);
 ps->_size = 0;
}

顺序表的整个程序如下

//SeqList.h头文件的代码
#pragma once
typedef int DataType;
//#define MAX_SIZE 100
typedef struct SeqList {
 DataType* _array;//用来存储顺序表中元素
 int _size;//顺序表中有效元素的个数
 int _capacity;///数组所指向空间的大小是多大也就是顺序表的总大小
}SeqList,*PSeq;
void SeqListInit(PSeq ps, int capacity);
void SeqListPushBack(PSeq ps, DataType data);
void SeqListPopBack(PSeq ps);
int SeqListEmpty(PSeq ps);
void SeqListPushFront(PSeq ps, DataType data);
void SeqListPopFront(PSeq ps);
void SeqListInsert(PSeq ps, int pos, DataType data);
void SeqListErase(PSeq ps, int pos);
int SeqListFind(PSeq ps, DataType data);
int SeqListSize(PSeq ps);
int SeqListCapacity(PSeq ps);
void SeqListClear(PSeq ps);
void SeqListRemove(PSeq ps,DataType data);
void SeqListRemoveAll(PSeq ps, DataType data);
void CheckCapacity(PSeq ps);
void SeqListDestroy(PSeq ps);
void TestSeqList();

//SeqList.c文件代码
#include"SeqList.h"
#include<malloc.h>
#include<assert.h>
#include<stdio.h>
#include<stdlib.h>
void SeqListInit(PSeq ps, int capacity) {
 ps->_array = (DataType*)malloc(sizeof(DataType)*capacity);
 if (ps->_array == NULL) {
  assert(0);
  return;
 }
 ps->_capacity = capacity;
 ps->_size = 0;
}
void SeqListPushBack(PSeq ps, DataType data) {
 assert(ps);
 //顺序表满的情况
 CheckCapacity(ps);
 ps->_array[ps->_size] = data;
 ps->_size++;
}
void SeqListPopBack(PSeq ps) {
 assert(ps);
 if (SeqListEmpty(ps)) {
  return;
 }
 ps->_size--;
 SeqListErase(ps, ps->_size - 1);
}

void CheckCapacity(PSeq ps) {
 assert(ps);
 if (ps->_size == ps->_capacity) {
  int newCapacity = ps->_capacity*2;
  //申请新空间
  int* pTemp = (DataType*)malloc(newCapacity * sizeof(DataType));
  if (pTemp == NULL) {
   assert(0);
   return;
  }
  //拷贝元素
  for (int i = 0; i < ps->_size; ++i) {
   pTemp[i] = ps->_array[i];
  }
  //释放旧空间
  free(ps->_array);
  //更新参数
  ps->_array = pTemp;
  ps->_capacity = newCapacity;
 }
}
void SeqListInsert(PSeq ps, int pos, DataType data) {
 assert(ps);
 if (pos < 0|| pos > ps->_size) {
  return;
 }
 for (int i = ps->_size; i > pos; --i) {
  ps->_array[i] = ps->_array[i - 1];
 }
 ps->_array[pos] = data;
 ps->_size++;
}
void SeqListErase(PSeq ps, int pos) {
 assert(ps);
 if (pos < 0 || pos >= ps->_size) {
  return;
 }
 for (int i = pos; i < ps->_size-1; ++i) {
  ps->_array[i] = ps->_array[i + 1];
 }
 ps->_size--;
}

int SeqListFind(PSeq ps, DataType data) {
 assert(ps);
 for (int i = 0; i < ps->_size; ++i) {
  if (ps->_array[i] == data) {
   return i;
  }
 }
 return -1;
}
int SeqListSize(PSeq ps) {
 assert(ps);
 return ps->_size;
}
int SeqListCapacity(PSeq ps) {
 assert(ps);
 return ps->_capacity;
}
int SeqListEmpty(PSeq ps) {
 assert(ps);
 return 0 == ps->_size;
}
void SeqListPushFront(PSeq ps, DataType data) {
 assert(ps);
 CheckCapacity(ps);
 //将顺序表中所有的元素统一向后搬移一个位置
 for (int i = ps->_size; i > 0; --i) {
  ps->_array[i] = ps->_array[i-1];
 }
 //插入元素
 ps->_array[0] = data;
 ps->_size++;
}
void SeqListPopFront(PSeq ps) {
 assert(ps);
 for (int i = 0; i < ps->_size-1; ++i) {
  ps->_array[i] = ps->_array[i+1];
 }
 ps->_size--;
}
void SeqListClear(PSeq ps) {
 assert(ps);
 ps->_size = 0;
}

void SeqListRemove(PSeq ps, DataType data) {
 SeqListErase(ps, SeqListFind(ps, data));
}
void SeqListRemoveAll(PSeq ps, DataType data) {
 /*int pos = -1;
 while (-1 != (pos = SeqListFind(ps, data)))
 {
  SeqListErase(ps,pos);
 }
*/
 assert(ps);
 int count = 0;
 for (int i = 0; i < ps->_size; ++i) {
  if (ps->_array[i] == data) {
   count++;
  } else {
   ps->_array[i - count] = ps->_array[i];
  }
 }
 ps->_size -= count;
}
void SeqListDestroy(PSeq ps) {
 if (ps->_array) {
  free(ps->_array);
  ps->_array = NULL;
  ps->_capacity = 0;
  ps->_size = 0;
 }
}
void SeqListPrint(PSeq ps) {
 for (int i = 0; i < ps->_size; ++i) {
  printf("%d ", ps->_array[i]);
 }
 printf("\n");
}

void TestSeqList() {
 SeqList s;
 int pos = -1;
 SeqListInit(&s, 10);
 SeqListPushBack(&s, 1);
 SeqListPushBack(&s, 2);
 SeqListPushBack(&s, 3);
 SeqListPushBack(&s, 4);
 SeqListPushBack(&s, 5);
 SeqListPrint(&s);
 SeqListPopBack(&s);
 SeqListPrint(&s);
 SeqListPushFront(&s, 0);
 SeqListPrint(&s);
 SeqListPopFront(&s);
 SeqListPrint(&s);
 SeqListInsert(&s,1,5);
 SeqListPrint(&s);

pos = SeqListFind(&s, 5);
 if (pos != -1) {
  printf("5 is in %d!!!\n", pos);
 } else {
  printf("5 is not in  %d!!!\n", pos);
 }
 SeqListErase(&s, 1);
 pos = SeqListFind(&s, 5);
 if (pos != -1) {
  printf("5 is in %d!!!\n", pos);
 } else {
  printf("5 is not in  %d!!!\n", pos);
 }
 SeqListPrint(&s);
 printf("size = %d\n", SeqListSize(&s));
 printf("capacity = %d\n", SeqListCapacity(&s));
 SeqListDestroy(&s);
}
int main() {
 TestSeqList();
 system("pause");
 return 0;
}
Solieaor
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之顺序表.rar
04-07
数据结构之顺序表
数据结构之顺序表的插入
m0_52201270的博客
12-15 3731
数据结构之链表的插入
数据结构之顺序表（C语言）
weixin_50803498的博客
10-14 2208
线性表、顺序表、线性表存储结构、顺序表初始化、顺序表数据插入、顺序表数据删除、按位插入、按位删除、顺序表的使用场景、适合场景、不适合场景
【数据结构】顺序表
East-sunrise的博客
08-15 4177
顺序表带你走进数据结构世界🎈
超详细讲解数据结构之顺序表
bit_xwg的博客
03-15 2581
超详细讲解数据结构之顺序表顺序表概念静态顺序表动态顺序表动态循序表的概念及构造动态顺序表接口的实现检查顺序表的容量尾插与尾删头插与头删 顺序表 概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。 顺序表一般分为静态顺序表和动态顺序表。 静态顺序表 静态顺序表是使用定长数组存储元素。 简单静态顺序表结构体的初始化： #define N 7 typedef int SLDataType; struct Seqlist { SLDataTy
php数据结构之顺序链表与链式线性表示例
10-18
主要介绍了php数据结构之顺序链表与链式线性表,结合实例形式较为详细的分析了php实现顺序链表与链式线性表的各种常用操作技巧,需要的朋友可以参考下
C#数据结构之顺序表(SeqList)实例详解
01-01
本文实例讲述了C#数据结构之顺序表(SeqList)实现方法。分享给大家供大家参考，具体如下： 线性结构(Linear Stucture)是数据结构(Data Structure)中最基本的结构，其特征用图形表示如下： 即：每个元素前面有且只有...
树和二叉树的知识点总结
qq_43514458的博客
05-31 3265
什么是树？ 树是一种非线性的结构，它是由n(n>=0)个有限结点组成一个具有层次关系的集合。我们平常在生活中所看到的树是根在下，枝叶在上面。而对于数据结构中的树则是根朝上，枝叶朝下，正好与生活中的树的结构相反。 树的特点 每个结点有零个或多个子节点 每一个非根结点有且只有一个父节点 只有根节点没有父节点 除了根结点外，每个子节点可以分为多个不相交的子树 叶子节点点 接下来我们从这个图来说...
顺序表和链表对比
qq_43514458的博客
11-02 508
1、底层结构上 顺序表底层结构是一段连续的空间(也可以这么说顺序表底层空间是逻辑上和物理上都是连续的） 链表底层结构是动态的创建不连续的空间(链表底层是逻辑上连续，物理上不连续) 2、随机访问 顺序表支持随机访问，访问某个元素效率为o（1） 链表不支持随机访问，访问某个元素的效率为o(n) 3、插入和删除效率 顺序表的插入删除效率低，需要搬移元素，时间复杂度为o(n)，并且再插入的时候还有可能需要...
二叉树链式结构的实现
qq_43514458的博客
05-31 451
对于二叉树链式结构的实现，理解二叉树的概念至关重要。在二叉树的创建以及求二叉树叶子节点的个数等其他操作时，都是先从二叉树的概念入手，一步一步完成二叉树的创建及其他操作，接下来看一下二叉树的概念 二叉树的概念 空树 根节点+根节点的左子树+根节点的右子树 接下来是二叉树的具体实现 #pragma once typedef char DataType; typedef struct BNo...
时间复杂度和空间复杂度知识点总结
qq_43514458的博客
04-26 373
算法：为了解决一个问题，你来写一个解决这个问题的一个方法。也就是一个一系列的计算步骤，用来将输入数据转化为输出结果。 那么怎么样才能知道你写的这个算法是好的还是坏的？ 时间复杂度和空间复杂度就是衡量一个算法好坏的标准。时间复杂度主要衡量的就是算法的运行速度，而空间复杂度主要衡量的就是一个算法所需要的一个额外空间。 时间复杂度 算法的时间复杂度是一个函数基本总的执行次数，也就是一个算法...
哈希表之闭散列
qq_43514458的博客
08-02 302
闭散列（即开放地址法）：当发生哈希冲突时，如果该哈希表还没有被填满，那么就把该元素放到哈希表的下一个空闲的位置。 代码实现思路： 哈希表结构的封装 首先我们能够知道哈希表是否冲突。我们使用状态标记来查看哈希表是否冲突。那么就有三种状态：当前位置空着，当前位置存在元素，当前元素已经被删除(这个一会会在删除的时候讲到) 接下来我们要对哈希表每一个存储位置空间去进行描述；哈希表每一个存储位置都有哪些元素：key、value、状态标记； 最后哈希表的构造。整个哈希表是由一个个存储位置构成的，包括哈希表当前有效的
链表之C++实现
qq_43514458的博客
11-01 120
Slist.hpp #include<iostream> using namespace std; typedef struct Node{ struct Node* next; int data; }Node; class Slist{ public: Slist() :head(nullptr){} Node* BuySlistNode(const int ...
队列之C++实现
qq_43514458的博客
11-03 112
Queue.hpp #include<iostream> using namespace std; typedef struct QueueNode{ QueueNode() :next(nullptr) {} struct QueueNode* next; int data; }Node; class Queue{ public: Queue() ...
数据结构之链表
qq_43514458的博客
04-30 102
链表 顺序表的增容需要malloc一段新空间，如果这个空间足够大，我们用不完这些空间势必就会造成空间的浪费。而且我们增容之后还要拷贝原空间的数据，释放旧空间，这样操作起来也比较麻烦。对于链表就恰恰能够解决这个问题。 单链表 1、逻辑上连续，位置上可以不连续的存储方式。 2、单链表由无数个结点组成，每个结点都有数据段和指针域组成。其中数据段存储数据，指针域存储后继的地址。 3、每个结点最多只能有一个...
顺序表之C++实现
qq_43514458的博客
10-30 81
#include<iostream> using namespace std; template<class T> class SeqList{ public: SeqList(T* array,int size) :_array(new T[size]) ,_capacity(size) ,_size(0) { for(int i=...
数据结构顺序表C++
最新发布
09-06
顺序表是一种常见的数据结构，用于存储一组具有相同类型的元素。它的基本操作包括创建、查找、插入和删除等。 在C语言中，可以通过使用数组来实现顺序表。我们可以定义一个数组来存储顺序表的元素，然后通过索引来访问和操作其中的元素。引用中的代码展示了一个简单的顺序表的例子，它使用了C语言来实现。在这个例子中，我们可以看到如何创建一个顺序表、插入元素、删除元素以及查找元素的前驱和后继。 引用中的代码是一个测试顺序表基本操作的例子。它使用了一个自定义的List类来实现顺序表，并对其进行了各种操作，包括插入元素、删除元素、查找元素的前驱和后继以及遍历整个顺序表。 顺序表的结构体定义可以根据具体的需求进行定义。在引用中的代码中，定义了一个结构体ConnTimeout，其中包含了一个int类型的fd和一个time_t类型的timeout成员变量。这个结构体可以用来表示连接超时的信息。 总而言之，顺序表是一种常见的数据结构，可以通过使用数组来实现。在C语言中，可以使用数组和相关的操作来创建、查找、插入和删除顺序表中的元素。结构体的定义可以根据具体的需求进行自定义。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [数据结构顺序表c++代码](https://download.csdn.net/download/qq_46546083/13458006)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *2* [C++数据结构之顺序表（模板类实现）](https://blog.csdn.net/sagjhdj/article/details/123260460)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *3* [【数据结构】顺序表(C++)](https://blog.csdn.net/qq_51604330/article/details/120600041)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值