学习顺序表相关知识，制作一个简易的“动态顺序表”操作（增删查改）

最新推荐文章于 2022-10-22 10:47:20 发布
最新推荐文章于 2022-10-22 10:47:20 发布
阅读量275 收藏 1
点赞数 1
分类专栏： C语言 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sakeww/article/details/106919875
版权

学习顺序表相关知识，制作一个简易操作（增删查改）

//test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"SeqList.h"

int main()
{
	TestSeqList();
	return 0;
}

SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include <assert.h>    //assert
#include"SeqList.h"
#include<malloc.h>//malloc
#include<stdio.h>//printf NULL 

//          需要改变的顺序表   初始容量大小
void SeqListInit(SeqList* s, int initCapacity) //初始化
{
	assert(s);
	initCapacity = initCapacity <= 3 ? 3 : initCapacity;
	//10个 SDataType------>总的字节数：sizeof(SDataType)*10
	s->array = (SDataType*)malloc(sizeof(SDataType)*initCapacity);//initCapacity这个不要忘记乘，如果没有这个，则在插入的过程中会崩溃。
	if (NULL == s->array)//判断空间是否申请成功
		return;
	s->capacity = initCapacity;
	s->size = 0;

}

//检查是否需要进行扩容
int CheckCapacity(SeqList* s)
{
	assert(s);
	if (s->size == s->capacity)
	{
		//将新空间按照两倍的方式进行扩容
		int newCapacity = s->capacity * 2;
		s->array - (SDataType*)realloc(s->array, newCapacity*sizeof(SDataType));
		if (NULL == s->array)
			return 0;

		s->capacity = newCapacity;

		/*
		//申请更大的空间
		SDataType* temp = (SDataType*)malloc(newCapacity*sizeof(SDataType));
		if (NULL == temp)
			return 0;
		//拷贝元素
		memcpy(temp, s->array, s->capacity*sizeof(SDataType));

		//释放旧空间
		free(s->array);

		//使用新空间
		s->array = temp;
		s->capacity = newCapacity;
        */
	}
	return 1;

}
//图例解释：
//              size
//【1 2 3 4 5 6】
//              capacity
//此时size和capacity在同一个位置

//给出更大的空间：将新空间的大小给成旧空间大小的2倍（常规）
//给大了，浪费空间，给小了，以后可能多次申请空间，所以常规定为2倍。
//【   】
//将旧空间的元素搬移到新空间中，然后将旧空间释放掉

//总结过程：
//1.开辟新空间
//2.拷贝元素
//3.释放旧空间
//4.使用新空间

//延申：malloc calloc realloc之间的区别
//相同点：1.都是c标准库提供的动态内存申请的库函数
//        2.返回值都是void*，因此在使用时必须进行强制类型转换
//        3.申请空间成功，返回值空间的首地址，失败则返回NULL，因此在使用时必须进行判空
//        4.申请的空间都在堆上，使用完成后必须free进行释放，否则就会存在内存泄漏

//不同：
//malloc：参数申请空间大小的字节数，直接将空间申请成功返回给用户
//calloc：有两个函数--参数1：表示元素个数，参数二：表示元素类型
//        功能：根据所给的参数来申请孔家，并将空间初始化为零
//                          size_t 无符号整形
//void* realloc（void* ptr，size_t size) ：将ptr所指向的空间调整到size个字节
//1.ptr == NULL		realloc函数就相当于malloc

//2.ptr ！= NULL，realloc将ptr指向的空间调整到size字节
//  假设：ptr指向的空间大小为oldsize个字节
//        （1）.size<=oldsize:将ptr指向的空间缩小到size字节，然后返回空间的首地址
//        （2）.size>oldsize：将ptr指向的空间扩大到size个字节
//          1）大一点点
//             原来的空间后面还有空余位置
//             对空间进行延申，然后返回原空间的首地址
//          2）大了许多
//             1.申请新空间
//             2.拷贝元素
//             3.释放旧空间
//             4.返回新空间的首地址
//             
//
//【  原来的空间                】
//【        20                  】
//【                            】
//【别人申请的空间但是已经归还了】
//【          10                】 
//【                            】
//【别人的空间                  】
//【                            】
//【                            】


//尾插   顺序表里面插入一些元素
//1.不需要扩容，直接将元素插入在size的位置--->O(1)
//2.需要扩容
void SeqListPushBack(SeqList* s, SDataType data)
{
	//assert(s);
	//s->array[s->size] = data;
	//s->size++;//一般情况我们将这行代码和上一行进行合并
	//即：
	assert(s);

	if (!CheckCapacity(s))
		return;

	s->array[s->size++] = data;
}
//这样写有点问题，我们必须保证空间足够，才能一直插入。


