顺序表的实现

已于 2023-10-31 17:13:25 修改
阅读量43 收藏
点赞数
文章标签： 数据结构
于 2023-10-31 16:45:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77529683/article/details/134132452
版权

目录

一、线性表的概念

二、顺序表

2.1概念

2.2动态实现

1.定义：

2.初始化和销毁：

3.增容

4.尾增尾删：

5.首增首删：

6.查找

7.在pos位置插入和删除

8.打印

全部代码：

顺序表是线性表的一种，我们需要先大概了解一下线性表。

一、线性表的概念

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


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

二、顺序表

2.1概念

顺序表是用一段物理地址连续的存储单元，也就是在内存上是连续存储的，通常使用数组存储或开辟一块空间来对这块空间上的数据进行增删查改。

顺序表又分两种静态和动态，静态是不可对空间进行增加的，动态可以。通常都是使用动态居多。

2.2动态实现

1.定义：

typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;

SLDateype：后面增加内存时，还会在用到元素的类型，任何类型都是可以使用顺序表的，所以重新定义类型名会方便使用。

size：存放当前顺序表使用的元素个数。

capacity：存放开辟的内存大小。

2.初始化和销毁：

//初始化
void SeqListInit(SeqList* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->size = 0;
}

初始化时不需要为a开辟空间，在增加元素时在开辟。

//销毁
void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	if(ps->a!=NULL)
	{
		free(ps->a);
		ps->a = NULL;
		ps->capacity = 0;
		ps->size = 0;
	}
}

3.增容

void SLCheckCapacity(SeqList* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SeqList* p = (SeqList*)realloc(ps->a, sizeof(SLDateType) * newcapacity);
		if (p == NULL)
		{
			perror("realloc");
			return;
		}
		ps->capacity = newcapacity;
		ps->a = p;
	}
}

在增加元素的每个函数内都放入一个增容函数来扩容。

先利用三木操作符来判断，表里没有内容先开辟4个字节来用，表里又内容开辟原有空间的2倍。realloc开辟空间后先放入一个SeqList指针内，判断这个指针是否为空开辟失败再进行赋值，这样可以防止开辟失败将原来的数据丢失。

4.尾增尾删：

//尾增
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}
//尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->size);
	ps->size--;
}

删除元素时要判断size是否为0，是就直接提醒。

5.首增首删：

//首增
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

首增要将所有数据向后移动一位，后末尾开始移动，如果从前开始移动就会覆盖掉接下来将要移动的数据。

//首删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size);
	int end = 0;
	while (end<ps->size-1)
	{
		ps->a[end] = ps->a[end + 1];
		end++;
	}
	ps->size--;
}

6.查找

int SeqListFind(SeqList* ps, SLDateType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
			return i;
	}
	return -1;
}

7.在pos位置插入和删除

//插入
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}
//删除
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	int end = pos;
	while (end < ps->size-1)
	{
		ps->a[end] = ps->a[end+1];
		end++;
	}
	ps->size--;
}

这里在插删和首增首删的逻辑基本一样，对插入删除后的数据进行移动。

8.打印

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

全部代码：

SeqList.h：

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;

// 对数据的管理:增删查改 

//初始化顺序表
void SeqListInit(SeqList* ps);
//顺序表销毁
void SeqListDestroy(SeqList* ps);

//打印顺序表
void SeqListPrint(SeqList* ps);
//尾增元素
void SeqListPushBack(SeqList* ps, SLDateType x);
//首增元素
void SeqListPushFront(SeqList* ps, SLDateType x);
//删除首元素
void SeqListPopFront(SeqList* ps);
//删除尾元素
void SeqListPopBack(SeqList* ps);

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

SeqList.c：
 

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include"SeqList.h"
void SeqListInit(SeqList* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->size = 0;
}

void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	if(ps->a!=NULL)
	{
		free(ps->a);
		ps->a = NULL;
		ps->capacity = 0;
		ps->size = 0;
	}
}

void SLCheckCapacity(SeqList* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SeqList* p = (SeqList*)realloc(ps->a, sizeof(SLDateType) * newcapacity);
		if (p == NULL)
		{
			perror("realloc");
			return;
		}
		ps->capacity = newcapacity;
		ps->a = p;
	}
}

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

void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->size);
	ps->size--;
}

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

void SeqListPushFront(SeqList* ps, SLDateType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size);
	int end = 0;
	while (end<ps->size-1)
	{
		ps->a[end] = ps->a[end + 1];
		end++;
	}
	ps->size--;
}

