顺序表实现

最新推荐文章于 2024-08-29 16:57:08 发布
最新推荐文章于 2024-08-29 16:57:08 发布
阅读量388 收藏 7
点赞数 7
分类专栏： # 基本数据结构 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53903743/article/details/136122320
版权
本文档详细介绍了如何在C++中使用SeqList.h实现动态顺序表，包括初始化、销毁、尾部和头部插入/删除、检查容量并扩容以及查找和删除特定位置的数据。提供了测试代码来演示这些功能的使用。
摘要由CSDN通过智能技术生成

SeqList.h

#pragma once    // 防止重复包含
//---------动态顺序表------------//
#include <stdlib.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <assert.h>
#define M 1000
 
// 加入typedef 可以进行简写
typedef int SLDateType;   // 数据类型
typedef struct Seqlist
{
	SLDateType* a;
	int size;  // 记录存储了多少个有效数据
	int capacity; //空间容量大小
}SL;
void SLInit(SL* ps);  //初始化   
 
void SLDestory(SL* ps); //销毁   
 
void SLPushBack(SL* ps, SLDateType x);  // 尾插  
 
void SLPrint(SL* ps);  //打印函数  
 
void SLPopBack(SL* ps); //尾删    
 
void SLPushFront(SL* ps, SLDateType x); //头插 
 
void SLPopFront(SL* ps);  //头删
 
void SLCheckCapacity(SL* ps);  //检查是否需要扩容
 
//中间插入删除
void SLInsert(SL* ps, int pos, SLDateType x);  //在pos位置插入数据
 
void SLErase(SL* ps, int pos); //删除pos位置的数据
 
void SLsize(SL* ps);  // 测试 size 的值
 
int SLFind(SL* ps, SLDateType x);  //查找某一个数字的位置
 
int SLFinds(SL* ps, SLDateType x, int begin);   // 确定查找数字的起始位置

Seqlist.c

#define  _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"
 
void SLPrint(SL *ps)  // 打印函数
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
 
// 测试 size 的值
void SLsize(SL* ps)
{
	assert(ps);
	printf("%d\n", ps->size);
}
 
void SLInit(SL *ps)   // 初始化
{
	assert(ps);
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}
 
//检查是否需要扩容
void SLCheckCapacity(SL* ps)
{
	assert(ps);
	// 扩容
	if (ps->size == ps->capacity)//检查是否越界
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDateType* temp = (SLDateType*)realloc(ps->a, newCapacity * sizeof(SLDateType));    //realloc 的用法
		if (temp == NULL)
		{
			perror("realloc fail");
			exit(-1);      //异常终止
		}
		ps->a = temp;
		ps->capacity = newCapacity;
	}
}
 
void SLDestory(SL* ps)   //销毁
{
	assert(ps);
	if (ps->a != NULL)
	{
		free(ps->a);
		ps->a = NULL;
		ps->size = ps->capacity = 0;
	}
}
 
void SLPushBack(SL* ps, SLDateType x)   // 尾部插入数据
{
	assert(ps);
	// 检查是否需要扩容
	SLCheckCapacity(ps);
	// 进行尾部插入
	ps->a[ps->size] = x;
	ps->size++;
}
 
void SLPopBack(SL* ps)  //尾部删除数据
{
	assert(ps);
	//ps->a[ps->size - 1] = 0;   // size 是从 0 开始的 所以要减去 1
	// 温柔的方式
	/*if (ps->size == 0)
	{
		printf("顺序表已空\n");
		return;
	}*/
	// 暴力的方式
	assert(ps->size > 0);
	ps->size--;
}
 
// 头插  O(N)  尽量用尾插  
// 需要从最后一个数据开始依次向后挪动，空出第一个位置，保证头插的位置
void SLPushFront(SL* 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++;
}
 
// 头删  O(1)
// 需要从前往后挪
void SLPopFront(SL* ps) 
{
	assert(ps);
	assert(ps->size > 0);  //暴力检查
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}
 