//举例：2 
//array       size = 5
//【1 2 3 4 5      】capacity(总空间大小)
//  0 1 2 3 4 
//尾插：将新元素放到5后面，此时新元素在的位置时size，然后size加一，



//尾删     //方法：将最后一个元素访问不到，（不让他在size的范围之内），时间复杂度O（1）
void SeqListPopBack(SeqList* s)
{
	if (SeqListEmpty(s))
		return;
	s->size--;
}

//头插
//1.先检测是否需要扩容--如果需要则扩容
//2.将顺序表中所有元素整体往后移一位
//3.将data插入顺序表的起始位置
//时间复杂度O(N)
void SeqListPushFront(SeqList* s, SDataType data)
{
	//插入都需要检查是否需要扩容

	if (!CheckCapacity(s))
		return;

	//1.将顺序表中的所有元素向后搬移一个位置
	for (int i = s->size - 1; i >= 0; i--)
		s->array[i+1] = s->array[i];
	//在0号位置插入data
	s->array[0] = data;
	s->size++;	

}

//头删--除第一个元素外，剩余元素整体往搬移一个位置--时间复杂夫O(N)
//顺序表不适合做头插和头删的工作，效率太低------链表适合做
void SeqListPopFront(SeqList* s)
{
	if (SeqListEmpty(s))
		return;
	for (int i = 1; i < s->size; i++)
		s->array[i - 1] = s->array[i];
	s->size--;
}

//任意位置的插入
//1.必须保证pos在[0，size]
//2.检测是否需要扩容
//3.将[pos,size]位置的元素整体往后搬移一个位置
//4.在pos的位置插入新元素
void SeqListInsert(SeqList* s, int pos, SDataType data)
{
	assert(s);
	if (pos >= 0 && pos > s->size)
		return;
	//检测是否需要扩容 

	if (!CheckCapacity(s))
		return;

	//将[pos,size]位置的元素整体往后搬移一个位置
	//i:表示需要搬移元素的下标
	for (int i = s->size - 1; i >= pos; --i)
		s->array[i+1] = s->array[i];

	s->array[pos] = data;
	s->size++;
}
//图像演示：
//（1）
//【1 2 3 4 5 6 7         】
//     丨
//     pos
//我们需要在pos指向的位置插入一个元素0
//不能直接插入，直接插，会导致元素0直接覆盖掉3这个数字
//我们需要：将2以后的所有数字往后搬移一个位置，然后将0插入进去
//（2）
//【1 2 3 4 5 6 7  _ _       】
//                     丨
//                     pos
//我们需要在pos指向的位置插入一个元素0
//这种插入没有意义
//没有插入的时候size在7的后一位
//你在这个位置插入元素，那么size是 向后移一位，还是不移动，还是两位（在插入元素0后面）？
//1.不移动size，此时0访问不到，此时插入元素0，则没有意义
//2.给加一，7后面没有有效元素
//3.如果向后移动两位，此时零可以访问到，但是七后面没有有效元素
//  此时顺序表一共有八个元素，但是size却是11
//因此：pos是有限制条件的他在[0，size]

//任意位置的删除
//注意：进行删除的时候需要判断pos的位置是否在[0,size）
//将pos之后的所有元素往前整体搬移一个位置,需要删除的元素就会直接被删除
void SeqListErase(SeqList* s, int pos)
{
	assert(s);
	if (pos < 0 || pos >= s->size)
		return;
	for (int i = pos + 1; i < s->size; ++i)
		s->array[i - 1] = s->array[i];
	s->size--;
}

//顺序表里面有效元素个数
int SeqListSize(SeqList* s)
{
	assert(s);//对顺序表里面的参数进行检测
	return s->size;
}

//顺序表里面的容量
int SeqListCapacity(SeqList* s)
{
	assert(s);
	return s->capacity;
}

//顺序表是否为NULL
int SeqListEmpty(SeqList* s)
{
	assert(s);
	return 0 == s->size;//判断size是否为零
}

//将顺序表里面的元素进行清空
void SeqListClear(SeqList* s)
{
	assert(s);
	s->size = 0;
}

//顺序表里面查找值为data的元素是否再顺序表中，如果在返回下标，否则返回-1
int SeqListFind(SeqList* s, SDataType data)
{
	assert(s);
	for (int i = 0; i < s->size; ++i)
	{
		if (s->array[i] == data)
		return i;
	}
	return -1;
}

//将当前的顺序表销毁掉
void SeqListDestroy(SeqList* s)
{
	assert(s);
	if (s->array)
	{
		free(s->array);
		s->array = NULL;
		s->capacity = 0;
		s->size = 0;
	}
}