int SeqListFind(SeqList* ps, SLDateType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
			return i;
	}
	return -1;
}

void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	int end = pos;
	while (end < ps->size-1)
	{
		ps->a[end] = ps->a[end+1];
		end++;
	}
	ps->size--;
}

代码测试：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include"Seqlist.h"
void test1()
{
	SeqList p;
	SeqListInit(&p);
	int i = 5;
	while(i--)
	{
		SeqListPushFront(&p, 10);
		SeqListPushFront(&p, 20);
		SeqListPushFront(&p, 30);
		SeqListPushFront(&p, 40);
		SeqListPushBack(&p, 1);
		SeqListPushBack(&p, 2);
		SeqListPushBack(&p, 3);
		SeqListPushBack(&p, 4);
		SeqListPrint(&p);
	}
	while (i++ != 3)
	{
		SeqListPopFront(&p);
		SeqListPopFront(&p);
		SeqListPopFront(&p);
		SeqListPopFront(&p);
		SeqListPopBack(&p);
		SeqListPopBack(&p);
		SeqListPopBack(&p);
		SeqListPopBack(&p);
		SeqListPrint(&p);
	}
	printf("%d \n",SeqListFind(&p, 5));
	while (i--)
	{
		SeqListInsert(&p, 4, 88);
		SeqListPrint(&p);
	}
	while (i++ != 3)
	{
		SeqListErase(&p, 4);
		SeqListPrint(&p);
	}
    SeqListDestroy(&p);
}
int main()
{
	test1();
	return 0;
}