//在pos位置插入数据
void SLInsert(SL* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos >= 0);    // pos 的位置，因该在有效位置
	assert(pos <= ps->size);  // 等于 “=” 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++;
}
 
//删除pos位置的数据
 
// 其中 SLErase(ps,0) 就是头删
// 其中 SLErase(ps,ps-size-1)  就是尾删
 
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos < ps->size);
	assert(ps->size > 0);  //检查 size 是否为空
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}
 
// 查找某一个数据的位置是
int SLFind(SL* ps, SLDateType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}
 
// begin 查找 x 的起始位置
int SLFinds(SL* ps, SLDateType x, int begin)
{
	assert(ps);
	for (int i = begin; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

test.c

#define  _CRT_SECURE_NO_WARNINGS 1
//  ----------- 顺序表 ----------- //
 
// 顺序表：顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，
// 一般情况下采用数组存储。在数组上完成数据的增删查改。
// 重点：要求连续存储   与数组的区别 ：数组是随意存储
// 而顺序表 是连续的存储必须是挨着的
 
// 1.静态顺序表  --- 不太实用
// 对于数组开打了，浪费 。开少了，不够用
 
// 2.动态顺序表 --- 按需扩展空间
#include "SeqList.h"
// 头插测试 
void TestSeqList3()
{
	SL s1;  // 创建一个结构体变量
	SLInit(&s1);  // 把结构体变量的地址传过去
	SLPushFront(&s1, 1);
	SLPushFront(&s1, 2);
	SLPushFront(&s1, 3);
	SLPushFront(&s1, 4);
 
	SLPrint(&s1);  // 4 3 2 1
	SLDestory(&s1);
}
//头删测试
void TestSeqList4()
{
	SL s1;  // 创建一个结构体变量
	SLInit(&s1);  // 把结构体变量的地址传过去
	SLPushFront(&s1, 1);
	SLPushFront(&s1, 2);
	SLPushFront(&s1, 3);
	SLPushFront(&s1, 4);
	SLPrint(&s1);
 
	SLPopFront(&s1);
	SLPopFront(&s1);
	SLPopFront(&s1);
	SLPopFront(&s1); 
	//SLPopFront(&s1);
 
	SLPrint(&s1);
 
	SLPushFront(&s1, 9);
	SLPrint(&s1);
	SLDestory(&s1);
}
// 测试 size 的值
// 注意 size 的值是从 0 开始的
void TestSeqList5()
{
	SL s1;  // 创建一个结构体变量
	SLInit(&s1);  // 把结构体变量的地址传过去
	SLPushFront(&s1, 1);
	SLPushFront(&s1, 2);
	SLPushFront(&s1, 3);
	SLPushFront(&s1, 4);
	SLPrint(&s1);   // 4 3 2 1
	SLsize(&s1);    // 4  也就是说，size 占了 5 个位置
	SLDestory(&s1);
 
}
 
// 测试任意位置的插入SLInsert
void TestSeqList6()
{
	SL s1;  // 创建一个结构体变量
	SLInit(&s1);  // 把结构体变量的地址传过去
	SLPushBack(&s1, 1);
	SLPushBack(&s1, 2);
	SLPushBack(&s1, 3);
	SLPushBack(&s1, 4);
	SLPrint(&s1);   // 1 2 3 4
 
	SLInsert(&s1, 2, 20); 
	SLPrint(&s1);    // 1 2 20 3 4
 
	SLInsert(&s1, 5, 500);  
	SLPrint(&s1);  // 1 2 20 3 4 500   //尾插
 
	SLInsert(&s1, 0, 400); // 400 1 2 20 3 4 500   // 头插
	SLPrint(&s1);
	SLDestory(&s1);
 
}
 
// 测试任意位置的删除 SLErase
void TestSeqList7()
{
	SL s1;  // 创建一个结构体变量
	SLInit(&s1);  // 把结构体变量的地址传过去
	SLPushBack(&s1, 1);
	SLPushBack(&s1, 2);
	SLPushBack(&s1, 3);
	SLPushBack(&s1, 4);
	SLPrint(&s1);   // 1 2 3 4
 
	SLErase(&s1, 2);
	SLPrint(&s1);  // 1 2 4
 
	SLErase(&s1, 2);
	SLPrint(&s1);  // 1 2 
	SLErase(&s1, 0);
	SLPrint(&s1);  // 2
	SLDestory(&s1);
}
 
// 测试查找某一个数字,并将这个是数字删除
void TestSeqList8()
{
	SL s1;  // 创建一个结构体变量
	SLInit(&s1);  // 把结构体变量的地址传过去
	SLPushBack(&s1, 1);
	SLPushBack(&s1, 2);
	SLPushBack(&s1, 3);
	SLPushBack(&s1, 4);
	SLPushBack(&s1, 5);
	SLPushBack(&s1, 6);
	SLPushBack(&s1, 7);
	SLPushBack(&s1, 8);
	SLPrint(&s1);   // 1 2 3 4 5 6 7 8
 
	int pos = SLFind(&s1, 5);
	if (pos != -1)
	{
		SLErase(&s1, pos);
	}
	SLPrint(&s1);  // 1 2 3 4 6 7 8
 
	SLDestory(&s1);
}
 
// 测试 删除顺序表中 所有的 5 
void TestSeqList9()
{
	SL s1;  // 创建一个结构体变量
	SLInit(&s1);  // 把结构体变量的地址传过去
	SLPushBack(&s1, 1);
	SLPushBack(&s1, 5);
	SLPushBack(&s1, 3);
	SLPushBack(&s1, 4);
	SLPushBack(&s1, 5);
	SLPushBack(&s1, 5);
	SLPushBack(&s1, 7);
	SLPushBack(&s1, 8);
	SLPrint(&s1);   // 1 5 3 4 5 5 7 8
 
	int pos = SLFinds(&s1, 5, 0);
	while (pos != -1)
	{
		SLErase(&s1, pos);
		pos = SLFinds(&s1, 5, pos);
	}
	SLPrint(&s1);  // 1 3 4 7 8
 
	SLDestory(&s1);  
}
 
// 越界是不一定报错的
// 越界 读 基本都查不出来 只能是程序的值会出现值
// 越界 写 可能会报错
 
void menu()
{
	printf("***********************************************************\n");
	printf("1、尾插数据             2、尾删数据\n");
	printf("\n");
	printf("3、头插数据             4、头删数据\n");
	printf("\n");
	printf("5、在任意位置插入数据（位置3插入20）\n");
	printf("\n");
	printf("6、在任意位置删除数据              \n"); 
	printf("\n");
	printf("7、查找某个数据的位置，并删除它     \n");
	printf("\n");
	printf("8、删除顺序表中有的 某个数据        \n");
	printf("\n");
	printf("9、打印数据                       \n");
	printf("\n");
	printf("-1、退出                          \n");
	printf("\n");
	printf("***********************************************************\n");
 
}
 
int main()
{
	printf("*************  欢迎大家来到动态顺序表的测试  **************\n");
	int option = 0;
	SL s;
	SLInit(&s);
	do
	{
		menu();
		printf("请输入你的操作：>");
		scanf("%d", &option);
		int sum = 0;
		int x = 0;
		int y = 0;
		int z = 0;
		int pos = 0;
		int w = 0;
		switch (option)
		{
		case 1:
			printf("请依次输入你要尾插的数据：，以-1结束\n");
			scanf("%d", &sum);
			while (sum != -1) 
			{
				SLPushBack(&s, sum);    // 1.尾插
				scanf("%d", &sum);
			}
			break;
		case 2:  
			SLPopBack(&s);             // 2.尾删
			break;
		case 3:
			scanf("%d", &x);
			SLPushFront(&s, x);       // 3.头插
			break;
		case 4:
			SLPopFront(&s);           // 4.头删
			break;
		case 5:
			SLInsert(&s, 3, 20);     // 5.在任意位置插入数据
			break;
		case 6:
			SLErase(&s, 3);          // 6.在任意位置删除数据
			break;
		case 7:
			printf("请输入要删除序列的中的某个数字\n");
			scanf("%d", &z);
			y = SLFind(&s, z);        // 7.查找某个数字的位置，并且删除它
			printf("%d的位置在%d处： \n", z, y);
			if (y != -1)
			{
				SLErase(&s, y);
			}
			break;
		case 8:
			printf("请输入要删除序列的中的数字\n");  //8.删除顺序表中 所有的 某个数据 
			scanf("%d", &w);
		     pos = SLFinds(&s, w, 0);
			while (pos != -1)
			{
				SLErase(&s, pos);
				pos = SLFinds(&s, w, pos);
			}
			break;
		case 9:
			SLPrint(&s);
			break;
		default:
			if (option == -1)
			{
				exit(0);  // 退出程序 
			}
			else
			{
				printf("输入错误，请重新输入\n");
			}
			break;
 
		}
	} while (option != -1);   // 退出程序
	SLDestory(&s);
	return 0;
}
英雄哪里出来_
关注
  • 7
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用顺序表实现奇偶排序
09-25
【顺序表实现奇偶排序】 在给定的问题中，我们需要对一个整数顺序表进行特殊排序，即把所有的奇数移到偶数的前面。这里我们使用C++编程语言来实现这个算法。首先，顺序表是一种数据结构，它将元素存储在连续的内存...
学生信息管理系统的顺序表实现
10-29
### 学生信息管理系统的顺序表实现 #### 案例背景与目标 在教育领域，班级不仅是学生学习和生活的基础单位，也是管理和组织教学活动的重要载体。因此，设计一个有效的班级管理系统对于提升学校的管理水平至关重要...
【数据结构】顺序表实现超详解（保姆级教程）
~
10-15 2422
目录 ​ 前言 顺序表 接口实现 各项功能 接口详解 顺序表初始化 顺序表释放 顺序表展示 顺序表容量检查 顺序表数据尾插 顺序表数据头插 顺序表数据前删 顺序表数据尾删 顺序表数据查找 顺序表指定位置插入数据 顺序表指定位置删除数据 前言 本章主要讲解： 顺序表以及顺序表的接口实现 注：保姆级教程，相信你一定会的~ 顺序表 顺序表是线性标的一种 概念： 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储...
用顺序表实现学生信息管理系统
热门推荐
温泉
03-30 2万+
用顺序表实现学生信息管理系统 问题描述： 定义一个包含学生信息（学号，姓名，成绩）的顺序表，使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学号和成绩； (4) 根据指定的位置可返回相应的学生信息（学号，姓名，成绩）； (5) 给定一个学生信息，插入到表中指定的位置； (6) 删除指定位置的学生记...
顺序表实现学生管理系统
weixin_44865810的博客
11-10 5399
定义一个包含学生信息（学号，姓名，成绩）的顺序表和链表，使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学号和成绩； (4) 根据指定的位置可返回相应的学生信息（学号，姓名，成绩）； (5) 给定一个学生信息，插入到表中指定的位置； (6) 删除指定位置的学生记录； (7) 统计表中学生个数。 //顺序表实现学生成绩管理系统 #include<iostream> #include<stri
C语言实验-动态顺序表实现简易通讯录
wyd_333的博客
10-08 5386
C语言数据结构顺序表的应用：简易通讯录
顺序表实现集合并集运算
qq_42285148的博客
05-30 4218
【问题描述】 设有两个用顺序表表示的有序集合，输出它们的并集，要求仍然保持有序。 【输入形式】 第一行输入两个整数N和M（不大于100），分别表示两个集合的长度； 第二行输入第一个集合的N个元素（递增有序）； 第三行输入第二个集合的M个元素（递增有序）； 【输出形式】 输出两个集合的并集（仍然保持有序），元素之间以空格分隔。 【样例输入】 5 4 -3 2 4 7 20 2 3 4 5 【样例输出】 -3 2 3 4 7 20 ...
数据结构 顺序表实现手机通讯录
taotu_tao的博客
03-29 5939
代码 #include <stdio.h> #include <malloc.h> #include <string.h> #include <stdlib.h> #include <windows.h> #include <conio.h> //#include <stack> typedef struct { char name[10]; char tel[12]; }ElemType; typedef s
C++实现顺序表
qq_45139003的博客
11-15 1万+
c++实现顺序表中的基本操作： 1、顺序表的初始化 2、顺序表的创建 3、顺序表的插入 4、顺序表的删除 5、顺序表的查找 6、顺序表的取值 7、顺序表的清空 8、顺序表的长度 9、顺序表的判空 10、顺序表的打印 /* Project: sequence_list(数据结构-顺序表) Date: 2021/11/15 InitList(SqList &L) 参数：顺序表L 功能：初始化 时间复杂度:O(1) CreateList(SqList &L,int n) 参数：顺序表L，顺
c语言学生成绩管理系统（顺序表实现）
weixin_52119087的博客
09-19 3004
c语言学生成绩管理系统,c结构体，结构体指针，结构体数组。
数据结构实验2：用链表和顺序表实现两个多项式的加法运算
m0_46663240的博客
04-26 3649
实现多项式求和运算简单，但是这个输入格式，让简单的加法变得不好实现了。 几个步骤： 偶数位保存系数，奇数位保存项数。 建两个线性表，s1和s2，双重循环遍历，s2中寻找和s1线性表中相同的偶数位，如果相同，s2中data[i-1]加s1的代表合并同类项，如果没找到，则把这个点插入s2。 最后对s2的遍历输出，如果要按项高低拍就建个结构体，排序后输出。 全部代码...
顺序表实现交集，并集，差集
edceee的博客
04-06 3706
#include <stdio.h> #define MAXSIZE 30 typedef int datatype; typedef struct { datatype data[MAXSIZE]; int last; }SeqList; //实现集合的并 void Union(SeqList A,SeqList B,SeqList *C){ int i=0,j=0,k=0; while(i<=A.last&&j<=B.last) { if(A
顺序表测试1_WordforWord_用顺序表实现词频统计_
10-03
在本文中，我们将深入探讨如何使用C语言实现一个顺序表来统计单词的出现频率。顺序表是一种基础的数据结构，它将元素存储在一个连续的内存区域中，通过索引来访问元素，具有简单直观的操作方式。 首先，我们需要...
约瑟夫环_用顺序表实现约瑟夫环问题_
10-04
此外，还可以优化算法，例如使用模运算减少计数过程中的重复计算，但这超出了基本的顺序表实现范畴。 总的来说，约瑟夫环问题的解决提供了一种理解数据结构和算法设计思路的典型例子，同时也让我们思考如何在有限的...
插入排序的顺序表实现代码
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;...
算法的学习笔记—连续子数组的最大和
最新发布
业精于勤，荒于嬉
08-29 1052
通过上述的动态规划方法，我们能够有效地解决连续子数组的最大和问题。该方法简单易懂，并且具有较高的效率，适合在大多数情况下使用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞。
递归、搜索与回溯算法
无聊_人的博客
08-29 546
所谓的递归其实就是函数自己调用自己的情况。
力扣（无重叠区间）
yyssas的博客
08-29 494
先按照左侧数字排序，然后对于i位置和i+1位置，如果i位置右侧数字大于i+1位置左侧数字，则说明这两个区间有重叠，则需要移除更可能和后面重叠的那一个，因为排序是按照左边从小到大排序的，所以左边一定是小的，此时要关注的就是右边，也就是选择i和i+1右侧更小的那个，即右侧大的那个删除。一直到右侧小于k的左侧停止，此时剩下的一定是不会重叠的那个。需要移除区间的最小数量，使剩余区间互不重叠。
7-7 数组中能被5整除的数的和
Virgo_616的博客
08-26 489
在一维数组中有10个整数，求出其中能被5整除的所有数的和。
顺序表实现与操作
本资源提供了一个简单的顺序表（Sequence List）实现，用于演示数据结构的基本操作。 顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储。这个实现中，顺序表由一个名为`Vector`的结构体表示，包含三个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值