//测试方法：
void  SeqListPrint(SeqList* s)
{
	assert(s);
	for (int i = 0; i < s->size; ++i)
		printf("%d ", s->array[i]);
	printf("\n");
}

void Test1()
{
	SeqList s;
	SeqListInit(&s, 10);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 6);

	printf("&d\n", SeqListSize(&s));
	printf("&d\n", SeqListCapacity(&s));
	SeqListPrint(&s);

	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);

	printf("&d\n", SeqListSize(&s));
	printf("&d\n", SeqListCapacity(&s));
	SeqListPrint(&s);
	
	SeqListPushFront(&s, 0);
	SeqListPrint(&s);

	SeqListPopFront(&s);
	SeqListPrint(&s);

	SeqListDestroy(&s);
}

void Test2()
{
	//保证顺序表里面含有六个元素
	SeqList s;
	SeqListInit(&s, 2);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 6);
	SeqListPrint(&s);

	//任意位置的插入:在三号位置插入零
	SeqListInsert(&s, 3, 0);
	SeqListPrint(&s);


	//删除第一个元素4，你的顺序表中第一个元素四（有可能你的顺序表中含有多个四）
	SeqListErase(&s, SeqListFind(&s, 4));
	SeqListPrint(&s);

}

void TestSeqList()
{
	//Test1();
	Test2(); 
}

//注意：扩容程序最后才补充的，所以有一些语句有点不通顺
//      （代码都是一点一点改进成的，没有人的代码直接就能写成，除了大佬，我这样写，也有益于我们学习）
//       这点问题如果给你带来不便，请原谅，（直接把注释删除了，就行了）

Seqlist.h

 #pragma once//(防止多次包含)



//顺序表只能存储一种类型，当我们需要改变这个类型的时候，很麻烦，我们只需要将类型的名字改成（SDataType）便可
typedef int SDataType; //这个顺序表可以存放int类型
//typedef double SDataType; //这个顺序表可以存放double类型

//我们定义的这种结构体类型，在c语言中使用时必须要加入struct
//因为麻烦，所以我们将其进行下面的改变
//struct SeqList
//{
//	int* array;//存放元素的空间，不够时申请更大的
//	int capacity;//空间总大小  capacity：容量
//	int size;//空间中有效元素的个数
//};

//【2】我们还有另外一种方法
//typedef 后面的
//结构体类型：
//struct SeqList
//{
//	int* array;//存放元素的空间，不够时申请更大的
//	int capacity;//空间总大小  capacity：容量
//	int size;//空间中有效元素的个数
//};
//我们需要将其命名为SeqList，即下面：

typedef struct SeqList
{
	int* array;//存放元素的空间，不够时申请更大的
	int capacity;//空间总大小  capacity：容量
	int size;//空间中有效元素的个数
}SeqList;


//【1】
//c语言里面你自己定义的结构体，你要用的时候需要假如struct
//而我们每次使用自己的结构体时，都需要用struct，麻烦，所以我们将struct SeqList命名为SeqList
//typedef struct SeqList SeqList;

//          需要改变的顺序表   初始容量大小
void SeqListInit(SeqList* s, int initCapacity);

//尾插   顺序表里面插入一些元素
void SeqListPushBack(SeqList* s, SDataType data);

//尾删
void SeqListPopBack(SeqList* s);

//头插
void SeqListPushFront(SeqList* s, SDataType data);

//头删
void SeqListPopFront(SeqList* s);

//任意位置的插入
void SeqListInsert(SeqList* psl, int pos, SDataType x);

//任意位置的删除
void SeqListErase(SeqList* psl, int pos);

//顺序表里面有效元素个数
int SeqListSize(SeqList* s);

//顺序表里面的容量
int SeqListCapacity(SeqList* s);

//顺序表是否为NULL
int SeqListEmpty(SeqList* s);

//将顺序表里面的元素进行清空
void SeqListClear(SeqList* s);
 
//顺序表里面查找值为data的元素是否再顺序表中，如果在返回下标，否则返回-1
int SeqListFind(SeqList* s, SDataType data);

//将当前的顺序表销毁掉
void SeqListDestroy(SeqList* s);


//测试方法
void TestSeqList();

//萌新一枚，请多多指教