仙茎鸣
关注
C++ 使用顺序表实现通讯录
Z_XiYu的博客
10-24 3001
C++ 使用顺序表实现通讯录 数据结构的作业，先放在这，以后有空就看一下。 查找&删除：按姓名，分别进入对应程序，查找到的信息单行显示，删除失败不进行任何改变。 插入：输入需要插入的人数和分别的姓名和电话号码来进行插入，人数超过初始化开辟的空间时，申请另一片空间，姓名重复时，提示重新输入。 显示：界面显示最新的联系人信息以及联系人数量。 销毁：退出时先销毁通讯录。 #include <string> #include <iostream> #define DEFAULT
使用顺序表实现奇偶排序
09-25
【顺序表实现奇偶排序】 在给定的问题中，我们需要对一个整数顺序表进行特殊排序，即把所有的奇数移到偶数的前面。这里我们使用C++编程语言来实现这个算法。首先，顺序表是一种数据结构，它将元素存储在连续的内存...
顺序表实现
m0_73736626的博客
07-12 1939
顺序表是用来连续存放数据单元的一种结构，逻辑连续的两个元素在实际上也为连续的。
【数据结构】顺序表实现超详解（保姆级教程）
~
10-15 2645
目录 ​ 前言 顺序表 接口实现 各项功能 接口详解 顺序表初始化 顺序表释放 顺序表展示 顺序表容量检查 顺序表数据尾插 顺序表数据头插 顺序表数据前删 顺序表数据尾删 顺序表数据查找 顺序表指定位置插入数据 顺序表指定位置删除数据 前言 本章主要讲解： 顺序表以及顺序表的接口实现 注：保姆级教程，相信你一定会的~ 顺序表 顺序表是线性标的一种 概念： 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储...
数据结构---顺序表实现
binhyun的博客
04-06 1681
顺序表的实现（C语言结构体）
用顺序表实现学生信息管理系统
热门推荐
温泉
03-30 2万+
用顺序表实现学生信息管理系统 问题描述： 定义一个包含学生信息（学号，姓名，成绩）的顺序表，使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学号和成绩； (4) 根据指定的位置可返回相应的学生信息（学号，姓名，成绩）； (5) 给定一个学生信息，插入到表中指定的位置； (6) 删除指定位置的学生记...
顺序表实现学生管理系统
weixin_44865810的博客
11-10 5531
定义一个包含学生信息（学号，姓名，成绩）的顺序表和链表，使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学号和成绩； (4) 根据指定的位置可返回相应的学生信息（学号，姓名，成绩）； (5) 给定一个学生信息，插入到表中指定的位置； (6) 删除指定位置的学生记录； (7) 统计表中学生个数。 //顺序表实现学生成绩管理系统 #include<iostream> #include<stri
顺序表实现多项式相加
qq_43599143的博客
10-30 7917
数据结构——顺序表 #include <stdio.h> #include <stdlib.h> /** =====================存储结构定义 开始======================= */ #define MAX_SIZE 128 /*顺序表中元素的类型，描述多项式中每一项的系数和指数*/ typedef struct _Elem { in...
运用顺序表实现多项式相加
分享自己的经验、IT技术，愿在博客中遇见更好的自己
09-29 1667
本题要求输入两个一元多项式，然后输出它们的和（相加后得到的一元多项式）输入格式: 输入一个整数n（表示输入组数），然后依次输入每一组数据：输入一个整数A（表示多项式的项数，小于100），然后输入A对整数，每一对整数表示对应项的指数和系数。输出格式:对每一组输入，在一行中输出得到的一元多项式。输入样例:在这里给出一组输入。例如：2 5 0 2 1 4 5 7 7 10 8 19 4 0 3 2 6 4 19 5 -9 3 0 3 4 7 8 2 3 0 -3 5 9 7 21
C语言实验-动态顺序表实现简易通讯录
wyd_333的博客
10-08 5603
C语言数据结构顺序表的应用：简易通讯录
顺序表测试1_WordforWord_用顺序表实现词频统计_
10-03
在本文中，我们将深入探讨如何使用C语言实现一个顺序表来统计单词的出现频率。顺序表是一种基础的数据结构，它将元素存储在一个连续的内存区域中，通过索引来访问元素，具有简单直观的操作方式。 首先，我们需要...
插入排序的顺序表实现代码
12-31
代码如下:#include<stdio>typedef struct { int key;}RecType;typedef struct { RecType R[100+1]; int Length;}SqList; #define N 11//为测试方便，直接输入11个整数void InsertSort(SqList *L){ int i,j;...
约瑟夫环_用顺序表实现约瑟夫环问题_
10-04
此外，还可以优化算法，例如使用模运算减少计数过程中的重复计算，但这超出了基本的顺序表实现范畴。 总的来说，约瑟夫环问题的解决提供了一种理解数据结构和算法设计思路的典型例子，同时也让我们思考如何在有限的...
学生信息管理系统的顺序表实现
10-29
### 学生信息管理系统的顺序表实现 #### 案例背景与目标 在教育领域，班级不仅是学生学习和生活的基础单位，也是管理和组织教学活动的重要载体。因此，设计一个有效的班级管理系统对于提升学校的管理水平至关重要...
【数据结构-栈】【贪心】力扣2434. 使用机器人打印字典序最小的字符串
sjsjs11的博客
10-12 369
我们可以思考，将t想象成一个栈，先进后出，然后当栈顶元素的值，也就是t的末尾的值比字符串s中的任何一个字符都要小的时候，那么我们就要将栈顶元素推入p中，也就是写出来的字符串，这样才能保证最小字典序列。，由于0代表a，1代表b…执行第一个操作四次，得到 p=“” ，s=“” ，t=“bdda”。执行第一个操作三次，得到 p=“” ，s=“” ，t=“zza”。执行第一个操作，得到 p=“ab” ，s=“” ，t=“c”。执行第二个操作，得到 p=“abc” ，s=“” ，t=“”。
前端常用算法和数据结构
renqq001的博客
10-17 306
前端常用算法和数据结构
数据结构(8.2_1)——插入排序
最新发布
m0_65240792的博客
10-17 210
算法思想：每次将一个待排序的记录按其关键字大小插入到前面已排序好的子序列中，直到全部记录插入完成。 代码实现 (带哨兵) 空间复杂度：O(1)时间复杂度:主要来自对比关键字，移动元素，若有n个元素，则需要n-1趟处理最好情况：共n-1趟处理，每一趟只需要对比关键字1次，不用移动元素———O(n)最坏情况：第1趟：对比关键字2次，移动元素3次第2趟：对比关键字3次，移动元素4次...第i趟：对比关键字i+1次，移动元素i+2次———O(n^2)平均时间复杂度：O(n^2) 思路：先用折半查找
浙大数据结构：10-排序4 统计工龄
qq_74924951的博客
10-14 181
简单题
使用顺序表实现个人通讯录管理
"使用顺序表实现简单的通讯录系统，包括数据结构、添加、显示和删除功能。" 在本文中，我们将探讨如何使用顺序表来创建一个基本的通讯录系统。顺序表是一种线性数据结构，其中元素按照它们被添加的顺序进行存储。在...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值