sakeww
关注
专栏目录
（二）数据类型（data type）
云飞扬0o的博客
12-09 1万+
数据类型（data type）数据类型分为基本数据类型和引用数据类型。1、基本数据类型8种基本数据类型。各个基本类型之间是平等的，不存在大小和父子类的关系。它们之间的大小只是从存储数据所占用的空间来比较的。 1.数值型​ 1.在Java种，整数默认是int类型，小数默认为bouble类型。​ 2.如果一个整数超过了int的取值范围，需要加上L/l作为结尾标识，表示是一个long类型的数据。​
SSM框架整合--实现简单的增删改查(商品管理系统)
guolin的博客
04-10 3426
SSM框架整合步骤 1：搭建一个web工程，将所需的jar包放进去 2，创建数据库，创建表 插入2条初始数据进去 INSERT INTO product VALUE(NULL,"手机",899,2); INSERT INTO product VALUE(NULL,"电视",1299,5); 有了数据之后，将实体类创建出来 package com.jgl.model; p...
栈和队列的面试题
yulong__li的博客
09-28 150
栈 #pragma once #include &lt;assert.h&gt; #include &lt;stdio.h&gt; typedef int SDataType; #define MAX_SIZE (100) typedef struct Stack { SDataType array[MAX_SIZE]; int top; // 起了个别名，含义还是 size }...
数据结构：动态栈
weixin_44779591的博客
05-22 230
动态栈 实现基于动态栈的以下操作： 栈的初始化 入栈 出栈 获取栈顶元素 有效元素个数 判断是否为空 销毁栈 代码如下： 引入头文件，定义动态栈 #pragma once typedef int SDataType; typedef struct Stack { SDataType* _array; int _capacity; int _size; // 表示栈中有效元素的个数 代...
数据结构之栈的基本操作（顺序栈）
weixin_45945300的博客
12-22 2400
数据结构之栈 语言版本 特点：后进先出（LIFO:last in,first out) 基本操作：栈的初始化、判断空、栈满、取栈顶的元素、在栈顶进行插入和删除； 在栈顶插入元素称为入栈、在栈顶删除元素成为出栈； 在这里插入代码片 typedef struct{ SDatatype *base;//栈底指针 SDatatape *top;//栈顶指针 int StackSize;//栈中定义内存大小 }SqStack; 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markd
Verilog 序列信号发生器的三种设计思路
qq_38573940的博客
11-28 1万+
在数字电路中， 序列信号是指在同步脉冲作用下循环地产生一串周期性的二进制信号.能产生这种信号的逻辑器件就称为序列信号发生器.根据结构不同,它可分为反馈移位型和计数型两种。 移位型序列信号发生器是由移位寄存器和组合电路两部分构成，组合电路的输出，作为移位寄存器的串行输入。 　　计数型序列信号发生器能产生多组序列信号,这是移位型发生器所没有的功能.计数型序列信号发生器是由计数器和组合电路构成的。 　　本实验的目的就是设计一个序列信号发生器。设计产生序列11100100、11100100、···的计数型序列信号发
数据结构 java版 简易通讯录
12-27
最简单的实现通讯录，供参考学习扩展，本人也是初学望交流
C语言实现一个简易通讯录
08-18
C语言实现一个简易通讯录是基于C语言的IO文件操作和数据结构里的顺序表实现的。这个通讯录主要提供了以下几个功能： 1. 信息的添加：用户可以添加新的联系人信息，包括姓名、性别、电话和地址等信息。 2. 信息的...
JavaEE + Oracle + Spring Boot + Mybatis + Maven 开发简易版银行管理系统（附源码）
渣渣的夏天
04-18 4679
JavaEE + Oracle + Spring Boot + Mybatis + Maven 开发的简易版银行管理系统，本文主要介绍了一个用 JavaEE + Oracle 开发的简易版银行信息管理系统，具备用户管理、银行卡管理、存取款管理、贷款管理、业务提醒、统计查询等功能。用到了Oracle数据库存储过程、触发器等功能。展示了各个页面效果和开发的流程、步骤、总结。
用C语言实现一个简易通讯录
GangStudyIT的博客
05-06 1545
通讯录 实现通讯录，是基于c语言的IO文件操作、数据结构里面的顺序表实现。 具体功能 实现了 信息的添加 信息的显示 信息的修改（修改单一属性） 将内存中的信息保存到文件中去 将文件中的信息加载到内存中（每次程序运行数据就会丢失） 信息的删除 信息的查找（按照各自的属性查找） 给每一条信息设置了唯一的标识id 通讯录的销毁 头文件中的声明 在c语言中我们采用结构体来记录每一个人...
Python DataType（数据类型）
遇见1995
07-27 2万+
简述 变量：指代任意一个数，或其他数据类型 变量名：大小写英文、数字和下划线（_）的组合，且不能用数字开头   Python主要的数据类型有如下：（允许自定义数据类型） 整数：0xff00（十六进制）、10 浮点数：1.23、1.23e9（科学计数法） 字符串："abc"、‘abc’（用“双引号”或'单引号'括起来） 布尔值：True、False（0、空字符串、None=&gt; ...
单链表基本操作--数据结构
Angelxinjun的博客
03-23 486
单链表基本操作–数据结构 链表是一种物理存储结构上非连续、非顺序的数据存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序来形成的。 单链表分为两种：带头节点和不带头结点。在这里，主要介绍不带头结点的单链表的基本操作。 头文件：SList.h typedef int SDataType; typedef struct SListNode//定义结点 { SDataType data;//值域 ...
$.ajax的dataType属性
热门推荐
hy340881的博客
07-25 5万+
var url= '/merchant/updateMerchant'; $.ajax({ type : 'post', url : url, dataType : 'json', data : $("#merform").serialize(), success : function(jsonStr) { ...
数据类型（Data Type）
weixin_46219545的博客
04-11 1610
数据类型 MySQL里有哪些数据类型？ MySQL支持几种类别的SQL数据类型：数值类型，日期和时间类型，字符串（字符和字节）类型，空间类型和JSON数据类型。 创建一个表格 root@nongda 11:30 mysql>create table student_inform( -> id int(6) primary key, -> name varchar(20), -> sex char(1), -> birth_date date,
datatype(数据类型)类（构造函数重载和调用）
luck_liao的博客
05-17 5848
【问题描述】声明一个datatype(数据类型)类，该类能够根据用户的输入，确定输入的数据类型，能处理包含字符型、整形、浮点型3种类型的数据，并给出合理的输出。 提示：需要进行构造函数的重载 【输入形式】给用户选择，当输入1时，选择输入整型；输入2时，输入字符型；选择3时，输入浮点型。不考虑其他错误情况 【输出形式】输入该数据以及该数据的类型 【样例输入1】 2 c 【样例输出1】character:c 【样例输入2】 1 12 【样例输出2】int:12 【样例输入3】 3 1.44F 【样例输出3】fl
顺序表和链表面试题（练习题）
最新发布
baotu的博客
10-22 587
解析：链表的插入和删除不是所有情况下都比顺序表快，比如尾插尾删，顺序表的时间复杂度为O（1），并且如果是单链表，如果要在中间某个节点的前面插入/删除一个节点，则需要遍历。B错误：链表中的元素在内存中不一定连续，因为new的时候，会从堆上分配空间，具体分配出来的空间是否每次都连续，这个不一定。A正确：链表中节点之间是通过next引用相互指向的，故插入或者删除元素时只需要修改几个引用的指向即可，不需要搬移元素。C错误：链表的空间不连续，插入时也不需要扩容之类的，因此不需要事先预估存储空间大小。
动态顺序表实现
vm04580
01-31 460
动态顺序表相比于静态顺序表加入了扩容机制，在进行所有插入操作是都必须判断是否需要扩容 结构体： typedef int DataType; #define INIT_CAPACITY (3) typedef struct SeqListD { DataType * parray; int capacity; // 当前容量 等于 静态顺序表 MAX_SIZE int size; ...
c语言实现动态顺序表的增删查改
清欢Allen的技术博客
05-03 1127
首先呢，我们要创建一个顺序表 为了以后更好的写，我们可以把这个结构体重定义为SL； 首先要对结构体进行初始化 我们是通过指向结构体指针来找到结构体对应的对象来进行初始化的； 尾插的实现：SLPushBack 当然了，尾插一定要考虑顺序表的容量与所放个数的大小，必要时要进行扩容； 以下便是CheckCapacity函数的实现啦！ 扩容呢，先要确定需要让新容量newcapacity的大小，然后再用realloc函数进行扩容；在进行扩容时要进行对ptr是否为空指针的判断；为空...
顺序表的基本操作之插入，删除与查找
weixin_45632016的博客
07-23 3800
数据结构学习：顺序表的基本操作之插入与删除 在顺序表当中插入元素 ListInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定元素e 插入位置后面的元素一次向后移动一位 先定义一个顺序表 #define MaxSize 10 //定义最大长度 typedef struct{ int data[MaxSize]; //采用静态数组来存放数据元素,ElemType为数据类型in int length; //顺序表的当前长度 }SqList; //定义结构体顺序表的名称为S
Java实现顺序表：增删查改操作详解
`contains(int toValue)`方法返回一个布尔值，表示顺序表是否包含`toValue`。这里假设始终包含，实际实现时应遍历数组，检查每个元素是否等于`toValue`。 查找元素位置`indexOf(int toValue)` `indexOf(int toValue...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值